Skip to content

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

Rust

route Luna web searches through a full-lane model

Soham Dasgupta63da7a8dc4b2
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index e98120b..7af605b 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -35,7 +35,7 @@ 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, uses_responses_lite,
+ assert_allowed_model, full_lane_web_search_model, resolve_model_request, uses_responses_lite,
};
use self::translate::reducer::finish_metadata_from_upstream;
use self::translate::request::{TranslateOptions, has_hosted_web_search, translate_request};
@@ -93,7 +93,7 @@ impl Provider for CodexProvider {
let want_stream = body.stream;
let model = body.model.as_deref().unwrap_or("gpt-5.6-sol");
- let resolved = resolve_model_request(model);
+ let mut resolved = resolve_model_request(model);
if let Err(e) = assert_allowed_model(&resolved.model) {
return json_error(
StatusCode::BAD_REQUEST,
@@ -104,6 +104,7 @@ impl Provider for CodexProvider {
),
);
}
+ let use_responses_lite = apply_model_lane_for_request(&mut resolved.model, &body);
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.model_resolved(&ctx.req_id, &resolved.model);
}
@@ -114,8 +115,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)
- && !has_hosted_web_search(&body),
+ use_responses_lite,
},
) {
Ok(t) => t,
@@ -235,7 +235,7 @@ impl Provider for CodexProvider {
async fn handle_count_tokens(&self, body: MessagesRequest, ctx: RequestContext) -> Response {
let model = body.model.as_deref().unwrap_or("gpt-5.6-sol");
- let resolved = resolve_model_request(model);
+ let mut resolved = resolve_model_request(model);
if let Err(e) = assert_allowed_model(&resolved.model) {
return json_error(
StatusCode::BAD_REQUEST,
@@ -246,6 +246,7 @@ impl Provider for CodexProvider {
),
);
}
+ let use_responses_lite = apply_model_lane_for_request(&mut resolved.model, &body);
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.model_resolved(&ctx.req_id, &resolved.model);
}
@@ -256,8 +257,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)
- && !has_hosted_web_search(&body),
+ use_responses_lite,
},
) {
Ok(t) => t,
@@ -284,6 +284,18 @@ impl Provider for CodexProvider {
}
}
+/// Picks the upstream model and lane for a request. Hosted web_search must
+/// run on the full Responses API (the lite lane rejects hosted tools), and
+/// lite-only models like gpt-5.6-luna don't exist there, so such requests
+/// are upgraded to a full-lane model. Returns whether to use the lite lane.
+fn apply_model_lane_for_request(model: &mut String, body: &MessagesRequest) -> bool {
+ if has_hosted_web_search(body) {
+ *model = full_lane_web_search_model(model).to_string();
+ return false;
+ }
+ uses_responses_lite(model)
+}
+
fn count_sse_events(bytes: &[u8]) -> u64 {
String::from_utf8_lossy(bytes).matches("event:").count() as u64
}
@@ -921,6 +933,50 @@ mod tests {
static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+ fn request_with_tools(tools: serde_json::Value) -> MessagesRequest {
+ serde_json::from_value(serde_json::json!({
+ "model": "gpt-5.6-luna",
+ "messages": [{"role":"user", "content":"find it"}],
+ "tools": tools
+ }))
+ .unwrap()
+ }
+
+ #[test]
+ fn web_search_requests_leave_lite_lane_and_upgrade_luna() {
+ let body = request_with_tools(serde_json::json!([
+ {"type":"web_search_20250305", "name":"web_search"}
+ ]));
+ for (resolved, expected) in [
+ ("gpt-5.6-luna", "gpt-5.6-sol"),
+ ("gpt-5.6-sol", "gpt-5.6-sol"),
+ ("gpt-5.6-terra", "gpt-5.6-terra"),
+ ("gpt-5.4", "gpt-5.4"),
+ ] {
+ let mut model = resolved.to_string();
+ let lite = apply_model_lane_for_request(&mut model, &body);
+ assert!(!lite, "{resolved} with web_search must use the full lane");
+ assert_eq!(model, expected);
+ }
+ }
+
+ #[test]
+ fn requests_without_web_search_keep_model_and_lite_lane() {
+ let body = request_with_tools(serde_json::json!([
+ {"name":"Bash", "input_schema":{}}
+ ]));
+ for (resolved, lite_expected) in [
+ ("gpt-5.6-luna", true),
+ ("gpt-5.6-sol", true),
+ ("gpt-5.4", false),
+ ] {
+ let mut model = resolved.to_string();
+ let lite = apply_model_lane_for_request(&mut model, &body);
+ assert_eq!(model, resolved, "model must not change without web_search");
+ assert_eq!(lite, lite_expected);
+ }
+ }
+
fn env_lock() -> std::sync::MutexGuard<'static, ()> {
ENV_LOCK
.get_or_init(|| Mutex::new(()))
diff --git a/src/providers/codex/translate/model_allowlist.rs b/src/providers/codex/translate/model_allowlist.rs
index 108cb8d..08df37d 100644
--- a/src/providers/codex/translate/model_allowlist.rs
+++ b/src/providers/codex/translate/model_allowlist.rs
@@ -112,6 +112,18 @@ pub fn uses_responses_lite(model: &str) -> bool {
matches!(model, "gpt-5.6-luna" | "gpt-5.6-sol" | "gpt-5.6-terra")
}
+/// `gpt-5.6-luna` exists only behind the Responses Lite lane; the full
+/// Responses API resolves it to a `-free` variant and returns 404 (Model not
+/// found gpt-5.6-luna-free-...). Hosted web_search requests must run on the
+/// full lane, so luna is upgraded to its nearest full-lane sibling.
+pub fn full_lane_web_search_model(model: &str) -> &str {
+ if model == "gpt-5.6-luna" {
+ "gpt-5.6-sol"
+ } else {
+ model
+ }
+}
+
pub fn is_valid_model_for_codex(model: &str) -> bool {
if ALLOWED_MODELS.contains(&model) {
return true;
@@ -133,6 +145,14 @@ mod tests {
assert_eq!(r.model, "gpt-5.6-luna");
}
+ #[test]
+ fn web_search_upgrades_luna_to_full_lane_sibling() {
+ assert_eq!(full_lane_web_search_model("gpt-5.6-luna"), "gpt-5.6-sol");
+ assert_eq!(full_lane_web_search_model("gpt-5.6-sol"), "gpt-5.6-sol");
+ assert_eq!(full_lane_web_search_model("gpt-5.6-terra"), "gpt-5.6-terra");
+ assert_eq!(full_lane_web_search_model("gpt-5.4"), "gpt-5.4");
+ }
+
#[test]
fn sonnet_resolves_to_terra() {
let r = resolve_model_request("sonnet");