Add extension hooks for model requests and response streams (#47679)

## What changed

Add `ModelRequestContributor` and `ModelResponseInterceptor` to the extension API. Contributors can add filtered `client_metadata` without overwriting existing or reserved fields and create interceptors for individual requests.

Wire contributors into HTTP and WebSocket requests, distinguishing generation from warmup. Apply response interceptors in registration order before tracing and response bookkeeping so transformed output is recorded consistently. Interceptors can inspect, buffer, or transform events, with stream ownership carrying request state and cancellation.

## Testing

Add tests for metadata protection, incremental event transformation, interceptor ordering, upstream cancellation, and consistency between delivered output, traces, and WebSocket bookkeeping. Integration tests cover output gating and interruption over HTTP and WebSocket, including a contributor that bypasses gating for warmup requests.

GitOrigin-RevId: d4bc1745d2cacf8636728dbc0a58ab9f250e9392
This commit is contained in:
Ruslan Nigmatullin
2026-09-23 22:10:04 +00:00
committed by copyberry
parent 9477081ccd
commit 8de2d336b8
18 changed files with 550 additions and 2 deletions
+25 -1
View File
@@ -266,6 +266,7 @@ pub struct ModelClient {
event_sender: Option<Sender<ProtocolEvent>>,
http_client_factory: HttpClientFactory,
restored_history: bool,
request_contributors: Vec<Arc<dyn codex_extension_api::ModelRequestContributor>>,
}
/// A turn-scoped streaming session created from a [`ModelClient`].
@@ -496,6 +497,7 @@ impl ModelClient {
attestation_provider: Option<Arc<dyn AttestationProvider>>,
http_client_factory: HttpClientFactory,
workspace_routing: WorkspaceRoutingContext,
request_contributors: Vec<Arc<dyn codex_extension_api::ModelRequestContributor>>,
) -> Self {
let model_provider = create_model_provider(provider_info, auth_manager);
let codex_api_key_env_enabled = model_provider
@@ -542,6 +544,7 @@ impl ModelClient {
event_sender: None,
http_client_factory,
restored_history: false,
request_contributors,
}
}
@@ -1731,6 +1734,13 @@ impl ModelClientSession {
let request_session_telemetry =
session_telemetry_for_request(session_telemetry, &request);
options.extra_headers.extend(responses_headers);
let interceptors = crate::model_request::prepare(
&self.client.request_contributors,
&self.client.state.thread_id.to_string(),
&model_info.slug,
codex_extension_api::ModelRequestKind::Generation,
&mut request.client_metadata,
);
let inference_trace_attempt = inference_trace.start_attempt();
inference_trace_attempt.add_request_headers(&mut options.extra_headers);
inference_trace_attempt.record_started(&request);
@@ -1749,6 +1759,7 @@ impl ModelClientSession {
request_session_telemetry,
inference_trace_attempt,
Arc::clone(&self.client.state.provider),
interceptors,
);
return Ok(stream);
}
@@ -1998,6 +2009,17 @@ impl ModelClientSession {
client_setup.auth.as_ref(),
&responses_headers,
);
let interceptors = crate::model_request::prepare(
&self.client.request_contributors,
&self.client.state.thread_id.to_string(),
&model_info.slug,
if warmup {
codex_extension_api::ModelRequestKind::Warmup
} else {
codex_extension_api::ModelRequestKind::Generation
},
&mut ws_payload.client_metadata,
);
let mut ws_request = ResponsesWsRequest::ResponseCreate(ws_payload);
stamp_ws_stream_request_start_ms(&mut ws_request);
if !previous_response_id_from_untraced_warmup {
@@ -2048,6 +2070,7 @@ impl ModelClientSession {
request_session_telemetry,
inference_trace_attempt,
Arc::clone(&self.client.state.provider),
interceptors,
);
self.websocket_session.last_response_rx = Some(last_request_rx);
return Ok(WebsocketStreamOutcome::Stream(stream));
@@ -2287,6 +2310,7 @@ fn map_response_stream(
session_telemetry: SessionTelemetry,
inference_trace_attempt: InferenceTraceAttempt,
provider: SharedModelProvider,
interceptors: Vec<Box<dyn codex_extension_api::ModelResponseInterceptor>>,
) -> (ResponseStream, oneshot::Receiver<LastResponse>) {
let codex_api::ResponseStream {
rx_event,
@@ -2298,7 +2322,7 @@ fn map_response_stream(
};
map_response_events(
upstream_request_id,
api_stream,
crate::model_request::intercept_stream(Box::pin(api_stream), interceptors),
session_telemetry,
inference_trace_attempt,
provider,
+68
View File
@@ -130,6 +130,7 @@ fn test_model_client_with_thread_id(
codex_model_provider::WorkspaceRoutingContext::new(
"https://chatgpt.com/backend-api".into(),
),
Vec::new(),
)
}
@@ -1729,6 +1730,7 @@ fn model_client_with_counting_attestation(
codex_model_provider::WorkspaceRoutingContext::new(
"https://chatgpt.com/backend-api".into(),
),
Vec::new(),
);
(model_client, attestation_calls)
}
@@ -1858,3 +1860,69 @@ async fn non_chatgpt_codex_endpoints_omit_attestation_generation() {
);
assert_eq!(attestation_calls.load(Ordering::Relaxed), 0);
}
#[tokio::test]
async fn intercepted_output_reaches_trace_and_websocket_bookkeeping() -> anyhow::Result<()> {
struct ReplaceOutput;
impl codex_extension_api::ModelResponseInterceptor for ReplaceOutput {
fn intercept(
self: Box<Self>,
stream: codex_extension_api::ModelResponseStream,
) -> codex_extension_api::ModelResponseStream {
Box::pin(stream.map(|event| {
event.map(|event| match event {
ResponseEvent::OutputItemDone(_) => {
ResponseEvent::OutputItemDone(output_message("1", "transformed"))
}
other => other,
})
}))
}
}
let temp = TempDir::new()?;
let attempt = started_inference_attempt(&temp)?;
let (tx_event, rx_event) = tokio::sync::mpsc::channel(2);
tx_event
.send(Ok(ResponseEvent::OutputItemDone(output_message(
"1", "original",
))))
.await?;
tx_event
.send(Ok(ResponseEvent::Completed {
response_id: "response".into(),
token_usage: None,
usage_metadata: None,
end_turn: None,
}))
.await?;
drop(tx_event);
let (mut stream, last_response) = super::map_response_stream(
codex_api::ResponseStream {
rx_event,
upstream_request_id: None,
},
test_session_telemetry(),
attempt,
test_model_provider(),
vec![Box::new(ReplaceOutput)],
);
let mut delivered = Vec::new();
while let Some(event) = stream.next().await {
if let ResponseEvent::OutputItemDone(item) = event? {
delivered.push(item);
}
}
assert_eq!(delivered, vec![output_message("1", "transformed")]);
assert_eq!(last_response.await?.items_added, delivered);
let rollout = replay_bundle(temp.path())?;
let payload = rollout
.raw_payloads
.values()
.find(|payload| payload.kind == codex_rollout_trace::RawPayloadKind::InferenceResponse)
.expect("response trace payload");
let recorded: serde_json::Value =
serde_json::from_slice(&std::fs::read(temp.path().join(&payload.path))?)?;
assert_eq!(recorded["output_items"], serde_json::to_value(&delivered)?);
Ok(())
}
+1
View File
@@ -9,6 +9,7 @@ mod apply_patch;
mod apps;
mod client;
mod client_common;
mod model_request;
mod realtime_context;
mod realtime_conversation;
mod realtime_history;
+51
View File
@@ -0,0 +1,51 @@
//! Compose request-scoped response interceptors before tracing and response bookkeeping.
use codex_extension_api::ModelRequestContributor;
use codex_extension_api::ModelRequestInput;
use codex_extension_api::ModelRequestKind;
use codex_extension_api::ModelResponseInterceptor;
use codex_extension_api::ModelResponseStream;
use std::collections::HashMap;
use std::sync::Arc;
pub(crate) fn prepare(
contributors: &[Arc<dyn ModelRequestContributor>],
thread_id: &str,
model: &str,
kind: ModelRequestKind,
metadata: &mut Option<HashMap<String, String>>,
) -> Vec<Box<dyn ModelResponseInterceptor>> {
contributors
.iter()
.filter_map(|contributor| {
let mut additions = None;
let interceptor = contributor.request(ModelRequestInput {
kind,
thread_id,
client_metadata: &mut additions,
model,
});
if let Some(additions) = additions {
for (key, value) in crate::responses_metadata::filter_extra_metadata(additions) {
if key != "parent_response_id" {
metadata.get_or_insert_default().entry(key).or_insert(value);
}
}
}
interceptor
})
.collect()
}
pub(crate) fn intercept_stream(
mut stream: ModelResponseStream,
interceptors: Vec<Box<dyn ModelResponseInterceptor>>,
) -> ModelResponseStream {
for interceptor in interceptors {
stream = interceptor.intercept(stream);
}
stream
}
#[cfg(test)]
#[path = "model_request_tests.rs"]
mod tests;
+104
View File
@@ -0,0 +1,104 @@
//! Interceptors can transform incremental events and retain upstream cancellation.
use super::*;
use crate::client_common::ResponseStream;
use codex_extension_api::ResponseEvent;
use futures::StreamExt;
use pretty_assertions::assert_eq;
use std::time::Duration;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
struct Append(&'static str);
impl ModelResponseInterceptor for Append {
fn intercept(self: Box<Self>, stream: ModelResponseStream) -> ModelResponseStream {
Box::pin(stream.map(move |event| {
event.map(|event| match event {
ResponseEvent::OutputTextDelta(text) => {
ResponseEvent::OutputTextDelta(format!("{text}{}", self.0))
}
other => other,
})
}))
}
}
#[tokio::test]
async fn interceptors_forward_before_completion_in_order_and_cancel_upstream() {
let (tx_event, rx_event) = mpsc::channel(1);
let consumer_dropped = CancellationToken::new();
let upstream_cancelled = consumer_dropped.clone();
let mut stream = intercept_stream(
Box::pin(
ResponseStream {
rx_event,
consumer_dropped,
}
.map(|event| {
event.map_err(|error| {
codex_extension_api::ModelResponseError::Stream(error.to_string())
})
}),
),
vec![Box::new(Append("a")), Box::new(Append("b"))],
);
tx_event
.send(Ok(ResponseEvent::OutputTextDelta("text".into())))
.await
.unwrap();
// Upstream remains open and has not sent Completed.
let event = tokio::time::timeout(Duration::from_secs(1), stream.next())
.await
.unwrap()
.unwrap()
.unwrap();
let ResponseEvent::OutputTextDelta(text) = event else {
panic!("expected text delta");
};
assert_eq!(text, "textab");
drop(stream);
tokio::time::timeout(Duration::from_secs(1), upstream_cancelled.cancelled())
.await
.unwrap();
}
#[derive(Debug)]
struct MetadataContributor;
impl ModelRequestContributor for MetadataContributor {
fn request(&self, input: ModelRequestInput<'_>) -> Option<Box<dyn ModelResponseInterceptor>> {
*input.client_metadata = Some(HashMap::from([
("thread_id".into(), "replaced".into()),
("guardian_credits_requested".into(), "true".into()),
("parent_response_id".into(), "forged".into()),
("existing".into(), "replaced".into()),
("x-request-id".into(), "request".into()),
]));
None
}
}
#[test]
fn contributor_metadata_preserves_core_fields_and_existing_values() {
let mut metadata = Some(HashMap::from([
("thread_id".into(), "thread".into()),
("existing".into(), "original".into()),
]));
let contributors: Vec<Arc<dyn ModelRequestContributor>> = vec![Arc::new(MetadataContributor)];
assert!(
prepare(
&contributors,
"thread",
"model",
ModelRequestKind::Generation,
&mut metadata
)
.is_empty()
);
assert_eq!(
metadata,
Some(HashMap::from([
("thread_id".into(), "thread".into()),
("existing".into(), "original".into()),
("x-request-id".into(), "request".into()),
]))
);
}
+2 -1
View File
@@ -1689,7 +1689,7 @@ impl Session {
agents_md_manager,
plugins_manager: Arc::clone(&plugins_manager),
mcp_manager: Arc::clone(&mcp_manager),
extensions,
extensions: Arc::clone(&extensions),
// TODO(jif): extract session to share between sub-agents
session_extension_data,
thread_extension_data,
@@ -1731,6 +1731,7 @@ impl Session {
attestation_provider,
config.http_client_factory(),
workspace_routing.as_ref().clone(),
extensions.model_request_contributors().to_vec(),
)
.with_restored_history(matches!(
&initial_history,
+3
View File
@@ -847,6 +847,7 @@ fn test_model_client_session() -> crate::client::ModelClientSession {
codex_model_provider::WorkspaceRoutingContext::new(
"https://chatgpt.com/backend-api".into(),
),
Vec::new(),
)
.new_session()
}
@@ -6528,6 +6529,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
/*attestation_provider*/ None,
config.http_client_factory(),
config.workspace_routing_context(),
Vec::new(),
),
executed_tool_calls: executed_tool_calls.clone(),
code_mode_service: crate::tools::code_mode::CodeModeService::new(
@@ -8798,6 +8800,7 @@ where
/*attestation_provider*/ None,
config.http_client_factory(),
config.workspace_routing_context(),
Vec::new(),
),
executed_tool_calls: executed_tool_calls.clone(),
code_mode_service: crate::tools::code_mode::CodeModeService::new(