@jeffusion/bungee-core 5.20.0 → 5.21.0

package/dist/plugins/codex-router/index.js

@@ -2256,14 +2256,25 @@ var DEFAULT_RESPONSES_CODEC_LIMITS = Object.freeze({
 
 class ResponsesCodecError extends Error {
   code;
-  constructor(code, message) {
+  param;
+  constructor(code, message, param) {
     super(message);
     this.code = code;
+    this.param = param;
     this.name = "ResponsesCodecError";
   }
 }
-function fail(code, message) {
-  throw new ResponsesCodecError(code, message);
+function fail(code, message, param) {
+  throw new ResponsesCodecError(code, message, param);
+}
+function atParam(param, run) {
+  try {
+    return run();
+  } catch (error) {
+    if (error instanceof ResponsesCodecError && error.param === undefined)
+      throw new ResponsesCodecError(error.code, error.message, param);
+    throw error;
+  }
 }
 function record(value, where) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -2426,8 +2437,94 @@ function responsePayload(id, model, output, end, usage, error, createdAt = Math.
   return result;
 }
 
+// packages/llms/src/responses-codec/request-preferences.ts
+function fields(value, allowed, path) {
+  for (const key of Object.keys(value))
+    if (!allowed.includes(key)) {
+      fail("unsupported_request", "Unrecognized request option", `${path}.${key}`);
+    }
+}
+function applyResponsesPreferences(body, result, protocol, capabilities, maxTokens, diagnostics) {
+  const note = (param, action, reason) => diagnostics.push({ param, action, reason });
+  if (body.stream_options !== undefined)
+    atParam("stream_options", () => {
+      const options = record(body.stream_options, "stream_options");
+      fields(options, ["include_usage", "reasoning_summary_delivery"], "stream_options");
+      if (options.include_usage !== undefined) {
+        if (typeof options.include_usage !== "boolean")
+          fail("invalid_payload", "Usage preference must be boolean", "stream_options.include_usage");
+        note("stream_options.include_usage", protocol === "chat_completions" && body.stream === true ? "mapped" : "omitted", protocol === "chat_completions" && body.stream === true ? "stream_usage_required" : "target_usage_events");
+      }
+      if (options.reasoning_summary_delivery !== undefined) {
+        if (options.reasoning_summary_delivery !== "sequential_cutoff")
+          fail("unsupported_request", "Unsupported summary delivery preference", "stream_options.reasoning_summary_delivery");
+        note("stream_options.reasoning_summary_delivery", "omitted", "source_summary_delivery_not_applicable");
+      }
+    });
+  if (body.access_programs !== undefined)
+    atParam("access_programs", () => {
+      const programs = record(body.access_programs, "access_programs");
+      fields(programs, ["cyber"], "access_programs");
+      if (programs.cyber !== undefined && programs.cyber !== "standard") {
+        if (programs.cyber === "daybreak_blue" || programs.cyber === "daybreak_red") {
+          fail("unsupported_access_program", "Selected access program cannot be represented by the target protocol", "access_programs.cyber");
+        }
+        fail("invalid_payload", "Invalid access program", "access_programs.cyber");
+      }
+      note("access_programs", "omitted", "target_uses_own_access_policy");
+    });
+  if (body.reasoning !== undefined)
+    atParam("reasoning", () => {
+      const reasoning = record(body.reasoning, "reasoning");
+      fields(reasoning, ["effort", "summary", "context"], "reasoning");
+      if (reasoning.summary !== undefined) {
+        if (typeof reasoning.summary !== "string" || !["none", "auto", "concise", "detailed"].includes(reasoning.summary))
+          fail("invalid_payload", "Invalid reasoning summary preference", "reasoning.summary");
+        note("reasoning.summary", "omitted", "target_summary_not_guaranteed");
+      }
+      if (reasoning.context !== undefined) {
+        if (reasoning.context !== "all_turns")
+          fail("unsupported_reasoning", "Unsupported reasoning context preference", "reasoning.context");
+        note("reasoning.context", "omitted", "source_reasoning_context_not_applicable");
+      }
+      if (reasoning.effort !== undefined)
+        atParam("reasoning.effort", () => {
+          const effort = string(reasoning.effort, "reasoning effort", true);
+          if (protocol === "chat_completions" && capabilities.reasoningEffort) {
+            result.reasoning_effort = effort;
+            note("reasoning.effort", "mapped", "target_reasoning_effort");
+          } else if (protocol === "anthropic_messages" && capabilities.anthropicThinkingBudget !== undefined && effort !== "none") {
+            const budget = capabilities.anthropicThinkingBudget;
+            if (!Number.isSafeInteger(budget) || budget < 1024 || typeof maxTokens !== "number" || budget >= maxTokens) {
+              fail("unsupported_reasoning", "Anthropic thinking requires an explicit budget below max_output_tokens");
+            }
+            result.thinking = { type: "enabled", budget_tokens: budget };
+            note("reasoning.effort", "mapped", "explicit_target_thinking_budget");
+          } else
+            note("reasoning.effort", "omitted", "target_reasoning_effort_unavailable");
+        });
+    });
+  if (body.text !== undefined)
+    atParam("text", () => {
+      const text = record(body.text, "text");
+      fields(text, ["verbosity", "format"], "text");
+      if (text.verbosity !== undefined) {
+        if (typeof text.verbosity !== "string" || !["low", "medium", "high"].includes(text.verbosity))
+          fail("invalid_payload", "Invalid text verbosity preference", "text.verbosity");
+        note("text.verbosity", "omitted", "target_verbosity_not_available");
+      }
+    });
+}
+
 // packages/llms/src/responses-codec/request.ts
 var contentNormalizer = new OpenAIProtocolConversion({ trimWhitespace: false });
+function definitionKey(value) {
+  if (Array.isArray(value))
+    return `[${value.map(definitionKey).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${definitionKey(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
 function decodeResponsesRequest(raw, protocol, capabilities = {}) {
   const body = record(raw, "Responses request");
   const budget = limits(capabilities.limits);
@@ -2453,11 +2550,15 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     "n",
     "truncation",
     "include",
-    "store"
+    "store",
+    "prompt_cache_key",
+    "client_metadata",
+    "stream_options",
+    "access_programs"
   ]);
   for (const key of Object.keys(body))
     if (!supported.has(key))
-      fail("unsupported_request", `Unsupported Responses request field ${key}`);
+      fail("unsupported_request", "Unrecognized Responses request field", key);
   if (body.store === true)
     fail("unsupported_request", "Stored Responses require caller-owned persistence");
   for (const key of ["previous_response_id", "conversation", "response_id"]) {
@@ -2470,17 +2571,28 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     fail("unsupported_request", "Only one response candidate is supported");
   if (body.truncation !== undefined && body.truncation !== "disabled")
     fail("unsupported_request", "Automatic input truncation cannot be represented");
-  if (body.include !== undefined && list(body.include, "include").length)
+  if (body.include !== undefined && list(body.include, "include").some((field) => field !== "reasoning.encrypted_content"))
     fail("unsupported_request", "Requested extra Responses output fields cannot be represented");
+  if (body.prompt_cache_key !== undefined)
+    string(body.prompt_cache_key, "prompt_cache_key");
+  if (body.client_metadata !== undefined)
+    record(body.client_metadata, "client_metadata");
   const model = string(body.model, "model", true);
+  const diagnostics = [];
+  const input = atParam("input", () => typeof body.input === "string" ? [{ role: "user", content: body.input }] : list(body.input, "input"));
+  if (input.length > budget.maxItems)
+    fail("resource_limit", "Too many input items", "input");
+  const canonicalInput = [];
   const toolNames = new Map;
   const byOriginal = new Map;
+  const definitions = new Map;
+  let examinedTools = 0;
   const tools = [];
   const identity = (name, namespace) => JSON.stringify([namespace ?? null, name]);
   const register = (name, namespace, custom) => {
     const key = identity(name, namespace);
     if (byOriginal.has(key))
-      fail("tool_name_collision", `Duplicate tool ${namespace ? namespace + "." : ""}${name}`);
+      fail("tool_name_collision", "Duplicate tool identity");
     if (toolNames.size >= budget.maxItems)
       fail("resource_limit", "Too many tools");
     const wire = `bungee_tool_${toolNames.size}`;
@@ -2488,18 +2600,29 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     byOriginal.set(key, wire);
     return wire;
   };
-  const expandTool = (rawTool, namespace) => {
+  const expandTool = (rawTool, namespace, path = "tools") => {
+    if (++examinedTools > budget.maxItems)
+      fail("resource_limit", "Too many tool declarations");
     const tool = record(rawTool, "tool");
+    if (namespace === undefined && capabilities.omitOptionalWebSearch && ["web_search", "web_search_preview"].includes(String(tool.type)) && (body.tool_choice === undefined || body.tool_choice === "auto" || body.tool_choice === "none"))
+      return;
+    const allowed = tool.type === "namespace" ? ["type", "name", "description", "tools"] : tool.type === "custom" ? ["type", "name", "description", "format"] : ["type", "name", "description", "parameters", "strict"];
+    for (const key of Object.keys(tool))
+      if (!allowed.includes(key))
+        fail("unsupported_tool", "Unsupported tool definition field", `${path}.${key}`);
     if (tool.type === "namespace") {
       if (namespace !== undefined)
         fail("unsupported_tool", "Nested tool namespaces are not supported");
       const name = string(tool.name, "namespace name", true);
-      for (const child of list(tool.tools, "namespace tools"))
-        expandTool(child, name);
+      for (const [index, child] of list(tool.tools, "namespace tools").entries()) {
+        const childPath = `${path}.tools[${index}]`;
+        atParam(childPath, () => expandTool(child, name, childPath));
+      }
       return;
     }
     if (tool.type !== "function" && tool.type !== "custom")
-      fail("unsupported_tool", `Hosted tool ${String(tool.type)} cannot be executed by Codex through this protocol`);
+      fail("unsupported_tool", "This tool type cannot be executed by Codex through the target protocol");
+    serialized(tool, budget.maxArgumentBytes, "tool definition");
     const name = string(tool.name, "tool name", true);
     const custom = tool.type === "custom";
     if (tool.strict !== undefined && typeof tool.strict !== "boolean")
@@ -2511,7 +2634,15 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
       if (format.type !== "text" && format.type !== "grammar")
         fail("unsupported_tool", "Unknown custom tool format");
     }
+    const key = identity(name, namespace);
+    const signature = definitionKey(tool);
+    if (definitions.has(key)) {
+      if (definitions.get(key) !== signature)
+        fail("tool_name_collision", "Conflicting definitions for the same tool identity");
+      return;
+    }
     const wire = register(name, namespace, custom);
+    definitions.set(key, signature);
     const parameters = custom ? { type: "object", properties: { input: { type: "string" } }, required: ["input"], additionalProperties: false } : record(tool.parameters ?? { type: "object", properties: {} }, "tool parameters");
     const description = tool.description === undefined ? undefined : string(tool.description, "tool description");
     const customHint = custom ? `Pass the complete original custom tool input verbatim in the input string.${tool.format ? ` Original input format: ${JSON.stringify(tool.format)}` : ""}` : undefined;
@@ -2524,8 +2655,24 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     }
   };
   if (body.tools !== undefined)
-    for (const tool of list(body.tools, "tools"))
-      expandTool(tool);
+    atParam("tools", () => {
+      for (const [index, tool] of list(body.tools, "tools").entries())
+        atParam(`tools[${index}]`, () => expandTool(tool, undefined, `tools[${index}]`));
+    });
+  for (const [index, rawItem] of input.entries())
+    atParam(`input[${index}]`, () => {
+      const item = record(rawItem, "input item");
+      if (item.type !== "additional_tools") {
+        canonicalInput.push(item);
+        return;
+      }
+      if (item.content !== undefined)
+        fail("invalid_payload", "A tool declaration carrier cannot also contain message content", `input[${index}].content`);
+      for (const [toolIndex, tool] of list(item.tools, "additional tools").entries()) {
+        const toolPath = `input[${index}].tools[${toolIndex}]`;
+        atParam(toolPath, () => expandTool(tool, undefined, toolPath));
+      }
+    });
   const resolve = (item, custom) => {
     const name = string(item.name, "call name", true);
     const namespace = item.namespace === undefined ? undefined : string(item.namespace, "call namespace", true);
@@ -2533,7 +2680,7 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     if (wire === undefined)
       wire = register(name, namespace, custom);
     if (toolNames.get(wire).custom !== custom)
-      fail("tool_name_collision", `Tool kind changed for ${name}`);
+      fail("tool_name_collision", "Historical tool kind conflicts with its current declaration");
     return wire;
   };
   const normalizeContent = (rawContent, role) => {
@@ -2544,6 +2691,8 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
       const part = record(rawPart, "content part");
       if (part.type === "input_text" || part.type === "output_text" || part.type === "text")
         string(part.text, "content text");
+      else if (part.type === "refusal" && role === "assistant")
+        string(part.refusal, "refusal");
       else if (part.type === "input_image" && role === "user") {
         if (protocol !== "chat_completions")
           fail("unsupported_content", "Anthropic image conversion requires provider-specific URL/data support");
@@ -2551,11 +2700,14 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
         if (part.detail !== undefined && !["auto", "low", "high"].includes(String(part.detail)))
           fail("unsupported_content", "Unknown image detail");
       } else
-        fail("unsupported_content", `Unsupported message content: ${String(part.type)}`);
+        fail("unsupported_content", "Unsupported message content type");
       if (part.annotations !== undefined && list(part.annotations, "annotations").length)
         fail("unsupported_content", "Output annotations cannot be represented in input history");
     }
-    const normalized = contentNormalizer.normalizeResponsesMessageContent(parts);
+    const normalized = contentNormalizer.normalizeResponsesMessageContent(parts.map((raw) => {
+      const part = raw;
+      return part.type === "refusal" ? { type: "output_text", text: part.refusal } : part;
+    }));
     for (let i = 0;i < parts.length; i++) {
       const part = parts[i];
       if (part.type === "input_image" && part.detail !== undefined)
@@ -2564,6 +2716,8 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     return normalized;
   };
   const chat = [];
+  const messageParams = new WeakMap;
+  let messageParam = "instructions";
   const callIds = new Set;
   const answered = new Set;
   let pendingReasoning = "";
@@ -2571,73 +2725,77 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     if (chat.length >= budget.maxItems)
       fail("resource_limit", "Too many input messages");
     chat.push(message);
+    messageParams.set(message, messageParam);
   };
   if (body.instructions !== undefined)
     addMessage({ role: "system", content: string(body.instructions, "instructions") });
-  const input = typeof body.input === "string" ? [{ role: "user", content: body.input }] : list(body.input, "input");
-  if (input.length > budget.maxItems)
-    fail("resource_limit", "Too many input items");
-  for (const rawItem of input) {
-    const item = record(rawItem, "input item");
-    if (item.encrypted_content !== undefined || item.type === "compaction")
-      fail("unsupported_content", "Encrypted reasoning and compaction cannot be restored");
-    if (item.type === "item_reference")
-      fail("unresolved_reference", "Input item references must be resolved before conversion");
-    if (item.type === "reasoning") {
-      if (protocol !== "chat_completions" || !capabilities.reasoningEffort)
-        fail("unsupported_reasoning", "Reasoning history requires an explicit compatible reasoning capability");
-      const summary = list(item.summary, "reasoning summary");
-      pendingReasoning += summary.map((part) => {
-        const p = record(part, "reasoning summary");
-        if (p.type !== "summary_text")
-          fail("unsupported_reasoning", "Unknown reasoning summary");
-        return string(p.text, "summary text");
-      }).join("");
-      continue;
-    }
-    if (item.type === "function_call" || item.type === "custom_tool_call") {
-      const custom = item.type === "custom_tool_call";
-      const id = string(item.call_id, "call_id", true);
-      if (callIds.has(id))
-        fail("invalid_tool_history", `Duplicate call_id ${id}`);
-      callIds.add(id);
-      const args = custom ? JSON.stringify({ input: string(item.input, "custom input") }) : string(item.arguments, "arguments");
-      bounded(args, budget.maxArgumentBytes, "arguments");
-      argumentObject(args);
-      const call = { id, type: "function", function: { name: resolve(item, custom), arguments: args } };
-      const previous = chat.at(-1);
-      if (previous?.role === "assistant") {
-        previous.tool_calls = [...previous.tool_calls ?? [], call];
-        if (pendingReasoning)
-          previous.reasoning_content = pendingReasoning;
-      } else
-        addMessage({ role: "assistant", content: null, tool_calls: [call], ...pendingReasoning ? { reasoning_content: pendingReasoning } : {} });
-      pendingReasoning = "";
-      continue;
-    }
-    if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
-      const id = string(item.call_id, "call_id", true);
-      if (!callIds.has(id) || answered.has(id))
-        fail("invalid_tool_history", `Unmatched or duplicate output ${id}`);
-      answered.add(id);
-      const output = typeof item.output === "string" ? item.output : normalizeContent(item.output, "tool");
-      addMessage({ role: "tool", tool_call_id: id, content: output, ...item.is_error === true ? { is_error: true } : {} });
-      continue;
-    }
-    if (item.type !== undefined && item.type !== "message")
-      fail("unsupported_content", `Unsupported input item ${String(item.type)}`);
-    const role = string(item.role, "message role", true);
-    if (!["user", "assistant", "system", "developer"].includes(role))
-      fail("unsupported_content", `Unknown message role ${role}`);
-    const message = { role, content: normalizeContent(item.content, role) };
-    if (pendingReasoning) {
-      if (role !== "assistant")
-        fail("unsupported_reasoning", "Reasoning must precede an assistant item");
-      message.reasoning_content = pendingReasoning;
-      pendingReasoning = "";
-    }
-    addMessage(message);
-  }
+  for (const [inputIndex, rawItem] of input.entries())
+    atParam(`input[${inputIndex}]`, () => {
+      messageParam = `input[${inputIndex}]`;
+      const item = record(rawItem, "input item");
+      if (item.type === "additional_tools")
+        return;
+      if (item.encrypted_content != null || item.type === "compaction")
+        fail("unsupported_content", "Encrypted reasoning and compaction cannot be restored");
+      if (item.type === "item_reference")
+        fail("unresolved_reference", "Input item references must be resolved before conversion");
+      if (item.type === "reasoning") {
+        if (protocol !== "chat_completions" || !(capabilities.reasoningHistory || capabilities.reasoningEffort))
+          fail("unsupported_reasoning", "Reasoning history requires an explicit compatible reasoning capability");
+        if (item.content != null)
+          fail("unsupported_reasoning", "Reasoning content requires an explicit history mapping", `${messageParam}.content`);
+        const summary = list(item.summary, "reasoning summary");
+        pendingReasoning += summary.map((part) => {
+          const p = record(part, "reasoning summary");
+          if (p.type !== "summary_text")
+            fail("unsupported_reasoning", "Unknown reasoning summary");
+          return string(p.text, "summary text");
+        }).join("");
+        return;
+      }
+      if (item.type === "function_call" || item.type === "custom_tool_call") {
+        const custom = item.type === "custom_tool_call";
+        const id = string(item.call_id, "call_id", true);
+        if (callIds.has(id))
+          fail("invalid_tool_history", "Duplicate tool call identifier");
+        callIds.add(id);
+        const args = custom ? JSON.stringify({ input: string(item.input, "custom input") }) : string(item.arguments, "arguments");
+        bounded(args, budget.maxArgumentBytes, "arguments");
+        argumentObject(args);
+        const call = { id, type: "function", function: { name: resolve(item, custom), arguments: args } };
+        const previous = chat.at(-1);
+        if (previous?.role === "assistant") {
+          previous.tool_calls = [...previous.tool_calls ?? [], call];
+          if (pendingReasoning)
+            previous.reasoning_content = pendingReasoning;
+        } else
+          addMessage({ role: "assistant", content: null, tool_calls: [call], ...pendingReasoning ? { reasoning_content: pendingReasoning } : {} });
+        pendingReasoning = "";
+        return;
+      }
+      if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
+        const id = string(item.call_id, "call_id", true);
+        if (!callIds.has(id) || answered.has(id))
+          fail("invalid_tool_history", "Unmatched or duplicate tool result");
+        answered.add(id);
+        const output = typeof item.output === "string" ? item.output : normalizeContent(item.output, "tool");
+        addMessage({ role: "tool", tool_call_id: id, content: output, ...item.is_error === true ? { is_error: true } : {} });
+        return;
+      }
+      if (item.type !== undefined && item.type !== "message")
+        fail("unsupported_content", "Unsupported input item type");
+      const role = string(item.role, "message role", true);
+      if (!["user", "assistant", "system", "developer"].includes(role))
+        fail("unsupported_content", "Unknown message role");
+      const message = { role, content: normalizeContent(item.content, role) };
+      if (pendingReasoning) {
+        if (role !== "assistant")
+          fail("unsupported_reasoning", "Reasoning must precede an assistant item");
+        message.reasoning_content = pendingReasoning;
+        pendingReasoning = "";
+      }
+      addMessage(message);
+    });
   if (pendingReasoning)
     fail("unsupported_reasoning", "Orphan reasoning history cannot be represented");
   const result = { model, messages: chat };
@@ -2670,41 +2828,35 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
       result.tool_choice = protocol === "chat_completions" ? { type: "function", function: { name: wire } } : { type: "tool", name: wire };
     }
   }
-  if (body.reasoning !== undefined) {
-    const reasoning = record(body.reasoning, "reasoning");
-    if (reasoning.summary !== undefined && reasoning.summary !== "none")
-      fail("unsupported_reasoning", "Requested reasoning summaries are not guaranteed by this upstream protocol");
-    if (reasoning.effort !== undefined && reasoning.effort !== "none") {
-      const effort = string(reasoning.effort, "reasoning effort", true);
-      if (protocol === "chat_completions") {
-        if (!capabilities.reasoningEffort)
-          fail("unsupported_reasoning", "Upstream does not advertise reasoning effort");
-        result.reasoning_effort = effort;
-      } else {
-        const thinking = capabilities.anthropicThinkingBudget;
-        if (!Number.isSafeInteger(thinking) || thinking < 1024 || typeof maxTokens !== "number" || thinking >= maxTokens)
-          fail("unsupported_reasoning", "Anthropic thinking requires an explicit budget below max_output_tokens");
-        result.thinking = { type: "enabled", budget_tokens: thinking };
+  applyResponsesPreferences(body, result, protocol, capabilities, maxTokens, diagnostics);
+  if (body.text !== undefined)
+    atParam("text.format", () => {
+      const text = record(body.text, "text");
+      if (text.format !== undefined) {
+        const format = record(text.format, "text format");
+        const allowed = format.type === "json_schema" ? ["type", "name", "schema", "strict", "description"] : ["type"];
+        for (const key of Object.keys(format))
+          if (!allowed.includes(key))
+            fail("unsupported_request", "Unsupported output format field", `text.format.${key}`);
+        if (format.type === "json_schema") {
+          atParam("text.format.name", () => string(format.name, "output schema name", true));
+          atParam("text.format.schema", () => record(format.schema, "output schema"));
+          if (format.strict !== undefined && typeof format.strict !== "boolean")
+            fail("invalid_payload", "Output schema strict must be boolean", "text.format.strict");
+          if (format.description !== undefined)
+            atParam("text.format.description", () => string(format.description, "output schema description"));
+        }
+        if (protocol !== "chat_completions" && format.type !== "text")
+          fail("unsupported_request", "Anthropic structured output requires a separate provider capability");
+        if (format.type === "json_schema")
+          result.response_format = { type: "json_schema", json_schema: { name: format.name, schema: format.schema, ...format.strict !== undefined ? { strict: format.strict } : {}, ...format.description !== undefined ? { description: format.description } : {} } };
+        else if (format.type === "json_object" || format.type === "text") {
+          if (protocol === "chat_completions")
+            result.response_format = format;
+        } else
+          fail("unsupported_request", "Unknown text format");
       }
-    }
-  }
-  if (body.text !== undefined) {
-    const text = record(body.text, "text");
-    if (text.verbosity !== undefined)
-      fail("unsupported_request", "Text verbosity cannot be represented");
-    if (text.format !== undefined) {
-      const format = record(text.format, "text format");
-      if (protocol !== "chat_completions" && format.type !== "text")
-        fail("unsupported_request", "Anthropic structured output requires a separate provider capability");
-      if (format.type === "json_schema")
-        result.response_format = { type: "json_schema", json_schema: { name: format.name, schema: format.schema, ...format.strict !== undefined ? { strict: format.strict } : {}, ...format.description !== undefined ? { description: format.description } : {} } };
-      else if (format.type === "json_object" || format.type === "text") {
-        if (protocol === "chat_completions")
-          result.response_format = format;
-      } else
-        fail("unsupported_request", "Unknown text format");
-    }
-  }
+    });
   if (protocol === "anthropic_messages") {
     const system = [];
     const messages = [];
@@ -2718,7 +2870,7 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
     for (const msg of chat) {
       if (msg.role === "system" || msg.role === "developer") {
         if (messages.length)
-          fail("unsupported_content", "Mid-conversation system instructions cannot be relocated safely");
+          fail("unsupported_content", "Mid-conversation system instructions cannot be relocated safely", `${messageParams.get(msg)}.role`);
         system.push(typeof msg.content === "string" ? msg.content : msg.content.map((p) => string(p.text, "system text")).join(""));
         continue;
       }
@@ -2744,7 +2896,7 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
       delete result.parallel_tool_calls;
     }
   }
-  return { body: result, toolNames };
+  return { body: result, toolNames, canonicalInput, diagnostics };
 }
 // packages/llms/src/responses-codec/events.ts
 class ResponsesEventEncoder {
@@ -3157,6 +3309,11 @@ function encodeResponsesResult(raw, protocol, model, toolNames = new Map, config
     fail("missing_terminal", "JSON response has no terminal result");
   return record(end.response, "Responses result");
 }
+// plugins/codex-router/server/history.ts
+function serializeHistory(value) {
+  return JSON.stringify(value).replace(/[\uD800-\uDFFF]/g, (unit) => "\\u" + unit.charCodeAt(0).toString(16).padStart(4, "0"));
+}
+
 // packages/core/src/plugin-logger.ts
 var sinkKey = Symbol.for("@jeffusion/bungee/plugin-log-sink");
 function createLogger(bindings = {}) {
@@ -3210,16 +3367,26 @@ function protocolSSEOutput(payloads, protocol, source) {
 // packages/core/src/plugin-extensions.ts
 var ANONYMOUS_PRINCIPAL = Object.freeze({ domain: "anonymous", keyId: "", credentialVersion: 0 });
 // packages/core/src/data-admission/errors.ts
+function safeDetails(details) {
+  if (!details)
+    return;
+  const message = typeof details.message === "string" && details.message.length <= 512 && !/[\x00-\x1f\x7f]/.test(details.message) ? details.message : undefined;
+  const param = typeof details.param === "string" && details.param.length <= 256 && /^[a-zA-Z_$][\w.$\[\]-]*$/.test(details.param) ? details.param : undefined;
+  return message === undefined && param === undefined ? undefined : Object.freeze({ message, param });
+}
+
 class DataAdmissionError extends Error {
   status;
   code;
   retryAfter;
   name = "DataAdmissionError";
-  constructor(status, code, retryAfter) {
+  details;
+  constructor(status, code, retryAfter, details) {
     super(code);
     this.status = status;
     this.code = code;
     this.retryAfter = retryAfter;
+    this.details = safeDetails(details);
   }
 }
 // packages/core/src/plugin-durable-state.ts
@@ -3751,7 +3918,7 @@ function historyClient(rpc) {
       throw new Error("codex_router_history_limit");
     },
     async put({ scope, id, value }, options) {
-      const text = JSON.stringify(value), total = Math.ceil(text.length / 8192);
+      const text = serializeHistory(value), total = Math.ceil(text.length / 8192);
       if (total > 1024 || Buffer.byteLength(text) > 8 * 1024 * 1024)
         throw new Error("codex_router_history_limit");
       for (let index = 0;index < total; index++) {
@@ -3766,12 +3933,13 @@ function historyClient(rpc) {
 function protocolAdapter(input) {
   const encoder = input.protocol ? new ResponsesEventEncoder(input.protocol, input.model, input.toolNames) : undefined;
   let nativeTerminal;
+  let sourceContext;
   let flushed = false;
   const terminal = async (events) => {
     for (const event of events)
       if (event.response && ["response.completed", "response.incomplete"].includes(event.type)) {
         input.signal.throwIfAborted();
-        await input.save(event.response);
+        await input.save(event.response, sourceContext);
       }
     return events;
   };
@@ -3787,7 +3955,7 @@ function protocolAdapter(input) {
         const body = input.protocol ? encodeResponsesResult(raw, input.protocol, input.model, input.toolNames) : { ...raw, model: input.model };
         if (["completed", "incomplete"].includes(body.status)) {
           input.signal.throwIfAborted();
-          await input.save(body);
+          await input.save(body, context);
         }
         const headers = new Headers(response.headers);
         headers.delete("content-length");
@@ -3795,7 +3963,8 @@ function protocolAdapter(input) {
         headers.set("content-type", "application/json");
         return new Response(JSON.stringify(body), { status: response.status, headers });
       });
-      hooks.onStreamChunk.tapPromise("codex-router.protocol", async (envelope) => {
+      hooks.onStreamChunk.tapPromise("codex-router.protocol", async (envelope, context) => {
+        sourceContext = context;
         if (!encoder) {
           const event = envelope.json;
           if (event?.response && ["response.completed", "response.incomplete"].includes(event.type))
@@ -3817,7 +3986,7 @@ function protocolAdapter(input) {
           return [...chunks, ...protocolSSEOutput(await terminal(encoder.finish()), "responses")];
         if (nativeTerminal) {
           input.signal.throwIfAborted();
-          await input.save(nativeTerminal);
+          await input.save(nativeTerminal, sourceContext);
         }
         return chunks;
       });
@@ -3862,7 +4031,6 @@ var manifest_default = {
     "dynamicRuntimeLoad",
     "controlPlane"
   ],
-  uiExtensionMode: "none",
   engines: {
     bungee: "^4.2.0 || ^5.0.0"
   },
@@ -3935,10 +4103,41 @@ var manifest_default = {
         type: "object",
         label: "Model",
         properties: [
+          {
+            name: "source",
+            type: "string",
+            label: "editor.source",
+            required: false,
+            validation: {
+              trimmed: true,
+              max: 512
+            }
+          },
+          {
+            name: "sourceProvider",
+            type: "string",
+            label: "editor.sourceProvider",
+            required: false,
+            validation: {
+              trimmed: true,
+              max: 512
+            }
+          },
+          {
+            name: "sourceProtocol",
+            type: "select",
+            label: "editor.sourceProtocol",
+            options: [
+              {
+                value: "responses",
+                label: "Responses"
+              }
+            ]
+          },
           {
             name: "provider",
             type: "string",
-            label: "provider",
+            label: "editor.provider",
             required: true,
             validation: {
               trimmed: true,
@@ -3948,7 +4147,7 @@ var manifest_default = {
           {
             name: "model",
             type: "string",
-            label: "model",
+            label: "editor.model",
             required: true,
             validation: {
               trimmed: true,
@@ -3968,20 +4167,19 @@ var manifest_default = {
           {
             name: "target",
             type: "gateway_target",
-            label: "Target",
+            label: "editor.target",
             required: true
           },
           {
             name: "capabilityOverrides",
             type: "json",
-            label: "Capabilities"
+            label: "editor.advanced"
           }
         ]
       }
     }
   ],
   contributes: {
-    settings: "/catalog",
     api: [
       {
         path: "/catalog",
@@ -3996,19 +4194,109 @@ var manifest_default = {
   },
   translations: {
     "zh-CN": {
+      "editor.loaded": "\u5DF2\u52A0\u8F7D",
+      "editor.complete": "\u5DF2\u5168\u90E8\u52A0\u8F7D",
+      "editor.loadMore": "\u52A0\u8F7D\u66F4\u591A",
       "metadata.name": "Codex \u6A21\u578B\u8DEF\u7531",
       "plugin.description": "\u4ECE\u5171\u4EAB\u76EE\u5F55\u9009\u62E9\u6A21\u578B\u5E76\u7ED1\u5B9A\u5DF2\u6709\u8DEF\u7531\u6216\u670D\u52A1",
-      "models.label": "\u6A21\u578B\u7ED1\u5B9A"
+      "models.label": "\u6A21\u578B\u7ED1\u5B9A",
+      "editor.description": "\u6309\u539F\u59CB\u6A21\u578B\u5339\u914D\u8BF7\u6C42\uFF0C\u5C06\u76EE\u6807\u6A21\u578B\u8F6C\u53D1\u5230\u6307\u5B9A\u8DEF\u7531\u6216\u670D\u52A1\u3002",
+      "editor.binding": "\u7ED1\u5B9A",
+      "editor.match": "\u5339\u914D\u8BF7\u6C42",
+      "editor.sourceProvider": "\u539F\u59CB\u63D0\u4F9B\u5546",
+      "editor.manual": "\u624B\u52A8\u8F93\u5165",
+      "editor.fromCatalog": "\u4ECE\u76EE\u5F55\u9009\u62E9",
+      "editor.source": "\u539F\u59CB\u6A21\u578B",
+      "editor.sourceHint": "\u7CBE\u786E\u5339\u914D\u5BA2\u6237\u7AEF\u8BF7\u6C42\u4E2D\u7684\u6A21\u578B\u6807\u8BC6\uFF1B\u4F9B\u5E94\u5546\u4EC5\u7528\u4E8E\u76EE\u5F55\u7B5B\u9009\u3002",
+      "editor.sourcePlaceholder": "\u4F8B\u5982 gpt-5.4",
+      "editor.provider": "\u76EE\u6807\u63D0\u4F9B\u5546",
+      "editor.model": "\u76EE\u6807\u6A21\u578B",
+      "editor.target": "\u8F6C\u53D1\u8DEF\u7531 / \u670D\u52A1",
+      "editor.targetPlaceholder": "\u9009\u62E9\u5DF2\u6709\u8DEF\u7531\u6216\u670D\u52A1",
+      "editor.search": "\u641C\u7D22\u6A21\u578B",
+      "editor.empty": "\u6CA1\u6709\u5339\u914D\u7684\u6A21\u578B",
+      "editor.loading": "\u6B63\u5728\u52A0\u8F7D\u6A21\u578B\u76EE\u5F55",
+      "editor.error": "\u76EE\u5F55\u4E0D\u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5 models.dev \u6216\u91CD\u8BD5\u3002",
+      "editor.targetsError": "\u65E0\u6CD5\u8BFB\u53D6\u8F6C\u53D1\u76EE\u6807\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+      "editor.retry": "\u91CD\u8BD5",
+      "editor.add": "\u6DFB\u52A0\u6A21\u578B\u7ED1\u5B9A",
+      "editor.remove": "\u79FB\u9664",
+      "editor.noBindings": "\u5C1A\u672A\u914D\u7F6E\u6A21\u578B\u7ED1\u5B9A\u3002",
+      "editor.noCatalog": "\u76EE\u5F55\u4E3A\u7A7A\uFF0C\u8BF7\u5148\u542F\u7528 models.dev \u5E76\u5237\u65B0\u76EE\u5F55\u3002",
+      "editor.advanced": "\u80FD\u529B\u9650\u5236\uFF08\u53EF\u9009\uFF09",
+      "editor.context": "\u4E0A\u4E0B\u6587\u957F\u5EA6\u4E0A\u9650",
+      "editor.contextHint": "\u7559\u7A7A\u4F7F\u7528\u76EE\u6807\u6A21\u578B\u7684\u4E0A\u4E0B\u6587\u957F\u5EA6\u3002",
+      "editor.toolsOff": "\u7981\u7528\u5DE5\u5177\u8C03\u7528",
+      "editor.imagesOff": "\u7981\u7528\u56FE\u7247\u8F93\u5165",
+      "editor.reasoningOff": "\u7981\u7528\u63A8\u7406\u80FD\u529B",
+      "editor.reasoningEffort": "\u4F20\u9012\u63A8\u7406\u5F3A\u5EA6\uFF08\u76EE\u6807\u9700\u652F\u6301\uFF09",
+      "editor.increase": "\u589E\u52A0\u4E0A\u4E0B\u6587\u4E0A\u9650",
+      "editor.decrease": "\u51CF\u5C11\u4E0A\u4E0B\u6587\u4E0A\u9650",
+      "editor.contextInvalid": "\u8BF7\u8F93\u5165\u6B63\u6574\u6570\u3002",
+      "editor.sourceProtocol": "\u6E90\u6A21\u578B\u534F\u8BAE",
+      "editor.targetProtocol": "\u76EE\u6807\u6A21\u578B\u534F\u8BAE",
+      "editor.targetProtocolPlaceholder": "\u9009\u62E9\u76EE\u6807\u63A5\u6536\u534F\u8BAE",
+      "editor.route": "\u8DEF\u7531",
+      "editor.service": "\u670D\u52A1",
+      "editor.targetUnavailable": "\u76EE\u6807\u4E0D\u53EF\u7528",
+      "editor.noOptions": "\u6CA1\u6709\u5339\u914D\u7684\u9009\u9879"
     },
     en: {
+      "editor.loaded": "Loaded",
+      "editor.complete": "All loaded",
+      "editor.loadMore": "Load more",
       "metadata.name": "Codex Router",
       "plugin.description": "Bind catalog models to existing routes or services",
-      "models.label": "Model bindings"
+      "models.label": "Model bindings",
+      "editor.description": "Match the original model and forward the target model through an existing route or service.",
+      "editor.binding": "Binding",
+      "editor.match": "Match request",
+      "editor.sourceProvider": "Original provider",
+      "editor.manual": "Enter manually",
+      "editor.fromCatalog": "Choose from catalog",
+      "editor.source": "Original model",
+      "editor.sourceHint": "Match the exact model ID in client requests; the provider only filters the catalog.",
+      "editor.sourcePlaceholder": "For example, gpt-5.4",
+      "editor.provider": "Target provider",
+      "editor.model": "Target model",
+      "editor.target": "Forwarding route / service",
+      "editor.targetPlaceholder": "Select an existing route or service",
+      "editor.search": "Search models",
+      "editor.empty": "No matching models",
+      "editor.loading": "Loading model catalog",
+      "editor.error": "Catalog unavailable. Check models.dev or retry.",
+      "editor.targetsError": "Unable to load forwarding targets. Please retry.",
+      "editor.retry": "Retry",
+      "editor.add": "Add model binding",
+      "editor.remove": "Remove",
+      "editor.noBindings": "No model bindings configured.",
+      "editor.noCatalog": "The catalog is empty. Enable models.dev and refresh it first.",
+      "editor.advanced": "Capability limits (optional)",
+      "editor.context": "Context length limit",
+      "editor.contextHint": "Leave empty to use the target model context length.",
+      "editor.toolsOff": "Disable tool calls",
+      "editor.imagesOff": "Disable image input",
+      "editor.reasoningOff": "Disable reasoning",
+      "editor.reasoningEffort": "Forward reasoning effort (requires target support)",
+      "editor.increase": "Increase context limit",
+      "editor.decrease": "Decrease context limit",
+      "editor.contextInvalid": "Enter a positive whole number.",
+      "editor.sourceProtocol": "Source protocol",
+      "editor.targetProtocol": "Target protocol",
+      "editor.targetProtocolPlaceholder": "Select the target receiving protocol",
+      "editor.route": "Route",
+      "editor.service": "Service",
+      "editor.targetUnavailable": "Target unavailable",
+      "editor.noOptions": "No matching options"
     }
-  }
+  },
+  uiExtensionMode: "none"
 };
 
 // plugins/codex-router/server/config.ts
+function bindingSource(binding) {
+  return binding.source ?? binding.alias ?? binding.model;
+}
 function parseBindings(value) {
   if (value === undefined)
     return [];
@@ -4016,16 +4304,22 @@ function parseBindings(value) {
     throw new Error("codex_router_invalid_bindings");
   const ids = new Set;
   return Object.freeze(value.map((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry) || Object.keys(entry).some((key) => !["provider", "model", "alias", "target", "capabilityOverrides"].includes(key)))
+    if (!entry || typeof entry !== "object" || Array.isArray(entry) || Object.keys(entry).some((key) => !["provider", "model", "source", "sourceProvider", "sourceProtocol", "alias", "target", "capabilityOverrides"].includes(key)) || entry.source !== undefined && entry.alias !== undefined || entry.sourceProvider !== undefined && entry.source === undefined)
       throw new Error("codex_router_invalid_bindings");
-    for (const text of [entry.provider, entry.model, ...entry.alias === undefined ? [] : [entry.alias]]) {
+    for (const text of [entry.provider, entry.model, ...entry.source === undefined ? [] : [entry.source], ...entry.sourceProvider === undefined ? [] : [entry.sourceProvider], ...entry.alias === undefined ? [] : [entry.alias]]) {
       if (typeof text !== "string" || !text || text !== text.trim() || text.length > 512 || /[\x00-\x1f\x7f]/.test(text))
         throw new Error("codex_router_invalid_bindings");
     }
+    if (entry.sourceProtocol !== undefined && entry.sourceProtocol !== "responses")
+      throw new Error("codex_router_source_protocol_unsupported");
     const target = entry.target;
-    if (!target || !["route", "service"].includes(target.type) || typeof target.id !== "string" || !target.id || Object.keys(target).some((key) => !["type", "id"].includes(key)))
+    if (!target || !["route", "service"].includes(target.type) || typeof target.id !== "string" || !target.id || Object.keys(target).some((key) => !["type", "id", "protocol"].includes(key)))
       throw new Error("codex_router_invalid_target");
-    const publicId = entry.alias ?? entry.model;
+    if (target.protocol === undefined)
+      throw new Error("codex_router_target_protocol_required");
+    if (!["responses", "chat_completions", "anthropic_messages"].includes(target.protocol))
+      throw new Error("codex_router_target_protocol_invalid");
+    const publicId = bindingSource(entry);
     if (ids.has(publicId))
       throw new Error("codex_router_model_conflict");
     ids.add(publicId);
@@ -4068,6 +4362,14 @@ var model_template_0_160_1_default = {
   priority: 100,
   default_reasoning_level: "none",
   supported_reasoning_levels: [],
+  experimental_supported_tools: [],
+  upgrade: null,
+  availability_nux: null,
+  model_messages: null,
+  include_skills_usage_instructions: false,
+  include_plugin_usage_instructions: false,
+  include_apps_usage_instructions: false,
+  supports_reasoning_summary_parameter: false,
   base_instructions: "",
   supports_search_tool: false,
   supports_parallel_tool_calls: false,
@@ -4090,22 +4392,34 @@ function mergeCatalog(native, bindings, catalog) {
   const existing = rich ? body.models : body.data;
   const ids = new Set(existing.map((entry) => rich ? entry.slug : entry.id));
   const added = [];
+  const replacements = new Map;
+  const unavailable = new Set;
+  const bound = new Set;
   for (const binding of bindings) {
-    const id = binding.alias ?? binding.model;
-    if (ids.has(id))
+    const id = bindingSource(binding);
+    if (bound.has(id) || ids.has(id) && binding.source === undefined)
       throw new Error("codex_router_model_conflict");
+    bound.add(id);
+    const replace = ids.has(id);
     ids.add(id);
     const info = catalog.model(binding);
-    if (!info || info.contextWindow === null || !info.inputModalities.includes("text"))
+    if (!info || info.contextWindow === null || !info.inputModalities.includes("text")) {
+      if (replace)
+        unavailable.add(id);
       continue;
+    }
     if (!rich) {
-      added.push({ id, object: "model", owned_by: binding.provider });
+      const model = { id, object: "model", owned_by: binding.provider };
+      if (replace)
+        replacements.set(id, model);
+      else
+        added.push(model);
       continue;
     }
     const overrides = binding.capabilityOverrides;
     const context = Math.min(info.contextWindow, overrides?.contextWindow ?? info.contextWindow);
     const reasoning = info.reasoning && overrides?.reasoning !== false;
-    added.push({
+    const model = {
       ...model_template_0_160_1_default,
       slug: id,
       display_name: info.name,
@@ -4117,9 +4431,13 @@ function mergeCatalog(native, bindings, catalog) {
       supported_reasoning_levels: reasoning ? ["low", "medium", "high"].map((effort) => ({ effort, description: effort })) : [],
       default_reasoning_level: reasoning ? "medium" : "none",
       support_verbosity: false
-    });
+    };
+    if (replace)
+      replacements.set(id, model);
+    else
+      added.push(model);
   }
-  return { ...body, [rich ? "models" : "data"]: [...existing, ...added] };
+  return { ...body, [rich ? "models" : "data"]: [...existing.filter((entry) => !unavailable.has(rich ? entry.slug : entry.id)).map((entry) => replacements.get(rich ? entry.slug : entry.id) ?? entry), ...added] };
 }
 function catalogEtag(body, version, clientVersion) {
   return `"${createHash("sha256").update(JSON.stringify([body, version, clientVersion])).digest("hex")}"`;
@@ -4132,7 +4450,6 @@ var CodexRouterPlugin = definePlugin(class {
   static configSchema = manifest_default.configSchema;
   bindings;
   history;
-  targets = [];
   catalog;
   constructor(options) {
     this.bindings = parseBindings(options?.models);
@@ -4140,7 +4457,6 @@ var CodexRouterPlugin = definePlugin(class {
   async init(context) {
     if (context.scope?.type !== "route")
       throw new Error("codex_router_requires_route_scope");
-    this.targets = context.dispatchTargets ?? [];
     this.history = historyClient(context.services.rpc.consume("codex-router", historyRpc));
     this.catalog = context.services.consume("models-dev", MODELS_DEV_CAPABILITIES_SERVICE_ID, MODELS_DEV_CAPABILITIES_CONTRACT_VERSION);
   }
@@ -4148,20 +4464,23 @@ var CodexRouterPlugin = definePlugin(class {
     return { request: context.method === "POST" && /\/responses$/.test(context.url.pathname) ? "json-write" : "none", response: context.method === "GET" && /\/models$/.test(context.url.pathname) ? ["json"] : [] };
   }
   register(hooks) {
+    hooks.onWebSocketSessionMode.tap("codex-router.session", (url) => /\/responses$/.test(url.pathname) ? "responses" : undefined);
     hooks.onDispatchRequest.tapPromise("codex-router.binding", async ({ context, targets, principal, servingRevision, signal }) => {
       if (context.method !== "POST" || !/\/responses$/.test(context.originalUrl.pathname))
         return;
-      const binding = this.bindings.find((binding) => (binding.alias ?? binding.model) === context.body?.model);
+      const binding = this.bindings.find((binding) => bindingSource(binding) === context.body?.model);
       if (!binding)
         return;
-      const target = targets.find((target) => target.type === binding.target.type && target.id === binding.target.id);
-      if (!target?.protocol)
-        throw new DataAdmissionError(422, "codex_router_target_protocol_required");
+      if (!targets.some((target) => target.type === binding.target.type && target.id === binding.target.id))
+        throw new DataAdmissionError(422, "codex_router_target_unavailable");
+      const protocol = binding.target.protocol;
       const capabilities = this.catalog.model(binding);
-      if (!capabilities)
+      if (!capabilities || capabilities.contextWindow === null || !capabilities.inputModalities.includes("text"))
         throw new DataAdmissionError(503, "codex_router_model_unavailable");
       const scope = principal?.domain !== "anonymous" && principal?.keyId ? createHash2("sha256").update(JSON.stringify([principal, context.routeId, servingRevision ?? null, this.bindings])).digest("hex") : null;
       const input = structuredClone(context.body);
+      let requiredUpstreamId;
+      let opaqueRestored = false;
       if (input.previous_response_id) {
         if (!scope)
           throw new DataAdmissionError(422, "codex_router_history_identity_required");
@@ -4171,46 +4490,60 @@ var CodexRouterPlugin = definePlugin(class {
         const delta = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
         if (!Array.isArray(delta))
           throw new DataAdmissionError(422, "codex_router_invalid_history");
-        if (JSON.stringify(prior.target) !== JSON.stringify(binding.target) && prior.items.some((item) => item.encrypted_content || item.type === "compaction"))
-          throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
+        if (prior.items.some((item) => item.encrypted_content || item.type === "compaction")) {
+          if (protocol !== "responses" || JSON.stringify(prior.target) !== JSON.stringify(binding.target) || prior.origin?.provider !== binding.provider || prior.origin?.model !== binding.model || !prior.origin?.upstreamId)
+            throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
+          requiredUpstreamId = prior.origin.upstreamId;
+          opaqueRestored = true;
+        }
         input.input = [...prior.items, ...delta];
         delete input.previous_response_id;
       }
       if (input.conversation || input.response_id)
         throw new DataAdmissionError(422, "codex_router_unsupported_history_reference");
       input.model = binding.model;
-      const logicalInput = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
+      let logicalInput = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
       if (!Array.isArray(logicalInput))
         throw new DataAdmissionError(422, "codex_router_invalid_history");
+      if (!opaqueRestored && logicalInput.some((item) => item?.encrypted_content || item?.type === "compaction"))
+        throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
+      const hasTools = input.tools?.length || logicalInput.some((item) => item?.type === "additional_tools" && item.tools?.length);
+      if (hasTools && (!capabilities.toolCall || binding.capabilityOverrides?.tools === false))
+        throw new DataAdmissionError(422, "codex_router_tools_unsupported");
       let toolNames;
-      if (target.protocol !== "responses") {
+      let diagnostics;
+      if (protocol !== "responses") {
         try {
-          const decoded = decodeResponsesRequest(input, target.protocol, {
+          const decoded = decodeResponsesRequest(input, protocol, {
+            omitOptionalWebSearch: true,
             reasoningEffort: capabilities.reasoning && binding.capabilityOverrides?.reasoningEffort === true,
-            anthropicThinkingBudget: binding.capabilityOverrides?.anthropicThinkingBudget,
+            reasoningHistory: capabilities.reasoning && binding.capabilityOverrides?.reasoning !== false,
+            anthropicThinkingBudget: undefined,
             maxOutputTokens: capabilities.outputLimit ?? undefined
           });
           context.body = decoded.body;
           toolNames = decoded.toolNames;
+          logicalInput = decoded.canonicalInput;
+          diagnostics = decoded.diagnostics;
         } catch (error) {
           if (error instanceof ResponsesCodecError)
-            throw new DataAdmissionError(422, `codex_router_${error.code}`);
+            throw new DataAdmissionError(422, `codex_router_${error.code}`, undefined, { message: error.message, param: error.param });
           throw error;
         }
-        context.url.pathname = context.url.pathname.replace(/\/responses$/, target.protocol === "chat_completions" ? "/chat/completions" : "/messages");
+        context.url.pathname = context.url.pathname.replace(/\/responses$/, protocol === "chat_completions" ? "/chat/completions" : "/messages");
       } else
         context.body = input;
       const adapter = protocolAdapter({
-        protocol: target.protocol === "responses" ? undefined : target.protocol,
-        model: binding.alias ?? binding.model,
+        protocol: protocol === "responses" ? undefined : protocol,
+        model: bindingSource(binding),
         toolNames,
         signal,
-        save: async (response) => {
+        save: async (response, responseContext) => {
           if (scope && typeof response.id === "string")
-            await this.history.put({ scope, id: response.id, value: { target: binding.target, items: [...logicalInput, ...response.output] } }, { signal, operationId: crypto.randomUUID() });
+            await this.history.put({ scope, id: response.id, value: { target: binding.target, origin: { provider: binding.provider, model: binding.model, upstreamId: responseContext?.upstreamId }, items: [...logicalInput, ...response.output] } }, { signal, operationId: crypto.randomUUID() });
         }
       });
-      return { target: binding.target, adapter };
+      return { target: binding.target, protocol, requiredUpstreamId, adapter, ...protocol !== "responses" ? { canonicalInput: logicalInput, diagnostics } : {} };
     });
     hooks.onBeforeRequest.tap("codex-router.catalog-validator", (context) => {
       if (context.method === "GET" && /\/models$/.test(context.originalUrl.pathname)) {
@@ -4225,11 +4558,11 @@ var CodexRouterPlugin = definePlugin(class {
         return response;
       const native = await context.bodyHandle.json({ id: "codex-router.catalog", mandatory: true });
       const bindings = this.bindings.map((binding) => {
-        const protocol = this.targets?.find((target) => target.type === binding.target.type && target.id === binding.target.id)?.protocol;
+        const protocol = binding.target.protocol;
         return { ...binding, capabilityOverrides: {
           ...binding.capabilityOverrides,
           ...protocol === "anthropic_messages" ? { images: false } : {},
-          ...protocol && protocol !== "responses" ? { reasoning: protocol === "chat_completions" ? binding.capabilityOverrides?.reasoningEffort === true : !!binding.capabilityOverrides?.anthropicThinkingBudget } : {}
+          ...protocol !== "responses" ? { reasoning: protocol === "chat_completions" ? binding.capabilityOverrides?.reasoningEffort === true : false } : {}
         } };
       });
       const body = mergeCatalog(native, bindings, this.catalog);
@@ -4249,4 +4582,4 @@ export {
   server_default as default
 };
 
-//# debugId=E29014A25F222FA164756E2164756E21
+//# debugId=3BEC03CB648CDF5064756E2164756E21