From 4c0407e3e08951df3598be56d0d0a13e77dd0de3 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 24 Aug 2026 03:48:05 +0200 Subject: [PATCH] Respect Codex subscription transport limits --- epiphany-openai-codex-spine/src/lib.rs | 30 +++++++++++ .../src/model_connector.rs | 50 ++++++++++++++++++- 2 files changed, 79 insertions(+), 1 deletion(-) diff --git a/epiphany-openai-codex-spine/src/lib.rs b/epiphany-openai-codex-spine/src/lib.rs index 028e9f53..8f4f60ce 100644 --- a/epiphany-openai-codex-spine/src/lib.rs +++ b/epiphany-openai-codex-spine/src/lib.rs @@ -181,6 +181,7 @@ impl EpiphanyCodexOpenAiTransport { .unwrap_or_else(|| default_base_url_for_auth(auth).to_string()); let url = format!("{}/responses", base_url.trim_end_matches('/')); let conversation_id = request.conversation_id.clone(); + let request = request_for_responses_backend(request, auth.uses_codex_backend()); let mut outbound = Request::new(http::Method::POST, url) .with_json(&responses_body_from_epiphany(request)?); attach_codex_auth_headers(auth, &mut outbound.headers) @@ -209,6 +210,18 @@ impl EpiphanyCodexOpenAiTransport { } } +fn request_for_responses_backend( + mut request: EpiphanyOpenAiModelRequest, + uses_codex_backend: bool, +) -> EpiphanyOpenAiModelRequest { + if uses_codex_backend { + // The ChatGPT Codex subscription boundary rejects this otherwise + // standard Responses parameter. Callers retain and verify their bound. + request.max_output_tokens = None; + } + request +} + /// OpenRouter owns a distinct credential and wire dialect. It is intentionally /// not routed through Codex auth or the Responses transport. pub struct EpiphanyOpenRouterTransport { @@ -1764,6 +1777,23 @@ mod tests { assert_eq!(responses["tool_choice"], "auto"); } + #[test] + fn codex_subscription_request_omits_unsupported_output_limit() { + let mut request = EpiphanyOpenAiModelRequest::new( + "req-codex-limit", + "conversation-codex-limit", + "gpt-5.4", + "Return a bounded answer.", + ); + request.max_output_tokens = Some(512); + + let codex = request_for_responses_backend(request.clone(), true); + let openai = request_for_responses_backend(request, false); + + assert_eq!(codex.max_output_tokens, None); + assert_eq!(openai.max_output_tokens, Some(512)); + } + #[test] fn responses_call_ids_are_one_shared_bounded_transport_projection() { assert_eq!(responses_call_id("call-1"), "call-1"); diff --git a/epiphany-openai-runtime/src/model_connector.rs b/epiphany-openai-runtime/src/model_connector.rs index a20609d5..5774bfcd 100644 --- a/epiphany-openai-runtime/src/model_connector.rs +++ b/epiphany-openai-runtime/src/model_connector.rs @@ -503,6 +503,23 @@ fn sanitize_model_events( "model provider returned an inadmissible tool call", )]; } + EpiphanyModelStreamPayload::Completed { receipt } => { + if let Some(limit) = request.max_output_tokens + && !matches!(receipt.output_tokens, Some(tokens) if tokens <= u64::from(limit)) + { + return vec![connector_failed_event( + &request.request_id, + "model provider did not prove the requested output-token bound", + )]; + } + sanitized.push(EpiphanyModelStreamEvent { + schema_id: MODEL_ADAPTER_EVENT_SCHEMA_ID.to_string(), + request_id: request.request_id.clone(), + provider: request.provider.clone(), + sequence: sanitized.len() as u64, + payload: EpiphanyModelStreamPayload::Completed { receipt }, + }); + } payload => sanitized.push(EpiphanyModelStreamEvent { schema_id: MODEL_ADAPTER_EVENT_SCHEMA_ID.to_string(), request_id: request.request_id.clone(), @@ -857,7 +874,8 @@ mod tests { #[test] fn reasoning_is_removed_and_public_events_are_renumbered() { let invocation = invocation(1_000); - let receipt = EpiphanyModelReceipt::new("request-1", "openai-codex", "gpt-5.4"); + let mut receipt = EpiphanyModelReceipt::new("request-1", "openai-codex", "gpt-5.4"); + receipt.output_tokens = Some(10); let events = vec![ EpiphanyModelStreamEvent { schema_id: MODEL_ADAPTER_EVENT_SCHEMA_ID.to_string(), @@ -899,6 +917,36 @@ mod tests { )); } + #[test] + fn connector_refuses_unproven_or_excessive_provider_output() { + let invocation = invocation(1_000); + let event = |output_tokens| EpiphanyModelStreamEvent { + schema_id: MODEL_ADAPTER_EVENT_SCHEMA_ID.to_string(), + request_id: "request-1".to_string(), + provider: "openai-codex".to_string(), + sequence: 0, + payload: EpiphanyModelStreamPayload::Completed { + receipt: { + let mut receipt = + EpiphanyModelReceipt::new("request-1", "openai-codex", "gpt-5.4"); + receipt.output_tokens = output_tokens; + receipt + }, + }, + }; + + for output_tokens in [None, Some(513)] { + let events = sanitize_model_events(&invocation.request, vec![event(output_tokens)]); + assert!(matches!( + events.as_slice(), + [EpiphanyModelStreamEvent { + payload: EpiphanyModelStreamPayload::Failed { .. }, + .. + }] + )); + } + } + #[test] fn encrypted_result_refuses_outer_identity_substitution() -> Result<()> { let security = CultNetClientSecurityOptions::new("not-a-production-secret")?;