@jeffusion/bungee-llms 5.19.0 → 5.21.0

package/dist/index.js

@@ -8499,10 +8499,1074 @@ function createTokenAccountingSession(input, options = {}) {
     }
   };
 }
+// src/responses-codec/common.ts
+var DEFAULT_RESPONSES_CODEC_LIMITS = Object.freeze({
+  maxRequestBytes: 8 * 1024 * 1024,
+  maxOutputBytes: 8 * 1024 * 1024,
+  maxArgumentBytes: 1024 * 1024,
+  maxItems: 1024
+});
+
+class ResponsesCodecError extends Error {
+  code;
+  param;
+  constructor(code, message, param) {
+    super(message);
+    this.code = code;
+    this.param = param;
+    this.name = "ResponsesCodecError";
+  }
+}
+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))
+    fail("invalid_payload", `${where} must be an object`);
+  return value;
+}
+function string(value, where, nonempty = false) {
+  if (typeof value !== "string" || nonempty && !value)
+    fail("invalid_payload", `${where} must be a${nonempty ? " non-empty" : ""} string`);
+  return value;
+}
+function list(value, where) {
+  if (!Array.isArray(value))
+    fail("invalid_payload", `${where} must be an array`);
+  return value;
+}
+function limits(overrides) {
+  const result = { ...DEFAULT_RESPONSES_CODEC_LIMITS, ...overrides };
+  for (const [key, value] of Object.entries(result)) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+      fail("invalid_limit", `${key} must be a positive integer`);
+  }
+  return result;
+}
+function bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function bounded(value, max, where) {
+  if (bytes(value) > max)
+    fail("resource_limit", `${where} exceeds ${max} bytes`);
+  return value;
+}
+function serialized(value, max, where) {
+  let result;
+  try {
+    result = JSON.stringify(value);
+  } catch {
+    fail("invalid_payload", `${where} must be serializable JSON`);
+  }
+  if (result === undefined)
+    fail("invalid_payload", `${where} must be serializable JSON`);
+  return bounded(result, max, where);
+}
+function argumentObject(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    fail("invalid_tool_arguments", "Tool arguments must be complete JSON");
+  }
+  return record(value, "tool arguments");
+}
+function restoreTool(name, names) {
+  const result = names.get(name);
+  if (result)
+    return result;
+  if (names.size)
+    fail("unknown_tool", `Provider returned undeclared tool ${name}`);
+  return { name, custom: false };
+}
+function customInput(text) {
+  const value = argumentObject(text);
+  if (Object.keys(value).length !== 1 || typeof value.input !== "string") {
+    fail("invalid_tool_arguments", "Custom tools require exactly one string input property");
+  }
+  return value.input;
+}
+function customInputPrefix(text) {
+  const prefix = /^\s*\{\s*"input"\s*:\s*"/.exec(text);
+  if (!prefix)
+    return "";
+  let result = "";
+  for (let i = prefix[0].length;i < text.length; ) {
+    const char = text[i];
+    if (char === '"')
+      break;
+    if (char !== "\\") {
+      if (char.charCodeAt(0) < 32)
+        fail("invalid_tool_arguments", "Invalid JSON string character");
+      result += char;
+      i++;
+      continue;
+    }
+    const escape = text[i + 1];
+    if (escape === undefined)
+      break;
+    const size = escape === "u" ? 6 : 2;
+    if (i + size > text.length)
+      break;
+    try {
+      result += JSON.parse(`"${text.slice(i, i + size)}"`);
+    } catch {
+      fail("invalid_tool_arguments", "Invalid JSON string escape");
+    }
+    i += size;
+  }
+  return result;
+}
+function terminal(reason, protocol) {
+  if (typeof reason !== "string" || !reason)
+    fail("missing_terminal", "Upstream has no explicit completion reason");
+  const completed = protocol === "chat_completions" ? ["stop", "tool_calls", "function_call"] : ["end_turn", "tool_use", "stop_sequence"];
+  if (completed.includes(reason))
+    return { status: "completed", reason };
+  if (reason === "length" || reason === "max_tokens" || reason === "model_context_window_exceeded")
+    return { status: "incomplete", reason: "max_output_tokens" };
+  if (reason === "content_filter" || reason === "refusal")
+    return { status: "incomplete", reason: "content_filter" };
+  if (reason === "error")
+    return { status: "failed", reason: "upstream_error" };
+  fail("unknown_terminal", `Unsupported upstream completion reason: ${reason}`);
+}
+function tokens(value, where) {
+  if (value === undefined)
+    return 0;
+  if (!Number.isSafeInteger(value) || value < 0)
+    fail("invalid_usage", `${where} must be a non-negative integer`);
+  return value;
+}
+function normalizeUsage(raw, protocol, prior = {}) {
+  if (raw === undefined || raw === null)
+    return prior;
+  const usage = record(raw, "usage");
+  const chat = protocol === "chat_completions";
+  const input = tokens(usage[chat ? "prompt_tokens" : "input_tokens"] ?? prior.input_tokens, "input_tokens");
+  const output = tokens(usage[chat ? "completion_tokens" : "output_tokens"] ?? prior.output_tokens, "output_tokens");
+  const details = chat ? usage.prompt_tokens_details : undefined;
+  const cached = chat ? details ? record(details, "prompt_tokens_details").cached_tokens : undefined : usage.cache_read_input_tokens;
+  const cacheRead = tokens(cached ?? prior.input_tokens_details?.cached_tokens, "cached_tokens");
+  const cacheWrite = chat ? 0 : tokens(usage.cache_creation_input_tokens, "cache_creation_input_tokens");
+  const totalInput = chat ? input : usage.input_tokens === undefined ? input : input + cacheRead + cacheWrite;
+  const reasoning = chat && usage.completion_tokens_details ? record(usage.completion_tokens_details, "completion_tokens_details").reasoning_tokens : undefined;
+  return {
+    input_tokens: totalInput,
+    output_tokens: output,
+    total_tokens: totalInput + output,
+    input_tokens_details: { cached_tokens: cacheRead },
+    output_tokens_details: { reasoning_tokens: tokens(reasoning ?? prior.output_tokens_details?.reasoning_tokens, "reasoning_tokens") }
+  };
+}
+function toolItem(id, name, args, names, status = "completed") {
+  const original = restoreTool(name, names);
+  const item = { id: `fc_${id}`, type: original.custom ? "custom_tool_call" : "function_call", call_id: id, name: original.name, status };
+  if (original.namespace)
+    item.namespace = original.namespace;
+  if (original.custom)
+    item.input = customInput(args);
+  else {
+    argumentObject(args);
+    item.arguments = args;
+  }
+  return item;
+}
+function responsePayload(id, model, output, end, usage, error, createdAt = Math.floor(Date.now() / 1000)) {
+  const result = { id, object: "response", created_at: createdAt, model, status: end.status, output, usage: Object.keys(usage).length ? usage : null };
+  if (end.status === "incomplete")
+    result.incomplete_details = { reason: end.reason };
+  if (end.status === "failed")
+    result.error = error ?? { code: end.reason, message: end.reason };
+  return result;
+}
+
+// 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");
+      }
+    });
+}
+
+// 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);
+  serialized(body, budget.maxRequestBytes, "request");
+  const supported = new Set([
+    "model",
+    "input",
+    "instructions",
+    "tools",
+    "tool_choice",
+    "reasoning",
+    "text",
+    "stream",
+    "temperature",
+    "top_p",
+    "parallel_tool_calls",
+    "metadata",
+    "max_output_tokens",
+    "previous_response_id",
+    "conversation",
+    "response_id",
+    "background",
+    "n",
+    "truncation",
+    "include",
+    "store",
+    "prompt_cache_key",
+    "client_metadata",
+    "stream_options",
+    "access_programs"
+  ]);
+  for (const key of Object.keys(body))
+    if (!supported.has(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"]) {
+    if (body[key] != null)
+      fail("unresolved_reference", `${key} must be resolved before protocol conversion`);
+  }
+  if (body.background === true)
+    fail("unsupported_request", "Background Responses cannot be represented by this codec");
+  if (body.n !== undefined && body.n !== 1)
+    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").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 identity");
+    if (toolNames.size >= budget.maxItems)
+      fail("resource_limit", "Too many tools");
+    const wire = `bungee_tool_${toolNames.size}`;
+    toolNames.set(wire, { name, namespace, custom });
+    byOriginal.set(key, wire);
+    return wire;
+  };
+  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 [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", "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")
+      fail("invalid_payload", "Tool strict must be boolean");
+    if (protocol === "anthropic_messages" && tool.strict === true)
+      fail("unsupported_tool", "Anthropic strict tool enforcement requires an explicit provider capability");
+    if (custom && tool.format !== undefined) {
+      const format = record(tool.format, "custom format");
+      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;
+    if (protocol === "chat_completions") {
+      tools.push({ type: "function", function: { name: wire, parameters, ...description || customHint ? { description: [description, customHint].filter(Boolean).join(`
+`) } : {}, ...tool.strict !== undefined ? { strict: tool.strict } : {} } });
+    } else {
+      tools.push({ name: wire, input_schema: parameters, ...description || customHint ? { description: [description, customHint].filter(Boolean).join(`
+`) } : {} });
+    }
+  };
+  if (body.tools !== undefined)
+    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);
+    let wire = byOriginal.get(identity(name, namespace));
+    if (wire === undefined)
+      wire = register(name, namespace, custom);
+    if (toolNames.get(wire).custom !== custom)
+      fail("tool_name_collision", "Historical tool kind conflicts with its current declaration");
+    return wire;
+  };
+  const normalizeContent = (rawContent, role) => {
+    if (typeof rawContent === "string")
+      return rawContent;
+    const parts = list(rawContent, "message content");
+    for (const rawPart of parts) {
+      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");
+        string(part.image_url, "image_url", true);
+        if (part.detail !== undefined && !["auto", "low", "high"].includes(String(part.detail)))
+          fail("unsupported_content", "Unknown image detail");
+      } else
+        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.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)
+        normalized[i].image_url.detail = part.detail;
+    }
+    return normalized;
+  };
+  const chat = [];
+  const messageParams = new WeakMap;
+  let messageParam = "instructions";
+  const callIds = new Set;
+  const answered = new Set;
+  let pendingReasoning = "";
+  const addMessage = (message) => {
+    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") });
+  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 };
+  for (const key of ["stream", "temperature", "top_p", "parallel_tool_calls", "metadata"])
+    if (body[key] !== undefined)
+      result[key] = body[key];
+  if (protocol === "chat_completions" && body.stream === true)
+    result.stream_options = { include_usage: true };
+  const maxTokens = body.max_output_tokens ?? capabilities.maxOutputTokens;
+  if (maxTokens !== undefined) {
+    if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0)
+      fail("invalid_payload", "max_output_tokens must be a positive integer");
+    result[protocol === "chat_completions" ? "max_completion_tokens" : "max_tokens"] = maxTokens;
+  }
+  if (tools.length)
+    result.tools = tools;
+  if (body.tool_choice !== undefined) {
+    const choice = body.tool_choice;
+    if (typeof choice === "string") {
+      if (!["auto", "none", "required"].includes(choice))
+        fail("unsupported_tool_choice", `Unsupported tool choice ${choice}`);
+      result.tool_choice = protocol === "chat_completions" ? choice : { type: choice === "required" ? "any" : choice };
+    } else {
+      const c = record(choice, "tool_choice");
+      if (c.type !== "function" && c.type !== "custom")
+        fail("unsupported_tool_choice", "Forced hosted tools are unsupported");
+      const wire = byOriginal.get(identity(string(c.name, "tool choice name", true), c.namespace === undefined ? undefined : string(c.namespace, "tool choice namespace")));
+      if (!wire || !tools.some((t) => t.name === wire || t.function?.name === wire))
+        fail("unsupported_tool_choice", "Forced tool is not declared");
+      result.tool_choice = protocol === "chat_completions" ? { type: "function", function: { name: wire } } : { type: "tool", name: wire };
+    }
+  }
+  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 (protocol === "anthropic_messages") {
+    const system = [];
+    const messages = [];
+    const append = (role, content) => {
+      const previous = messages.at(-1);
+      if (previous?.role === role)
+        previous.content.push(...content);
+      else
+        messages.push({ role, content });
+    };
+    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", `${messageParams.get(msg)}.role`);
+        system.push(typeof msg.content === "string" ? msg.content : msg.content.map((p) => string(p.text, "system text")).join(""));
+        continue;
+      }
+      if (msg.role === "tool") {
+        append("user", [{ type: "tool_result", tool_use_id: msg.tool_call_id, content: msg.content, ...msg.is_error ? { is_error: true } : {} }]);
+      } else {
+        const content = msg.content == null ? [] : typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : msg.content;
+        for (const call of msg.tool_calls ?? []) {
+          const fn = call.function;
+          content.push({ type: "tool_use", id: call.id, name: fn.name, input: argumentObject(fn.arguments) });
+        }
+        append(msg.role, content);
+      }
+    }
+    result.messages = messages;
+    if (system.length)
+      result.system = system.join(`
+`);
+    if (maxTokens === undefined)
+      fail("missing_capability", "Anthropic requires max_output_tokens or capabilities.maxOutputTokens");
+    if (body.parallel_tool_calls !== undefined) {
+      result.tool_choice = { ...record(result.tool_choice ?? { type: "auto" }, "tool_choice"), disable_parallel_tool_use: body.parallel_tool_calls === false };
+      delete result.parallel_tool_calls;
+    }
+  }
+  return { body: result, toolNames, canonicalInput, diagnostics };
+}
+// src/responses-codec/events.ts
+class ResponsesEventEncoder {
+  protocol;
+  model;
+  toolNames;
+  budget;
+  id = `resp_${crypto.randomUUID().replaceAll("-", "")}`;
+  createdAt = Math.floor(Date.now() / 1000);
+  output = [];
+  states = new Map;
+  anthropicBlocks = new Map;
+  usage = {};
+  end;
+  error;
+  started = false;
+  anthropicStarted = false;
+  anthropicStopped = false;
+  finalized = false;
+  poisoned = false;
+  sequence = 0;
+  retained = 0;
+  constructor(protocol, model, toolNames = new Map, configuredLimits) {
+    this.protocol = protocol;
+    this.model = model;
+    this.toolNames = toolNames;
+    this.budget = limits(configuredLimits);
+  }
+  event(type, fields = {}) {
+    return { type, sequence_number: this.sequence++, ...fields };
+  }
+  start(events) {
+    if (this.started)
+      return;
+    this.started = true;
+    const payload = { id: this.id, object: "response", created_at: this.createdAt, model: this.model, status: "in_progress", output: [], usage: null };
+    events.push(this.event("response.created", { response: payload }), this.event("response.in_progress", { response: { ...payload } }));
+  }
+  retain(text) {
+    this.retained += bytes(text);
+    if (this.retained > this.budget.maxOutputBytes)
+      fail("resource_limit", "Accumulated response output exceeds maxOutputBytes");
+  }
+  state(key, kind) {
+    const existing = this.states.get(key);
+    if (existing) {
+      if (existing.kind !== kind)
+        fail("invalid_stream", "Output item changed kind");
+      return existing;
+    }
+    if (this.output.length >= this.budget.maxItems)
+      fail("resource_limit", "Too many output items");
+    const state = { key, index: this.output.length, kind, id: `${this.id}_item_${this.output.length}`, text: "", name: "", callId: "", args: "", emittedInput: "", added: false, closed: false };
+    this.states.set(key, state);
+    this.output.push(state);
+    return state;
+  }
+  fields(state) {
+    return { response_id: this.id, item_id: state.id, output_index: state.index };
+  }
+  item(state, status, strict = false) {
+    if (state.kind === "tool") {
+      if (strict)
+        return { ...toolItem(state.callId, state.name, state.args || "{}", this.toolNames, status), id: state.id };
+      const original = state.original ?? restoreTool(state.name, this.toolNames);
+      return {
+        id: state.id,
+        type: original.custom ? "custom_tool_call" : "function_call",
+        call_id: state.callId,
+        name: original.name,
+        ...original.namespace ? { namespace: original.namespace } : {},
+        status,
+        ...original.custom ? { input: state.emittedInput } : { arguments: state.args }
+      };
+    }
+    if (state.kind === "reasoning")
+      return { id: state.id, type: "reasoning", summary: status === "in_progress" ? [] : [{ type: "summary_text", text: state.text }] };
+    return {
+      id: state.id,
+      type: "message",
+      role: "assistant",
+      status,
+      content: status === "in_progress" ? [] : [this.part(state)]
+    };
+  }
+  part(state) {
+    return state.kind === "refusal" ? { type: "refusal", refusal: state.text } : state.kind === "reasoning" ? { type: "summary_text", text: state.text } : { type: "output_text", text: state.text, annotations: [] };
+  }
+  add(state, events, final = false) {
+    if (state.added)
+      return;
+    if (state.kind === "tool") {
+      if (!state.callId || !state.name || this.toolNames.size && !this.toolNames.has(state.name))
+        return;
+      if (!final && !state.args && [...this.toolNames.keys()].some((name) => name !== state.name && name.startsWith(state.name)))
+        return;
+      state.original = restoreTool(state.name, this.toolNames);
+    }
+    state.added = true;
+    const initial = this.item(state, "in_progress");
+    if (state.kind === "tool") {
+      if (state.original?.custom)
+        initial.input = "";
+      else
+        initial.arguments = "";
+    }
+    events.push(this.event("response.output_item.added", { response_id: this.id, output_index: state.index, item: initial }));
+    if (state.kind !== "tool") {
+      const part = state.kind === "reasoning" ? { type: "summary_text", text: "" } : state.kind === "refusal" ? { type: "refusal", refusal: "" } : { type: "output_text", text: "", annotations: [] };
+      events.push(this.event(state.kind === "reasoning" ? "response.reasoning_summary_part.added" : "response.content_part.added", { ...this.fields(state), [state.kind === "reasoning" ? "summary_index" : "content_index"]: 0, part }));
+    }
+  }
+  appendText(state, delta, events) {
+    if (state.closed)
+      fail("invalid_stream", "Delta arrived after content block stop");
+    this.retain(delta);
+    state.text += delta;
+    this.add(state, events);
+    const type = state.kind === "reasoning" ? "response.reasoning_summary_text.delta" : state.kind === "refusal" ? "response.refusal.delta" : "response.output_text.delta";
+    if (delta)
+      events.push(this.event(type, { ...this.fields(state), [state.kind === "reasoning" ? "summary_index" : "content_index"]: 0, delta }));
+  }
+  emitArgs(state, events, fragment = "", first = false) {
+    if (!state.added)
+      return;
+    if (state.original?.custom) {
+      const prefix = customInputPrefix(state.args);
+      if (!prefix.startsWith(state.emittedInput))
+        fail("invalid_tool_arguments", "Custom input prefix changed");
+      const delta = prefix.slice(state.emittedInput.length);
+      state.emittedInput = prefix;
+      if (delta)
+        events.push(this.event("response.custom_tool_call_input.delta", { ...this.fields(state), delta }));
+    } else {
+      const delta = first ? state.args : fragment;
+      if (delta)
+        events.push(this.event("response.function_call_arguments.delta", { ...this.fields(state), delta }));
+    }
+  }
+  toolDelta(state, raw, events) {
+    if (state.closed)
+      fail("invalid_stream", "Tool delta arrived after content block stop");
+    if (raw.id !== undefined) {
+      const id = string(raw.id, "tool call id", true);
+      if (state.callId && state.callId !== id)
+        fail("invalid_stream", "Tool call id changed");
+      if (!state.callId)
+        this.retain(id);
+      state.callId = id;
+    }
+    const fn = raw.function === undefined ? {} : record(raw.function, "tool function");
+    if (fn.name !== undefined) {
+      const name = string(fn.name, "tool name");
+      if (state.added && name)
+        fail("invalid_stream", "Tool name changed after output_item.added");
+      this.retain(name);
+      state.name += name;
+    }
+    const args = fn.arguments === undefined ? "" : string(fn.arguments, "tool arguments delta");
+    this.retain(args);
+    state.args = bounded(state.args + args, this.budget.maxArgumentBytes, "tool arguments");
+    const wasAdded = state.added;
+    this.add(state, events);
+    this.emitArgs(state, events, args, !wasAdded);
+  }
+  push(raw) {
+    if (this.poisoned)
+      fail("invalid_stream", "Encoder cannot continue after a codec error");
+    if (this.finalized)
+      fail("invalid_stream", "Event arrived after response terminal");
+    try {
+      const chunk = record(raw, "stream event");
+      serialized(chunk, this.budget.maxOutputBytes, "stream event");
+      const events = [];
+      this.start(events);
+      if (chunk.error !== undefined || chunk.type === "error") {
+        this.error = record(chunk.error, "upstream error");
+        this.end = { status: "failed", reason: "upstream_error" };
+        this.anthropicStopped = true;
+        return [...events, ...this.complete()];
+      }
+      if (this.protocol === "chat_completions")
+        this.chat(chunk, events);
+      else
+        this.anthropic(chunk, events);
+      return events;
+    } catch (error) {
+      this.poisoned = true;
+      throw error;
+    }
+  }
+  chat(chunk, events) {
+    const choices = list(chunk.choices, "choices");
+    if (choices.length > 1)
+      fail("unsupported_response", "Multiple response candidates are not supported");
+    if (choices.length) {
+      const choice = record(choices[0], "choice");
+      if (choice.index !== undefined && choice.index !== 0)
+        fail("unsupported_response", "Only choice index 0 is supported");
+      const delta = record(choice.delta ?? {}, "choice delta");
+      for (const key of Object.keys(delta))
+        if (!["role", "content", "refusal", "reasoning_content", "reasoning", "tool_calls", "function_call", "annotations"].includes(key))
+          fail("unsupported_content", `Unsupported Chat output field ${key}`);
+      if (delta.annotations !== undefined && list(delta.annotations, "annotations").length)
+        fail("unsupported_content", "Chat output annotations cannot be faithfully converted");
+      if (delta.role !== undefined && delta.role !== "assistant")
+        fail("unsupported_response", "Response role must be assistant");
+      if (this.end && Object.values(delta).some((v) => v !== undefined && v !== null && v !== "" && (!Array.isArray(v) || v.length)))
+        fail("invalid_stream", "Output arrived after finish_reason");
+      const reasoning = delta.reasoning_content ?? delta.reasoning;
+      if (reasoning !== undefined && reasoning !== null)
+        this.appendText(this.state("reasoning", "reasoning"), string(reasoning, "reasoning delta"), events);
+      if (delta.content !== undefined && delta.content !== null)
+        this.appendText(this.state("text", "text"), string(delta.content, "text delta"), events);
+      if (delta.refusal !== undefined && delta.refusal !== null)
+        this.appendText(this.state("refusal", "refusal"), string(delta.refusal, "refusal delta"), events);
+      if (delta.tool_calls !== undefined) {
+        for (const rawTool of list(delta.tool_calls, "tool_calls")) {
+          const tool = record(rawTool, "tool call");
+          if (!Number.isSafeInteger(tool.index) || tool.index < 0)
+            fail("invalid_stream", "Streamed tool requires a non-negative integer index");
+          if (tool.type !== undefined && tool.type !== "function")
+            fail("unsupported_tool", "Unknown upstream tool call type");
+          this.toolDelta(this.state(`tool:${tool.index}`, "tool"), tool, events);
+        }
+      }
+      if (delta.function_call !== undefined)
+        fail("unsupported_response", "Legacy function_call lacks a stable call_id");
+      if (choice.finish_reason !== undefined && choice.finish_reason !== null) {
+        const next = terminal(choice.finish_reason, this.protocol);
+        if (this.end && (this.end.status !== next.status || this.end.reason !== next.reason))
+          fail("invalid_stream", "Conflicting finish reasons");
+        this.end = next;
+      }
+    }
+    this.usage = normalizeUsage(chunk.usage, this.protocol, this.usage);
+  }
+  anthropic(chunk, events) {
+    if (chunk.type === "ping")
+      return;
+    if (this.anthropicStopped)
+      fail("invalid_stream", "Event arrived after message_stop");
+    if (chunk.type === "message_start") {
+      if (this.anthropicStarted)
+        fail("invalid_stream", "Duplicate message_start");
+      const message = record(chunk.message, "message");
+      this.anthropicStarted = true;
+      this.usage = normalizeUsage(message.usage, this.protocol, this.usage);
+      return;
+    }
+    if (!this.anthropicStarted)
+      fail("invalid_stream", "Anthropic event arrived before message_start");
+    if (chunk.type === "message_delta") {
+      const delta = record(chunk.delta, "message delta");
+      if (delta.stop_reason != null) {
+        const next = terminal(delta.stop_reason, this.protocol);
+        if (this.end && (this.end.status !== next.status || this.end.reason !== next.reason))
+          fail("invalid_stream", "Conflicting stop reasons");
+        this.end = next;
+      }
+      this.usage = normalizeUsage(chunk.usage, this.protocol, this.usage);
+      return;
+    }
+    if (chunk.type === "message_stop") {
+      if (!this.end)
+        fail("missing_terminal", "message_stop has no preceding stop_reason");
+      if ([...this.anthropicBlocks.values()].some((s) => !s.closed))
+        fail("invalid_stream", "message_stop arrived before content_block_stop");
+      this.anthropicStopped = true;
+      return;
+    }
+    if (!Number.isSafeInteger(chunk.index) || chunk.index < 0)
+      fail("invalid_stream", "Anthropic content requires a non-negative integer index");
+    const index = chunk.index;
+    if (this.end)
+      fail("invalid_stream", "Content arrived after stop_reason");
+    if (chunk.type === "content_block_start") {
+      if (this.anthropicBlocks.has(index))
+        fail("invalid_stream", "Duplicate content_block_start");
+      const block = record(chunk.content_block, "content block");
+      const kind = block.type === "tool_use" ? "tool" : block.type === "text" ? "text" : block.type === "thinking" ? "reasoning" : undefined;
+      if (!kind)
+        fail("unsupported_content", `Unsupported Anthropic block ${String(block.type)}`);
+      const state = this.state(`block:${index}`, kind);
+      this.anthropicBlocks.set(index, state);
+      if (kind === "tool") {
+        const input = record(block.input ?? {}, "tool input");
+        this.toolDelta(state, { id: block.id, function: { name: block.name, ...Object.keys(input).length ? { arguments: serialized(input, this.budget.maxArgumentBytes, "tool input") } : {} } }, events);
+      } else
+        this.appendText(state, string(block[kind === "text" ? "text" : "thinking"] ?? "", "block text"), events);
+      return;
+    }
+    const state = this.anthropicBlocks.get(index);
+    if (!state || state.closed)
+      fail("invalid_stream", "Content event has no open block");
+    if (chunk.type === "content_block_stop") {
+      state.closed = true;
+      return;
+    }
+    if (chunk.type !== "content_block_delta")
+      fail("unsupported_response", `Unknown Anthropic event ${String(chunk.type)}`);
+    const delta = record(chunk.delta, "content delta");
+    if (delta.type === "input_json_delta" && state.kind === "tool")
+      this.toolDelta(state, { function: { arguments: delta.partial_json } }, events);
+    else if (delta.type === "text_delta" && state.kind === "text")
+      this.appendText(state, string(delta.text, "text delta"), events);
+    else if (delta.type === "thinking_delta" && state.kind === "reasoning")
+      this.appendText(state, string(delta.thinking, "thinking delta"), events);
+    else if (delta.type === "signature_delta" && state.kind === "reasoning") {
+      bounded(string(delta.signature, "signature"), this.budget.maxArgumentBytes, "signature");
+    } else
+      fail("unsupported_content", `Unsupported content delta ${String(delta.type)}`);
+  }
+  complete() {
+    if (!this.end)
+      fail("missing_terminal", "Stream ended without an explicit upstream terminal");
+    const events = [];
+    const items = [];
+    const callIds = new Set;
+    for (const state of this.output) {
+      const strict = this.end.status === "completed";
+      if (state.kind === "tool") {
+        if (!state.callId || !state.name)
+          fail("invalid_tool_arguments", "Tool call is missing id or name");
+        if (callIds.has(state.callId))
+          fail("invalid_tool_arguments", "Duplicate provider call_id");
+        callIds.add(state.callId);
+        state.original ??= restoreTool(state.name, this.toolNames);
+        this.add(state, events, true);
+        if (!state.added)
+          fail("unknown_tool", `Unknown tool ${state.name}`);
+        if (strict) {
+          argumentObject(state.args || "{}");
+          if (state.original.custom) {
+            const text = customInput(state.args);
+            if (!text.startsWith(state.emittedInput))
+              fail("invalid_tool_arguments", "Custom tool input changed");
+            if (text.length > state.emittedInput.length)
+              events.push(this.event("response.custom_tool_call_input.delta", { ...this.fields(state), delta: text.slice(state.emittedInput.length) }));
+            state.emittedInput = text;
+          }
+        }
+      }
+      const item = this.item(state, this.end.status === "completed" ? "completed" : "incomplete", strict);
+      const fields = this.fields(state);
+      if (state.kind === "tool") {
+        const custom = state.original.custom;
+        events.push(this.event(custom ? "response.custom_tool_call_input.done" : "response.function_call_arguments.done", { ...fields, [custom ? "input" : "arguments"]: custom ? item.input : item.arguments }));
+      } else {
+        const reasoning = state.kind === "reasoning";
+        const textField = state.kind === "refusal" ? "refusal" : "text";
+        events.push(this.event(reasoning ? "response.reasoning_summary_text.done" : state.kind === "refusal" ? "response.refusal.done" : "response.output_text.done", { ...fields, [reasoning ? "summary_index" : "content_index"]: 0, [textField]: state.text }));
+        events.push(this.event(reasoning ? "response.reasoning_summary_part.done" : "response.content_part.done", { ...fields, [reasoning ? "summary_index" : "content_index"]: 0, part: this.part(state) }));
+      }
+      events.push(this.event("response.output_item.done", { response_id: this.id, output_index: state.index, item }));
+      items.push(item);
+    }
+    const response = responsePayload(this.id, this.model, items, this.end, this.usage, this.error, this.createdAt);
+    serialized(response, this.budget.maxOutputBytes, "final response");
+    events.push(this.event(`response.${this.end.status}`, { response }));
+    this.finalized = true;
+    return events;
+  }
+  finish() {
+    if (this.poisoned)
+      fail("invalid_stream", "Encoder cannot finish after a codec error");
+    if (this.finalized)
+      return [];
+    try {
+      if (this.protocol === "anthropic_messages" && !this.anthropicStopped)
+        fail("missing_terminal", "Anthropic stream ended before message_stop");
+      return this.complete();
+    } catch (error) {
+      this.poisoned = true;
+      throw error;
+    }
+  }
+}
+
+// src/responses-codec/result.ts
+function encodeResponsesResult(raw, protocol, model, toolNames = new Map, configuredLimits) {
+  const body = record(raw, "upstream response");
+  const budget = limits(configuredLimits);
+  serialized(body, budget.maxOutputBytes, "upstream response");
+  if (body.error !== undefined || body.type === "error")
+    return responsePayload(`resp_${crypto.randomUUID().replaceAll("-", "")}`, model, [], { status: "failed", reason: "upstream_error" }, {}, record(body.error, "upstream error"));
+  const encoder = new ResponsesEventEncoder(protocol, model, toolNames, configuredLimits);
+  if (protocol === "chat_completions") {
+    const choices = list(body.choices, "choices");
+    if (choices.length !== 1)
+      fail("unsupported_response", "Exactly one response choice is required");
+    const choice = record(choices[0], "choice");
+    const message = record(choice.message, "message");
+    const delta = { ...message };
+    if (message.tool_calls !== undefined)
+      delta.tool_calls = list(message.tool_calls, "tool_calls").map((tool, index) => ({ ...record(tool, "tool call"), index }));
+    encoder.push({ choices: [{ index: choice.index ?? 0, delta, finish_reason: choice.finish_reason }], usage: body.usage });
+  } else {
+    encoder.push({ type: "message_start", message: { usage: body.usage } });
+    for (const [index, rawBlock] of list(body.content, "content").entries()) {
+      const block = record(rawBlock, "content block");
+      encoder.push({ type: "content_block_start", index, content_block: block });
+      encoder.push({ type: "content_block_stop", index });
+    }
+    encoder.push({ type: "message_delta", delta: { stop_reason: body.stop_reason } });
+    encoder.push({ type: "message_stop" });
+  }
+  const end = encoder.finish().at(-1);
+  if (!end)
+    fail("missing_terminal", "JSON response has no terminal result");
+  return record(end.response, "Responses result");
+}
 export {
   AnthropicAdapter,
   AnthropicToGeminiConverter,
   AnthropicToOpenAIConverter,
+  DEFAULT_RESPONSES_CODEC_LIMITS,
   GeminiToAnthropicConverter,
   GeminiToOpenAIConverter,
   LLMProtocolAdapterRegistry,
@@ -8517,6 +9581,8 @@ export {
   OpenAIToGeminiConverter,
   PROVIDER_TOKEN_ACCOUNTING_CAPABILITY_MATRIX,
   ProtocolTransformerRegistry,
+  ResponsesCodecError,
+  ResponsesEventEncoder,
   SUPPORTED_TOKEN_ACCOUNTING_PROVIDERS,
   TOKEN_ACCOUNTING_AUTHORITIES,
   TOKEN_ACCOUNTING_OUTCOMES,
@@ -8531,6 +9597,8 @@ export {
   countTextTokens,
   createPartialTokenAccountingEvent,
   createTokenAccountingSession,
+  decodeResponsesRequest,
+  encodeResponsesResult,
   finalizeTokenAccountingEvent,
   generateAnthropicMessageId,
   generateGeminiCandidateId,