Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

codex: use responses lite for gpt-5.6 models

Raine Virtae0342c4e9286
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index bf390cc..fca44a0 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -82,6 +82,7 @@ impl std::fmt::Display for CodexTransportError {
pub fn build_codex_headers(
auth: &StoredAuth,
ctx: &RequestContext,
+ use_responses_lite: bool,
) -> Result<http::HeaderMap, CodexError> {
let mut headers = http::HeaderMap::new();
headers.insert(
@@ -103,6 +104,12 @@ pub fn build_codex_headers(
"openai-beta",
header_value("openai-beta", "responses=experimental")?,
);
+ if use_responses_lite {
+ headers.insert(
+ "x-openai-internal-codex-responses-lite",
+ header_value("x-openai-internal-codex-responses-lite", "true")?,
+ );
+ }
if let Some(ref account_id) = auth.account_id {
headers.insert(
"ChatGPT-Account-Id",
@@ -290,10 +297,12 @@ impl CodexHttpClient {
retry_after: None,
origin: CodexErrorOrigin::Http,
})?;
- self.attempt_post_http(&auth, &body_json, ctx).await
+ self.attempt_post_http(&auth, &body_json, ctx, body.client_metadata.is_some())
+ .await
}
CodexTransport::WebSocket => {
- let ws_headers = build_codex_headers(&auth, ctx)?;
+ let ws_headers =
+ build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;
let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);
let ws_body = build_websocket_request(body, continuation);
@@ -311,7 +320,8 @@ impl CodexHttpClient {
.await
}
CodexTransport::Auto => {
- let ws_headers = build_codex_headers(&auth, ctx)?;
+ let ws_headers =
+ build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;
let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);
let ws_body = build_websocket_request(body, continuation);
@@ -344,7 +354,13 @@ impl CodexHttpClient {
retry_after: None,
origin: CodexErrorOrigin::Http,
})?;
- self.attempt_post_http(&auth, &body_json, ctx).await
+ self.attempt_post_http(
+ &auth,
+ &body_json,
+ ctx,
+ body.client_metadata.is_some(),
+ )
+ .await
}
Err(err) => Err(err),
}
@@ -418,7 +434,8 @@ impl CodexHttpClient {
super::websocket::invalidate_codex_websocket_pool_key(key);
}
- let retry_headers = build_codex_headers(&auth, ctx)?;
+ let retry_headers =
+ build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;
let full_body_json = serde_json::to_string(body).map_err(|e| CodexError {
status: 500,
message: "Failed to serialize request".to_string(),
@@ -429,7 +446,14 @@ impl CodexHttpClient {
match transport {
CodexTransport::Http => {
- return self.attempt_post_http(&auth, &full_body_json, ctx).await;
+ return self
+ .attempt_post_http(
+ &auth,
+ &full_body_json,
+ ctx,
+ body.client_metadata.is_some(),
+ )
+ .await;
}
CodexTransport::WebSocket | CodexTransport::Auto => {
let ws_retry_headers =
@@ -493,7 +517,7 @@ impl CodexHttpClient {
super::websocket::invalidate_codex_websocket_pool_key(key);
}
- let ws_headers = build_codex_headers(&auth, ctx)?;
+ let ws_headers = build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;
let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);
let ws_body = build_websocket_request(body, continuation);
@@ -575,9 +599,10 @@ impl CodexHttpClient {
auth: &StoredAuth,
body_json: &str,
ctx: &RequestContext,
+ use_responses_lite: bool,
) -> Result<CodexResponse, CodexError> {
let url = &self.base_url;
- let headers = build_codex_headers(auth, ctx)?;
+ let headers = build_codex_headers(auth, ctx, use_responses_lite)?;
if let Some(traffic) = ctx.traffic.as_deref() {
write_codex_http_request_capture(traffic, url, &headers, body_json);
@@ -885,7 +910,7 @@ mod tests {
traffic: None,
monitor: None,
};
- let headers = build_codex_headers(&auth, &ctx).unwrap();
+ let headers = build_codex_headers(&auth, &ctx, false).unwrap();
assert_eq!(
headers.get("openai-beta").unwrap(),
"responses=experimental"
@@ -893,6 +918,31 @@ mod tests {
assert_eq!(headers.get("session_id").unwrap(), "s");
}
+ #[test]
+ fn codex_headers_include_responses_lite_when_requested() {
+ let auth = StoredAuth {
+ access: "tok".into(),
+ refresh: String::new(),
+ account_id: None,
+ expires: u64::MAX,
+ };
+ let ctx = RequestContext {
+ req_id: "r".into(),
+ session_id: None,
+ session_seq: None,
+ provider: "codex".into(),
+ traffic: None,
+ monitor: None,
+ };
+ let headers = build_codex_headers(&auth, &ctx, true).unwrap();
+ assert_eq!(
+ headers
+ .get("x-openai-internal-codex-responses-lite")
+ .unwrap(),
+ "true"
+ );
+ }
+
#[test]
fn codex_headers_omit_session_when_missing() {
let auth = StoredAuth {
@@ -909,7 +959,7 @@ mod tests {
traffic: None,
monitor: None,
};
- let headers = build_codex_headers(&auth, &ctx).unwrap();
+ let headers = build_codex_headers(&auth, &ctx, false).unwrap();
assert!(headers.get("session_id").is_none());
assert!(headers.get("x-client-request-id").is_none());
}
@@ -930,7 +980,7 @@ mod tests {
traffic: None,
monitor: None,
};
- let err = build_codex_headers(&auth, &ctx).unwrap_err();
+ let err = build_codex_headers(&auth, &ctx, false).unwrap_err();
assert_eq!(err.status, 500);
assert!(err.message.contains("session_id"));
}
@@ -957,6 +1007,7 @@ mod tests {
stream: true,
parallel_tool_calls: true,
include: None,
+ client_metadata: None,
service_tier: None,
prompt_cache_key: None,
text: super::super::translate::request::ResponsesText {
@@ -1053,7 +1104,7 @@ mod tests {
traffic: None,
monitor: None,
};
- let result = build_codex_headers(&auth, &ctx);
+ let result = build_codex_headers(&auth, &ctx, false);
assert!(
result.is_ok(),
"empty access should still produce valid Bearer header"
diff --git a/src/providers/codex/count_tokens.rs b/src/providers/codex/count_tokens.rs
index a8e7d41..a0f546c 100644
--- a/src/providers/codex/count_tokens.rs
+++ b/src/providers/codex/count_tokens.rs
@@ -35,6 +35,10 @@ pub fn count_translated_tokens(translated: &ResponsesRequest) -> u64 {
fn count_input_item_tokens(item: &ResponsesInputItem) -> u64 {
match item {
+ ResponsesInputItem::AdditionalTools { tools, .. } => tools
+ .iter()
+ .map(|tool| approx_token_count(&serde_json::to_string(tool).unwrap_or_default()))
+ .sum(),
ResponsesInputItem::Message { content, .. } => {
let mut total = 0u64;
for part in content {
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index d9662c1..e833b54 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -33,7 +33,9 @@ use self::continuation::{
use self::count_tokens::count_translated_tokens;
use self::translate::accumulate::accumulate_response_with_traffic;
use self::translate::live_stream::LiveStreamTranslator;
-use self::translate::model_allowlist::{assert_allowed_model, resolve_model_request};
+use self::translate::model_allowlist::{
+ assert_allowed_model, resolve_model_request, uses_responses_lite,
+};
use self::translate::reducer::finish_metadata_from_upstream;
use self::translate::request::{TranslateOptions, translate_request};
@@ -104,6 +106,7 @@ impl Provider for CodexProvider {
session_id: ctx.session_id.clone(),
service_tier: resolved.service_tier.clone(),
model: resolved.model.clone(),
+ use_responses_lite: uses_responses_lite(&resolved.model),
},
) {
Ok(t) => t,
@@ -247,6 +250,7 @@ impl Provider for CodexProvider {
session_id: None,
service_tier: resolved.service_tier.clone(),
model: resolved.model.clone(),
+ use_responses_lite: uses_responses_lite(&resolved.model),
},
) {
Ok(t) => t,
diff --git a/src/providers/codex/request_summary.rs b/src/providers/codex/request_summary.rs
index 39906dd..cd04ac4 100644
--- a/src/providers/codex/request_summary.rs
+++ b/src/providers/codex/request_summary.rs
@@ -79,12 +79,14 @@ pub fn summarize_codex_request_size(body: &ResponsesRequest) -> CodexRequestSize
let image_parts = input_image_parts(&body.input);
let input_type_counts = count_items_by(&body.input, |item| match item {
+ ResponsesInputItem::AdditionalTools { .. } => Some("additional_tools".to_string()),
ResponsesInputItem::Message { .. } => Some("message".to_string()),
ResponsesInputItem::FunctionCall { .. } => Some("function_call".to_string()),
ResponsesInputItem::FunctionCallOutput { .. } => Some("function_call_output".to_string()),
});
let role_counts = count_items_by(&body.input, |item| match item {
+ ResponsesInputItem::AdditionalTools { role, .. } => Some(role.clone()),
ResponsesInputItem::Message { role, .. } => Some(role.clone()),
_ => None,
});
@@ -96,6 +98,9 @@ pub fn summarize_codex_request_size(body: &ResponsesRequest) -> CodexRequestSize
.enumerate()
.map(|(i, item)| {
let (r#type, role) = match item {
+ ResponsesInputItem::AdditionalTools { role, .. } => {
+ ("additional_tools".to_string(), Some(role.clone()))
+ }
ResponsesInputItem::Message { role, .. } => {
("message".to_string(), Some(role.clone()))
}
@@ -184,7 +189,12 @@ pub fn summarize_codex_request_size(body: &ResponsesRequest) -> CodexRequestSize
.map(|i| serde_json::to_value(i).unwrap_or_default())
.as_ref(),
),
- client_metadata_json_bytes: 0,
+ client_metadata_json_bytes: json_bytes(
+ body.client_metadata
+ .as_ref()
+ .map(|m| serde_json::to_value(m).unwrap_or_default())
+ .as_ref(),
+ ),
input_item_count: body.input.len(),
tool_count: body.tools.as_ref().map_or(0, |t| t.len()),
input_image_part_count: image_parts.len(),
@@ -237,6 +247,7 @@ mod tests {
stream: true,
parallel_tool_calls: true,
include: None,
+ client_metadata: None,
service_tier: None,
prompt_cache_key: None,
text: super::super::translate::request::ResponsesText {
diff --git a/src/providers/codex/translate/model_allowlist.rs b/src/providers/codex/translate/model_allowlist.rs
index f303537..84be380 100644
--- a/src/providers/codex/translate/model_allowlist.rs
+++ b/src/providers/codex/translate/model_allowlist.rs
@@ -104,6 +104,10 @@ pub fn assert_allowed_model(model: &str) -> Result<(), ModelNotAllowedError> {
}
}
+pub fn uses_responses_lite(model: &str) -> bool {
+ matches!(model, "gpt-5.6-luna" | "gpt-5.6-sol" | "gpt-5.6-terra")
+}
+
pub fn is_valid_model_for_codex(model: &str) -> bool {
if ALLOWED_MODELS.contains(&model) {
return true;
diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rs
index 3ec7efd..a7d7190 100644
--- a/src/providers/codex/translate/request.rs
+++ b/src/providers/codex/translate/request.rs
@@ -70,6 +70,8 @@ pub struct ResponsesRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub include: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
+ pub client_metadata: Option<std::collections::HashMap<String, String>>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
pub service_tier: Option<ServiceTier>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub prompt_cache_key: Option<String>,
@@ -84,6 +86,8 @@ pub struct ResponsesReasoning {
pub effort: Option<Effort>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub summary: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub context: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -111,6 +115,13 @@ pub enum ResponsesTextFormat {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ResponsesInputItem {
+ #[serde(rename = "additional_tools")]
+ AdditionalTools {
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ id: Option<String>,
+ role: String,
+ tools: Vec<Value>,
+ },
#[serde(rename = "message")]
Message {
role: String,
@@ -185,6 +196,7 @@ pub struct TranslateOptions {
pub session_id: Option<String>,
pub service_tier: Option<ServiceTier>,
pub model: String,
+ pub use_responses_lite: bool,
}
// ---------------------------------------------------------------------------
@@ -222,6 +234,13 @@ fn resolve_effort(effort: Option<Effort>) -> Result<Option<Effort>, anyhow::Erro
Ok(effort)
}
+fn cap_luna_effort(effort: Option<Effort>) -> Option<Effort> {
+ match effort {
+ Some(Effort::High | Effort::Xhigh) => Some(Effort::Medium),
+ other => other,
+ }
+}
+
fn reasoning_summary_requested(summary: Option<&str>) -> bool {
!matches!(summary, Some("off" | "none"))
}
@@ -280,6 +299,7 @@ pub fn translate_request(
let input = build_input(req);
let tools = read_tools(req)?;
let tool_choice = map_tool_choice(req)?;
+ let is_luna = opts.model == "gpt-5.6-luna";
let mut text = ResponsesText {
verbosity: Some("low".to_string()),
@@ -301,12 +321,46 @@ pub fn translate_request(
text,
tools: None,
include: None,
+ client_metadata: None,
service_tier: None,
prompt_cache_key: None,
reasoning: None,
};
- if let Some(tools) = tools
+ if opts.use_responses_lite {
+ out.client_metadata = Some(std::collections::HashMap::from([(
+ "ws_request_header_x_openai_internal_codex_responses_lite".to_string(),
+ "true".to_string(),
+ )]));
+ out.parallel_tool_calls = false;
+
+ let mut prefix = Vec::new();
+ if let Some(ref tools) = tools
+ && !tools.is_empty()
+ {
+ let tools = tools
+ .iter()
+ .map(serde_json::to_value)
+ .collect::<Result<Vec<_>, _>>()?;
+ prefix.push(ResponsesInputItem::AdditionalTools {
+ id: None,
+ role: "developer".to_string(),
+ tools,
+ });
+ }
+ if let Some(instructions) = out.instructions.take()
+ && !instructions.is_empty()
+ {
+ prefix.push(ResponsesInputItem::Message {
+ role: "developer".to_string(),
+ content: vec![ResponsesContentPart::InputText { text: instructions }],
+ });
+ }
+ if !prefix.is_empty() {
+ prefix.extend(out.input);
+ out.input = prefix;
+ }
+ } else if let Some(tools) = tools
&& !tools.is_empty()
{
out.tools = Some(tools);
@@ -323,7 +377,10 @@ pub fn translate_request(
let effort = read_effort(req)?;
let codex_effort = to_codex_effort(effort);
- let resolved_effort = resolve_effort(codex_effort)?;
+ let mut resolved_effort = resolve_effort(codex_effort)?;
+ if is_luna {
+ resolved_effort = cap_luna_effort(resolved_effort);
+ }
if let Some(ref eff) = resolved_effort {
let summary = if reasoning_summary_requested(config::codex_reasoning_summary().as_deref()) {
Some("auto".to_string())
@@ -333,6 +390,7 @@ pub fn translate_request(
out.reasoning = Some(ResponsesReasoning {
effort: Some(eff.clone()),
summary,
+ context: opts.use_responses_lite.then_some("all_turns".to_string()),
});
out.include = Some(vec!["reasoning.encrypted_content".to_string()]);
}
@@ -791,6 +849,7 @@ mod tests {
session_id: None,
service_tier: None,
model: "gpt-5.5".to_string(),
+ use_responses_lite: false,
}
}
@@ -813,6 +872,7 @@ mod tests {
session_id: Some("s".into()),
service_tier: None,
model: "gpt-5.5".to_string(),
+ use_responses_lite: false,
},
)
.unwrap();
@@ -1214,6 +1274,104 @@ mod tests {
);
}
+ #[test]
+ fn luna_caps_high_effort_to_medium() {
+ let req: MessagesRequest = serde_json::from_value(json!({
+ "model": "gpt-5.6-luna",
+ "messages": [{"role":"user", "content":"hello"}],
+ "output_config": {"effort": "high"}
+ }))
+ .unwrap();
+ let out = translate_request(
+ &req,
+ TranslateOptions {
+ model: "gpt-5.6-luna".to_string(),
+ use_responses_lite: true,
+ ..opts()
+ },
+ )
+ .unwrap();
+ assert!(matches!(
+ out.reasoning.unwrap().effort,
+ Some(Effort::Medium)
+ ));
+ }
+
+ #[test]
+ fn sol_preserves_high_effort() {
+ let req: MessagesRequest = serde_json::from_value(json!({
+ "model": "gpt-5.6-sol",
+ "messages": [{"role":"user", "content":"hello"}],
+ "output_config": {"effort": "high"}
+ }))
+ .unwrap();
+ let out = translate_request(
+ &req,
+ TranslateOptions {
+ model: "gpt-5.6-sol".to_string(),
+ use_responses_lite: true,
+ ..opts()
+ },
+ )
+ .unwrap();
+ assert!(matches!(out.reasoning.unwrap().effort, Some(Effort::High)));
+ }
+
+ #[test]
+ fn responses_lite_moves_instructions_and_tools_into_input() {
+ let req: MessagesRequest = serde_json::from_value(json!({
+ "model": "gpt-5.6-luna",
+ "messages": [{"role":"user", "content":"hello"}],
+ "system": "be helpful",
+ "tools": [{"name":"test","input_schema":{"type":"object"}}]
+ }))
+ .unwrap();
+ let out = translate_request(
+ &req,
+ TranslateOptions {
+ model: "gpt-5.6-luna".to_string(),
+ use_responses_lite: true,
+ ..opts()
+ },
+ )
+ .unwrap();
+ assert!(out.instructions.is_none());
+ assert!(out.tools.is_none());
+ assert!(!out.parallel_tool_calls);
+ assert!(out.client_metadata.is_some());
+ assert_eq!(out.input.len(), 3);
+ assert!(matches!(
+ out.input[0],
+ ResponsesInputItem::AdditionalTools { .. }
+ ));
+ if let ResponsesInputItem::Message { role, content } = &out.input[1] {
+ assert_eq!(role, "developer");
+ assert!(matches!(content[0], ResponsesContentPart::InputText { .. }));
+ } else {
+ panic!("expected developer message");
+ }
+ }
+
+ #[test]
+ fn responses_lite_reasoning_uses_all_turns_context() {
+ let req: MessagesRequest = serde_json::from_value(json!({
+ "model": "gpt-5.6-luna",
+ "messages": [{"role":"user", "content":"hello"}],
+ "output_config": {"effort": "medium"}
+ }))
+ .unwrap();
+ let out = translate_request(
+ &req,
+ TranslateOptions {
+ model: "gpt-5.6-luna".to_string(),
+ use_responses_lite: true,
+ ..opts()
+ },
+ )
+ .unwrap();
+ assert_eq!(out.reasoning.unwrap().context.as_deref(), Some("all_turns"));
+ }
+
#[test]
fn translate_returns_only_expected_top_level_fields() {
let req: MessagesRequest = serde_json::from_value(json!({