claudish 9.4.0 → 9.5.0

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "9.4.0";
+var VERSION = "9.5.0";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -19045,6 +19045,28 @@ var init_remote_provider_types = __esm(() => {
   };
 });
 
+// src/adapters/optional-param-rejection.ts
+function escapeName(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function namesParameterField(errorText, param) {
+  const p = escapeName(param);
+  const tail = "(?![A-Za-z0-9_])";
+  const quoted = new RegExp(`['"\`]${p}['"\`]`);
+  const introduced = new RegExp("(?:parameter|argument|field|property|key|input)s?\\b" + "(?:[^A-Za-z0-9_]|\\b(?:supplied|provided|given|named|name|is|was|of|in|the|for|body|request|json)\\b){0,6}" + `${p}${tail}`, "i");
+  const leading = new RegExp(`(?:^|["'])\\s*${p}\\s*:`);
+  return quoted.test(errorText) || introduced.test(errorText) || leading.test(errorText);
+}
+function rejectedOptionalParams(errorText, candidates) {
+  if (!errorText || !PARAMETER_COMPLAINT.test(errorText))
+    return [];
+  return candidates.filter((param) => namesParameterField(errorText, param));
+}
+var PARAMETER_COMPLAINT;
+var init_optional_param_rejection = __esm(() => {
+  PARAMETER_COMPLAINT = /(unknown|unrecognized|unexpected|unsupported|not supported|does not support|invalid|not permitted|not allowed|extra (fields|inputs))/i;
+});
+
 // src/adapters/tool-name-utils.ts
 function hashToolName(name) {
   let h1 = 3735928559;
@@ -19061,20 +19083,46 @@ function hashToolName(name) {
   const combined = 4294967296 * (2097151 & h2) + (h1 >>> 0);
   return combined.toString(16).padStart(8, "0").slice(0, 8);
 }
-function truncateToolName(name, maxLength) {
-  if (name.length <= maxLength)
-    return name;
-  const prefixLen = maxLength - 9;
-  const prefix = name.slice(0, prefixLen);
-  const hash = hashToolName(name);
-  const truncated = `${prefix}_${hash}`;
-  log(`[ToolName] Truncated: "${name}" -> "${truncated}" (${name.length} -> ${truncated.length} chars)`);
-  return truncated;
-}
-var TOOL_NAME_SOURCE = "[A-Za-z_][A-Za-z0-9_.-]{0,63}", TOOL_NAME_SHAPE;
+function newToolNameBindings() {
+  return { byEncoded: new Map, byOriginal: new Map };
+}
+function hashedForm(transformed, original, limit, salt) {
+  const seed = salt === 0 ? original : `${original}#${salt}`;
+  const prefix = transformed.slice(0, Math.max(0, limit - 9));
+  return `${prefix}_${hashToolName(seed)}`;
+}
+function encodeToolName(original, limit, bindings) {
+  const already = bindings.byOriginal.get(original);
+  if (already !== undefined)
+    return already;
+  const transformed = original.replace(UNWIRABLE_CHARACTER, "_");
+  const takenByAnother = (name) => {
+    const owner = bindings.byEncoded.get(name);
+    return owner !== undefined && owner !== original;
+  };
+  let encoded = transformed.length <= limit ? transformed : hashedForm(transformed, original, limit, 0);
+  if (takenByAnother(encoded)) {
+    let salt = 0;
+    do {
+      encoded = hashedForm(transformed, original, limit, salt++);
+    } while (takenByAnother(encoded));
+  }
+  bindings.byEncoded.set(encoded, original);
+  bindings.byOriginal.set(original, encoded);
+  if (encoded !== original) {
+    log(`[ToolName] Encoded: "${original}" -> "${encoded}" (${original.length} -> ${encoded.length})`);
+  }
+  return encoded;
+}
+function wireDecodesToolNames(format) {
+  return format !== undefined && TOOL_NAME_DECODING_WIRES.includes(format);
+}
+var TOOL_NAME_SOURCE = "[A-Za-z_][A-Za-z0-9_.-]{0,63}", TOOL_NAME_SHAPE, UNWIRABLE_CHARACTER, TOOL_NAME_DECODING_WIRES;
 var init_tool_name_utils = __esm(() => {
   init_logger();
   TOOL_NAME_SHAPE = new RegExp(`^${TOOL_NAME_SOURCE}$`);
+  UNWIRABLE_CHARACTER = /[^A-Za-z0-9_-]/g;
+  TOOL_NAME_DECODING_WIRES = ["openai-sse", "openai-responses-sse"];
 });
 
 // src/handlers/shared/format/openai-messages.ts
@@ -19106,13 +19154,154 @@ ${msg}`;
         processAssistantMessage(msg, messages, simpleFormat);
     }
   }
-  return messages;
+  return normalizeMessageSequence(messages);
 }
-function imageBlockToUrlPart(block) {
-  return {
-    type: "image_url",
-    image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+function mergeUserContent(a, b) {
+  if (typeof a === "string" && typeof b === "string") {
+    if (!a)
+      return b;
+    if (!b)
+      return a;
+    return `${a}
+
+${b}`;
+  }
+  const toParts = (c) => {
+    if (typeof c === "string")
+      return c ? [{ type: "text", text: c }] : [];
+    if (Array.isArray(c))
+      return c;
+    return;
   };
+  const pa = toParts(a);
+  const pb = toParts(b);
+  if (!pa || !pb)
+    return;
+  return [...pa, ...pb];
+}
+function pushUserMessage(out, msg) {
+  const prev = out[out.length - 1];
+  if (prev?.role === "user") {
+    const merged = mergeUserContent(prev.content, msg.content);
+    if (merged !== undefined) {
+      prev.content = merged;
+      return;
+    }
+  }
+  out.push(msg);
+}
+function normalizeMessageSequence(messages) {
+  const out = [];
+  let openRound = null;
+  let collected = [];
+  const flushRound = (isFinal = false) => {
+    if (!openRound)
+      return;
+    if (isFinal && collected.length === 0) {
+      openRound = null;
+      return;
+    }
+    out.push(...alignToolRound(openRound, collected));
+    openRound = null;
+    collected = [];
+  };
+  for (const msg of messages) {
+    if (msg.role === "tool") {
+      if (openRound) {
+        collected.push(msg);
+        continue;
+      }
+      log(`[OpenAIMessages] error \u2014 tool result ${msg.tool_call_id} answers no open tool round; ` + "re-emitted as a user message");
+      const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      pushUserMessage(out, { role: "user", content: `[Tool Result]: ${text}` });
+      continue;
+    }
+    flushRound();
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+      out.push(msg);
+      openRound = msg;
+      continue;
+    }
+    if (msg.role === "user")
+      pushUserMessage(out, msg);
+    else
+      out.push(msg);
+  }
+  flushRound(true);
+  return out;
+}
+function missingResultText(name) {
+  const call = name ? `\`${name}\` call` : "call";
+  return `[No tool result was provided for this ${call} \u2014 it was interrupted, cancelled, ` + "or dropped from the conversation history.]";
+}
+function alignToolRound(assistant, collected) {
+  const calls = Array.isArray(assistant.tool_calls) ? assistant.tool_calls : [];
+  const byId = new Map;
+  for (const m of collected) {
+    const list = byId.get(m.tool_call_id);
+    if (list)
+      list.push(m);
+    else
+      byId.set(m.tool_call_id, [m]);
+  }
+  const ordered = [];
+  let synthesized = 0;
+  for (const call of calls) {
+    const matched = byId.get(call.id);
+    if (matched) {
+      ordered.push(...matched);
+      byId.delete(call.id);
+      continue;
+    }
+    synthesized++;
+    log(`[OpenAIMessages] error \u2014 tool call ${call.id} (${call.function?.name || "?"}) has no ` + "result; a synthetic tool message names the omission");
+    ordered.push({
+      role: "tool",
+      content: missingResultText(call.function?.name || ""),
+      tool_call_id: call.id
+    });
+  }
+  let dropped = 0;
+  for (const [id, list] of byId) {
+    dropped += list.length;
+    log(`[OpenAIMessages] error \u2014 tool result ${id} matches no call in the round it follows; dropped`);
+  }
+  const reordered = ordered.some((m, i) => m !== collected[i]);
+  if (reordered && !synthesized && !dropped) {
+    log(`[OpenAIMessages] Reordered ${ordered.length} tool results to their tool_calls order`);
+  }
+  return ordered;
+}
+function imageBlockToUrlPart(block) {
+  const source = block?.source;
+  if (!source || typeof source !== "object") {
+    log("[OpenAIMessages] Dropping image block: error \u2014 no source object");
+    return null;
+  }
+  const url = typeof source.url === "string" ? source.url : "";
+  const data = typeof source.data === "string" ? source.data : "";
+  const kind = source.type || (url ? "url" : data ? "base64" : "");
+  if (kind === "url") {
+    if (!url) {
+      log("[OpenAIMessages] Dropping image block: error \u2014 url source carries no url");
+      return null;
+    }
+    return { type: "image_url", image_url: { url } };
+  }
+  if (kind === "base64") {
+    if (!data) {
+      log("[OpenAIMessages] Dropping image block: error \u2014 base64 source carries no data");
+      return null;
+    }
+    const mediaType = typeof source.media_type === "string" ? source.media_type : "";
+    if (!mediaType) {
+      log("[OpenAIMessages] Dropping image block: error \u2014 base64 source carries no media_type");
+      return null;
+    }
+    return { type: "image_url", image_url: { url: `data:${mediaType};base64,${data}` } };
+  }
+  log(`[OpenAIMessages] Dropping image block: error \u2014 unsupported source type ${kind || "(none)"}`);
+  return null;
 }
 function processUserMessage(msg, messages, simpleFormat = false) {
   if (Array.isArray(msg.content)) {
@@ -19129,7 +19318,9 @@ function processUserMessage(msg, messages, simpleFormat = false) {
         }
       } else if (block.type === "image") {
         if (!simpleFormat) {
-          contentParts.push(imageBlockToUrlPart(block));
+          const part = imageBlockToUrlPart(block);
+          if (part)
+            contentParts.push(part);
         }
       } else if (block.type === "tool_result") {
         if (seen.has(block.tool_use_id))
@@ -19141,12 +19332,21 @@ function processUserMessage(msg, messages, simpleFormat = false) {
         } else if (Array.isArray(block.content)) {
           const texts = [];
           const others = [];
+          let forwardedImages = 0;
+          let droppedImages = 0;
           for (const inner of block.content) {
             if (inner.type === "text") {
               texts.push(inner.text);
             } else if (inner.type === "image" && inner.source) {
-              if (!simpleFormat)
-                toolResultImages.push(imageBlockToUrlPart(inner));
+              if (!simpleFormat) {
+                const part = imageBlockToUrlPart(inner);
+                if (part) {
+                  toolResultImages.push(part);
+                  forwardedImages++;
+                } else {
+                  droppedImages++;
+                }
+              }
             } else {
               others.push(inner);
             }
@@ -19157,7 +19357,12 @@ function processUserMessage(msg, messages, simpleFormat = false) {
             resultText += (resultText ? `
 ` : "") + JSON.stringify(others);
           if (!resultText) {
-            resultText = toolResultImages.length ? "[image returned; see following message]" : "";
+            if (forwardedImages)
+              resultText = "[image returned; see following message]";
+            else if (droppedImages)
+              resultText = "[image returned, but its source could not be forwarded]";
+            else
+              resultText = "";
           }
         } else {
           resultText = JSON.stringify(block.content);
@@ -19243,6 +19448,9 @@ function processAssistantMessage(msg, messages, simpleFormat = false) {
     messages.push({ role: "assistant", content: msg.content });
   }
 }
+var init_openai_messages = __esm(() => {
+  init_logger();
+});
 
 // src/transform.ts
 function removeUriFormat(schema) {
@@ -19452,6 +19660,45 @@ function summarizeToolParameters(schema) {
   }
   return summarized;
 }
+function mapToolChoiceToOpenAI(choice, encodeName) {
+  if (!choice)
+    return;
+  const { type, name } = choice;
+  if (type === "tool" && name) {
+    return { type: "function", function: { name: encodeName ? encodeName(name) : name } };
+  }
+  if (type === "any")
+    return "required";
+  if (type === "auto" || type === "none")
+    return type;
+  return;
+}
+function mapToolChoiceToResponsesAPI(choice, encodeName) {
+  const mapped = mapToolChoiceToOpenAI(choice, encodeName);
+  if (mapped === undefined || typeof mapped === "string")
+    return mapped;
+  return { type: "function", name: mapped.function.name };
+}
+function mapToolChoiceToGemini(choice, encodeName) {
+  if (!choice)
+    return;
+  const { type, name } = choice;
+  if (type === "tool" && name) {
+    return {
+      functionCallingConfig: {
+        mode: "ANY",
+        allowedFunctionNames: [encodeName ? encodeName(name) : name]
+      }
+    };
+  }
+  if (type === "any")
+    return { functionCallingConfig: { mode: "ANY" } };
+  if (type === "auto")
+    return { functionCallingConfig: { mode: "AUTO" } };
+  if (type === "none")
+    return { functionCallingConfig: { mode: "NONE" } };
+  return;
+}
 var PORTABLE_ESCAPE_LETTERS, NAMED_SCHEMA_MAPS;
 var init_openai_tools = __esm(() => {
   init_logger();
@@ -19494,7 +19741,11 @@ function isEffortLevel(value) {
 class BaseAPIFormat {
   modelId;
   wireFormat;
-  toolNameMap = new Map;
+  responseWireFormat;
+  setResponseWireFormat(format) {
+    this.responseWireFormat = format;
+  }
+  toolNameBindings = newToolNameBindings();
   constructor(modelId, wireFormat) {
     this.modelId = modelId;
     this.wireFormat = wireFormat;
@@ -19505,20 +19756,52 @@ class BaseAPIFormat {
   getWireFormat() {
     return this.wireFormat;
   }
+  recoverFromRejection(payload, errorText) {
+    return this.recoverFromSamplingParamRejection(payload, errorText);
+  }
+  recoverFromSamplingParamRejection(payload, errorText) {
+    if (!payload)
+      return null;
+    const present = OPTIONAL_SAMPLING_PARAMS.filter((p) => payload[p] !== undefined);
+    if (present.length === 0)
+      return null;
+    const rejected = rejectedOptionalParams(errorText, present);
+    if (rejected.length === 0)
+      return null;
+    const next = { ...payload };
+    for (const p of rejected)
+      delete next[p];
+    return { payload: next, note: `dropped ${rejected.join(", ")} for ${this.modelId}` };
+  }
+  applyOpenAISamplingParams(payload, claudeRequest) {
+    if (!payload || !claudeRequest)
+      return;
+    const sequences = claudeRequest.stop_sequences;
+    if (Array.isArray(sequences)) {
+      const usable = sequences.filter((s) => typeof s === "string" && s.length > 0);
+      if (usable.length > 0)
+        payload.stop = usable;
+    }
+    if (claudeRequest.top_p !== undefined && claudeRequest.top_p !== null) {
+      payload.top_p = claudeRequest.top_p;
+    }
+  }
   getToolNameLimit() {
-    return null;
+    const wire = this.responseWireFormat ?? this.wireFormat ?? this.getStreamFormat();
+    return wireDecodesToolNames(wire) ? OPENAI_TOOL_NAME_LIMIT : null;
   }
   getMaxToolCount() {
     return null;
   }
   getToolNameMap() {
-    return this.toolNameMap;
+    return this.toolNameBindings.byEncoded;
   }
   restoreToolName(name) {
-    return this.toolNameMap.get(name) || name;
+    return this.toolNameBindings.byEncoded.get(name) || name;
   }
   prepareRequest(request, originalRequest) {
     const prepared = this.prepareRequestCommon(request, originalRequest) ?? request;
+    this.encodeToolNames(prepared);
     if (!this.isAnthropicWire()) {
       return this.applyNativeReasoning(prepared, originalRequest) ?? prepared;
     }
@@ -19656,7 +19939,7 @@ class BaseAPIFormat {
     return;
   }
   reset() {
-    this.toolNameMap.clear();
+    this.toolNameBindings = newToolNameBindings();
   }
   convertMessages(claudeRequest, filterIdentityFn) {
     return convertMessagesToOpenAI(claudeRequest, this.modelId, filterIdentityFn);
@@ -19672,6 +19955,10 @@ class BaseAPIFormat {
     };
     if (tools.length > 0) {
       payload.tools = tools;
+      const toolChoice = mapToolChoiceToOpenAI(claudeRequest.tool_choice);
+      if (toolChoice !== undefined) {
+        payload.tool_choice = toolChoice;
+      }
     }
     if (claudeRequest.max_tokens) {
       payload.max_tokens = claudeRequest.max_tokens;
@@ -19679,6 +19966,7 @@ class BaseAPIFormat {
     if (claudeRequest.temperature !== undefined) {
       payload.temperature = claudeRequest.temperature;
     }
+    this.applyOpenAISamplingParams(payload, claudeRequest);
     return payload;
   }
   getStreamFormat() {
@@ -19696,50 +19984,56 @@ class BaseAPIFormat {
   shouldFilterThinking() {
     return this.isAnthropicWire();
   }
-  truncateToolNames(request) {
+  encodeToolNames(request) {
     const limit = this.getToolNameLimit();
-    if (!limit || !request.tools)
+    if (!limit || !request)
       return;
-    for (const tool of request.tools) {
-      const originalName = tool.function?.name || tool.name;
-      if (originalName && originalName.length > limit) {
-        const truncated = truncateToolName(originalName, limit);
-        this.toolNameMap.set(truncated, originalName);
-        if (tool.function?.name) {
-          tool.function.name = truncated;
-        } else if (tool.name) {
-          tool.name = truncated;
+    const encode = (name) => encodeToolName(name, limit, this.toolNameBindings);
+    if (Array.isArray(request.tools)) {
+      for (const tool of request.tools) {
+        if (tool?.function?.name) {
+          tool.function.name = encode(tool.function.name);
+        } else if (tool?.name) {
+          tool.name = encode(tool.name);
         }
       }
     }
-  }
-  truncateToolNamesInMessages(messages) {
-    const limit = this.getToolNameLimit();
-    if (!limit)
-      return;
-    for (const msg of messages) {
-      if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+    if (Array.isArray(request.messages)) {
+      for (const msg of request.messages) {
+        if (msg?.role !== "assistant" || !Array.isArray(msg.tool_calls))
+          continue;
         for (const tc of msg.tool_calls) {
-          const name = tc.function?.name;
-          if (name && name.length > limit) {
-            const truncated = truncateToolName(name, limit);
-            tc.function.name = truncated;
-            if (!this.toolNameMap.has(truncated)) {
-              this.toolNameMap.set(truncated, name);
-            }
-          }
+          if (tc?.function?.name)
+            tc.function.name = encode(tc.function.name);
         }
       }
     }
+    if (Array.isArray(request.input)) {
+      for (const item of request.input) {
+        if (item?.type === "function_call" && item.name)
+          item.name = encode(item.name);
+      }
+    }
+    const choice = request.tool_choice;
+    if (choice && typeof choice === "object") {
+      if (choice.function?.name) {
+        choice.function.name = encode(choice.function.name);
+      } else if (choice.name) {
+        choice.name = encode(choice.name);
+      }
+    }
   }
 }
-var EFFORT_ORDER, EFFORT_LEVELS, NON_ANTHROPIC_REASONING_FIELDS, DefaultAPIFormat;
+var OPTIONAL_SAMPLING_PARAMS, OPENAI_TOOL_NAME_LIMIT = 64, EFFORT_ORDER, EFFORT_LEVELS, NON_ANTHROPIC_REASONING_FIELDS, DefaultAPIFormat;
 var init_base_api_format = __esm(() => {
   init_remote_provider_types();
   init_logger();
   init_model_catalog();
+  init_optional_param_rejection();
   init_tool_name_utils();
+  init_openai_messages();
   init_openai_tools();
+  OPTIONAL_SAMPLING_PARAMS = ["stop", "top_p"];
   EFFORT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
   EFFORT_LEVELS = EFFORT_ORDER;
   NON_ANTHROPIC_REASONING_FIELDS = [
@@ -19922,6 +20216,7 @@ function normalizeCodexModel(modelId) {
 }
 var CodexAPIFormat;
 var init_codex_api_format = __esm(() => {
+  init_openai_tools();
   init_logger();
   init_base_api_format();
   init_reasoning_cache();
@@ -19987,6 +20282,10 @@ var init_codex_api_format = __esm(() => {
           }
           return tool;
         });
+        const toolChoice = mapToolChoiceToResponsesAPI(claudeRequest.tool_choice);
+        if (toolChoice !== undefined) {
+          payload.tool_choice = toolChoice;
+        }
       }
       return payload;
     }
@@ -20568,31 +20867,308 @@ function filterIdentity(content) {
 `);
 }
 
+// src/handlers/shared/schema-validate.ts
+function missingRequired(schema, args) {
+  const required = schema?.required;
+  if (!Array.isArray(required) || required.length === 0)
+    return [];
+  const supplied = args ?? {};
+  return required.filter((key) => {
+    if (typeof key !== "string")
+      return false;
+    if (!Object.hasOwn(supplied, key))
+      return true;
+    const value = supplied[key];
+    return value === undefined || value === null;
+  });
+}
+function isAbsent(args, key) {
+  if (!Object.hasOwn(args, key))
+    return true;
+  const value = args[key];
+  return value === undefined || value === null;
+}
+function declaredTypes(node) {
+  if (!node)
+    return [];
+  const t = node.type;
+  if (typeof t === "string")
+    return [t];
+  if (Array.isArray(t))
+    return t.filter((x) => typeof x === "string");
+  if (Array.isArray(node.enum) && node.enum.length > 0) {
+    const kinds = new Set;
+    for (const member of node.enum) {
+      if (member === null || member === undefined)
+        continue;
+      if (Array.isArray(member))
+        kinds.add("array");
+      else if (typeof member === "object")
+        kinds.add("object");
+      else if (typeof member === "number")
+        kinds.add(Number.isInteger(member) ? "integer" : "number");
+      else if (typeof member === "boolean")
+        kinds.add("boolean");
+      else if (typeof member === "string")
+        kinds.add("string");
+    }
+    return [...kinds];
+  }
+  return [];
+}
+function coerceOne(value, type, node) {
+  switch (type) {
+    case "string":
+      return typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" ? String(value) : undefined;
+    case "number":
+    case "integer": {
+      if (typeof value === "number") {
+        return type === "integer" && !Number.isInteger(value) ? undefined : value;
+      }
+      if (typeof value !== "string" || !FULL_NUMBER.test(value.trim()))
+        return;
+      const n = Number(value.trim());
+      if (!Number.isFinite(n))
+        return;
+      return type === "integer" && !Number.isInteger(n) ? undefined : n;
+    }
+    case "boolean": {
+      if (typeof value === "boolean")
+        return value;
+      if (typeof value !== "string")
+        return;
+      const s = value.trim().toLowerCase();
+      return s === "true" ? true : s === "false" ? false : undefined;
+    }
+    case "array": {
+      const arr = Array.isArray(value) ? value : parseJsonOfKind(value, "array");
+      if (!Array.isArray(arr))
+        return;
+      const items = node?.items;
+      if (!items)
+        return arr;
+      return arr.map((el) => {
+        const target = declaredTypes(items);
+        for (const t of target) {
+          const c = coerceOne(el, t, items);
+          if (c !== undefined)
+            return c;
+        }
+        return el;
+      });
+    }
+    case "object":
+      return value && typeof value === "object" && !Array.isArray(value) ? value : parseJsonOfKind(value, "object");
+    default:
+      return;
+  }
+}
+function parseJsonOfKind(value, kind) {
+  if (typeof value !== "string")
+    return;
+  try {
+    const parsed = JSON.parse(value);
+    if (kind === "array")
+      return Array.isArray(parsed) ? parsed : undefined;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function coerceToSchema(schema, args) {
+  const properties = schema?.properties;
+  if (!properties)
+    return { args, coerced: [] };
+  const out = { ...args };
+  const coerced = [];
+  for (const [key, value] of Object.entries(args)) {
+    const node = properties[key];
+    if (!node || value === undefined || value === null)
+      continue;
+    const types = declaredTypes(node);
+    if (types.length === 0)
+      continue;
+    if (types.some((t) => matchesType(value, t)))
+      continue;
+    for (const t of types) {
+      const c = coerceOne(value, t, node);
+      if (c !== undefined) {
+        out[key] = c;
+        coerced.push(key);
+        break;
+      }
+    }
+  }
+  return { args: coerced.length > 0 ? out : args, coerced };
+}
+function matchesType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return !!value && typeof value === "object" && !Array.isArray(value);
+    case "null":
+      return value === null;
+    default:
+      return false;
+  }
+}
+function applySchemaDefaults(schema, args) {
+  const properties = schema?.properties;
+  const required = schema?.required;
+  if (!properties || !Array.isArray(required))
+    return { args, applied: [] };
+  const out = { ...args };
+  const applied = [];
+  for (const key of required) {
+    if (typeof key !== "string" || !isAbsent(out, key))
+      continue;
+    const node = properties[key];
+    if (!node || !Object.hasOwn(node, "default") || node.default === undefined)
+      continue;
+    out[key] = node.default;
+    applied.push(key);
+  }
+  return { args: applied.length > 0 ? out : args, applied };
+}
+function renameToDeclaredKeys(schema, args) {
+  const properties = schema?.properties;
+  const required = schema?.required;
+  if (!properties || !Array.isArray(required))
+    return { args, renamed: [] };
+  const out = { ...args };
+  const renamed = [];
+  for (const target of required) {
+    if (typeof target !== "string")
+      continue;
+    if (!properties[target] || !isAbsent(out, target))
+      continue;
+    for (const source of KEY_SYNONYMS[target] ?? []) {
+      if (properties[source])
+        continue;
+      if (isAbsent(out, source))
+        continue;
+      out[target] = out[source];
+      delete out[source];
+      renamed.push(`${source}\u2192${target}`);
+      break;
+    }
+  }
+  return { args: renamed.length > 0 ? out : args, renamed };
+}
+var FULL_NUMBER, KEY_SYNONYMS;
+var init_schema_validate = __esm(() => {
+  FULL_NUMBER = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+  KEY_SYNONYMS = {
+    command: ["cmd", "shell", "script"],
+    file_path: ["path", "file", "filename"],
+    content: ["text", "data", "body"],
+    pattern: ["query", "search", "regex", "glob"],
+    query: ["search", "keyword"],
+    prompt: ["query", "task"]
+  };
+});
+
 // src/handlers/shared/tool-call-recovery.ts
 function hasExtractableFunctionTag(text) {
   return FUNCTION_TAG_PRESENT.test(text);
 }
-function keepOnlyRealTools(extracted, knownToolNames) {
+function keepOnlyRealTools(extracted, knownToolNames, decodeToolName) {
   const kept = [];
   for (const call of extracted) {
     if (!TOOL_NAME_SHAPE.test(call.name)) {
       log(`[ToolRecovery] Dropped extracted call: name is not an identifier: ${JSON.stringify(call.name.slice(0, 120))}`);
       continue;
     }
+    const decoded = decodeToolName ? decodeToolName(call.name) : call.name;
+    const named = decoded === call.name ? call : { ...call, name: decoded };
     if (!knownToolNames || knownToolNames.length === 0) {
-      kept.push(call);
+      kept.push(named);
       continue;
     }
-    const canonical = knownToolNames.find((t) => t.toLowerCase() === call.name.toLowerCase());
+    const canonical = knownToolNames.find((t) => t.toLowerCase() === named.name.toLowerCase());
     if (!canonical) {
-      log(`[ToolRecovery] Dropped extracted call for unadvertised tool: ${call.name}`);
+      log(`[ToolRecovery] Dropped extracted call for unadvertised tool: ${named.name}`);
       continue;
     }
-    kept.push(canonical === call.name ? call : { ...call, name: canonical });
+    kept.push(canonical === named.name ? named : { ...named, name: canonical });
   }
   return kept;
 }
-function extractToolCallsFromText(text, knownToolNames) {
+function parseFunctionTagEnvelope(text) {
+  const body = text.trim();
+  if (body.length === 0)
+    return null;
+  if (!body.startsWith("<function="))
+    return null;
+  const calls = [];
+  let cursor = 0;
+  while (cursor < body.length) {
+    FUNCTION_TAG_AT_CURSOR.lastIndex = cursor;
+    const open = FUNCTION_TAG_AT_CURSOR.exec(body);
+    if (!open)
+      return null;
+    cursor = FUNCTION_TAG_AT_CURSOR.lastIndex;
+    const args = {};
+    while (cursor < body.length) {
+      const rest = body.slice(cursor);
+      const closeLen = /^\s*<\/function>/.exec(rest)?.[0].length;
+      if (closeLen !== undefined) {
+        cursor += closeLen;
+        break;
+      }
+      if (/^\s*<function=/.test(rest))
+        break;
+      const lead = /^\s*/.exec(rest)?.[0].length ?? 0;
+      PARAMETER_TAG_AT_CURSOR.lastIndex = cursor + lead;
+      const param = PARAMETER_TAG_AT_CURSOR.exec(body);
+      if (!param)
+        return null;
+      let valueStart = PARAMETER_TAG_AT_CURSOR.lastIndex;
+      if (body[valueStart] === `
+`)
+        valueStart += 1;
+      const tail = body.slice(valueStart);
+      const end = /<\/parameter>|<\/function>|<parameter=|<function=/.exec(tail);
+      const raw = end ? tail.slice(0, end.index) : tail;
+      args[param[1]] = raw.trim();
+      cursor = valueStart + raw.length;
+      const consumedClose = /^<\/parameter>/.exec(body.slice(cursor))?.[0].length;
+      if (consumedClose !== undefined)
+        cursor += consumedClose;
+    }
+    calls.push({ name: open[1], arguments: args, source: "xml_text" });
+    const gap = /^\s*/.exec(body.slice(cursor))?.[0].length ?? 0;
+    cursor += gap;
+  }
+  return calls.length > 0 ? calls : null;
+}
+function normalizeAgainstSchema(call, toolSchemas) {
+  const schema = toolSchemas?.find((t) => t.name === call.name)?.input_schema;
+  if (!schema)
+    return call;
+  const renamed = renameToDeclaredKeys(schema, call.arguments);
+  const defaulted = applySchemaDefaults(schema, renamed.args);
+  const coerced = coerceToSchema(schema, defaulted.args);
+  if (renamed.renamed.length + defaulted.applied.length + coerced.coerced.length === 0) {
+    return call;
+  }
+  log(`[ToolRecovery] Normalized ${call.name} against its schema: ` + `renamed=[${renamed.renamed}] defaults=[${defaulted.applied}] coerced=[${coerced.coerced}]`);
+  return { ...call, arguments: coerced.args };
+}
+function extractToolCallsFromText(text, knownToolNames, toolSchemas, decodeToolName) {
+  const envelope = parseFunctionTagEnvelope(text);
+  if (envelope) {
+    return keepOnlyRealTools(envelope, knownToolNames, decodeToolName).map((call) => normalizeAgainstSchema(call, toolSchemas));
+  }
   const extracted = [];
   const qwenPattern = new RegExp(FUNCTION_TAG_SOURCE, "gi");
   let match;
@@ -20719,73 +21295,6 @@ function extractToolCallsFromText(text, knownToolNames) {
       while ((kvMatch = kvPattern.exec(paramText)) !== null) {
         args[kvMatch[1]] = kvMatch[2];
       }
-      const quotedPattern = /["']([^"']+)["']/g;
-      let quotedMatch;
-      const quotedValues = [];
-      while ((quotedMatch = quotedPattern.exec(paramText)) !== null) {
-        quotedValues.push(quotedMatch[1]);
-      }
-      if (normalizedToolName === "Task") {
-        if (!args.subagent_type) {
-          const stMatch = paramText.match(/subagent_type\s*[=:]\s*["']?(\w+)["']?/i);
-          if (stMatch) {
-            args.subagent_type = stMatch[1];
-          } else if (/explore|codebase|structure/i.test(paramText)) {
-            args.subagent_type = "Explore";
-          } else if (/plan|architect/i.test(paramText)) {
-            args.subagent_type = "Plan";
-          } else {
-            args.subagent_type = "general-purpose";
-          }
-        }
-        if (!args.prompt) {
-          const toMatch = paramText.match(/\bto\s+(.+)/i);
-          if (toMatch) {
-            args.prompt = toMatch[1].trim();
-          } else {
-            args.prompt = paramText.trim();
-          }
-        }
-        if (!args.description) {
-          args.description = (args.prompt || paramText).substring(0, 50).trim();
-        }
-      } else if (normalizedToolName === "Read") {
-        if (!args.file_path) {
-          if (quotedValues.length > 0) {
-            args.file_path = quotedValues[0];
-          } else {
-            const pathMatch = paramText.match(/(?:read|file)\s+([\/\w.-]+)/i);
-            if (pathMatch) {
-              args.file_path = pathMatch[1];
-            }
-          }
-        }
-      } else if (normalizedToolName === "Bash") {
-        if (!args.command) {
-          if (quotedValues.length > 0) {
-            args.command = quotedValues[0];
-          } else {
-            const cmdMatch = paramText.match(/(?:run|execute)\s+(.+)/i);
-            if (cmdMatch) {
-              args.command = cmdMatch[1].trim();
-            }
-          }
-        }
-        if (args.command && !args.description) {
-          args.description = `Run ${args.command.split(" ")[0]} command`;
-        }
-      } else if (normalizedToolName === "Grep" || normalizedToolName === "Glob") {
-        if (!args.pattern) {
-          if (quotedValues.length > 0) {
-            args.pattern = quotedValues[0];
-          } else {
-            const searchMatch = paramText.match(/(?:search|find|look for)\s+(.+)/i);
-            if (searchMatch) {
-              args.pattern = searchMatch[1].trim();
-            }
-          }
-        }
-      }
       if (Object.keys(args).length > 0) {
         extracted.push({
           name: normalizedToolName,
@@ -20796,139 +21305,7 @@ function extractToolCallsFromText(text, knownToolNames) {
       }
     }
   }
-  return keepOnlyRealTools(extracted, knownToolNames);
-}
-function inferMissingParameters(toolName, args, missingParams, context) {
-  const inferred = { ...args };
-  if (toolName === "Task") {
-    const validSubagentTypes = [
-      "general-purpose",
-      "Explore",
-      "Plan",
-      "claude-code-guide",
-      "code-analysis:detective",
-      "feature-dev:code-architect",
-      "feature-dev:code-explorer",
-      "feature-dev:code-reviewer"
-    ];
-    if (inferred.subagent_type) {
-      const st = inferred.subagent_type.toLowerCase();
-      if (st.includes("explore") || st.includes("codebase") || st.includes("file")) {
-        inferred.subagent_type = "Explore";
-      } else if (st.includes("plan") || st.includes("architect")) {
-        inferred.subagent_type = "Plan";
-      } else if (st.includes("analysis") || st.includes("analyz") || st.includes("config") || st.includes("git") || st.includes("test") || st.includes("doc") || st.includes("version")) {
-        inferred.subagent_type = "general-purpose";
-      } else if (!validSubagentTypes.includes(inferred.subagent_type)) {
-        log(`[ToolRecovery] Unknown subagent_type "${inferred.subagent_type}", mapping to general-purpose`);
-        inferred.subagent_type = "general-purpose";
-      }
-    }
-    if (missingParams.includes("subagent_type") && !inferred.subagent_type) {
-      inferred.subagent_type = "general-purpose";
-      log("[ToolRecovery] Inferred subagent_type: general-purpose");
-    }
-    let extractedTask = "";
-    if (context) {
-      const patterns = [
-        /(?:I(?:'ll| will| need to| want to| am going to)|Let me|Going to)\s+([^.!?\n]+)/i,
-        /(?:help you|assist with)\s+([^.!?\n]+)/i,
-        /(?:explore|search|find|look for|investigate)\s+([^.!?\n]+)/i,
-        /(?:implement|create|build|add|fix|update)\s+([^.!?\n]+)/i
-      ];
-      for (const pattern of patterns) {
-        const match = context.match(pattern);
-        if (match?.[1] && match[1].length > 10) {
-          extractedTask = match[1].trim();
-          log(`[ToolRecovery] Extracted task from context: "${extractedTask.substring(0, 50)}..."`);
-          break;
-        }
-      }
-      if (!extractedTask && context.length > 20) {
-        const sentences = context.split(/[.!?\n]+/).filter((s) => s.trim().length > 15);
-        if (sentences.length > 0) {
-          extractedTask = sentences[sentences.length - 1].trim();
-        }
-      }
-    }
-    if (missingParams.includes("prompt") && !inferred.prompt) {
-      if (inferred.query) {
-        inferred.prompt = inferred.query;
-        log(`[ToolRecovery] Mapped query -> prompt: "${inferred.query.substring(0, 50)}..."`);
-      } else if (inferred.description && inferred.description !== "Execute task") {
-        inferred.prompt = inferred.description;
-      } else if (inferred.task) {
-        inferred.prompt = inferred.task;
-      } else if (extractedTask) {
-        inferred.prompt = extractedTask;
-      } else if (context && context.length > 20) {
-        inferred.prompt = context.substring(0, 500).trim();
-      }
-      if (inferred.prompt) {
-        log(`[ToolRecovery] Inferred prompt: "${inferred.prompt.substring(0, 50)}..."`);
-      }
-    }
-    if (missingParams.includes("description") && !inferred.description) {
-      if (inferred.prompt) {
-        inferred.description = inferred.prompt.substring(0, 50).replace(/\s+/g, " ").trim();
-        if (inferred.description.length < inferred.prompt.length) {
-          inferred.description += "...";
-        }
-      } else if (extractedTask) {
-        inferred.description = extractedTask.substring(0, 50).trim();
-      } else {
-        inferred.description = "Execute task";
-      }
-      log(`[ToolRecovery] Inferred description: ${inferred.description}`);
-    }
-  }
-  if (toolName === "Bash") {
-    if (missingParams.includes("command") && !inferred.command) {
-      inferred.command = inferred.cmd || inferred.shell || inferred.script || "";
-    }
-    if (missingParams.includes("description") && !inferred.description) {
-      if (inferred.command) {
-        const cmd = inferred.command.split(" ")[0];
-        inferred.description = `Run ${cmd} command`;
-      }
-    }
-  }
-  if (toolName === "Read") {
-    if (missingParams.includes("file_path") && !inferred.file_path) {
-      inferred.file_path = inferred.path || inferred.file || inferred.filename || "";
-    }
-  }
-  if (toolName === "Write") {
-    if (missingParams.includes("file_path") && !inferred.file_path) {
-      inferred.file_path = inferred.path || inferred.file || inferred.filename || "";
-    }
-    if (missingParams.includes("content") && !inferred.content) {
-      inferred.content = inferred.text || inferred.data || inferred.body || "";
-    }
-  }
-  if (toolName === "Grep") {
-    if (missingParams.includes("pattern") && !inferred.pattern) {
-      inferred.pattern = inferred.query || inferred.search || inferred.regex || "";
-    }
-  }
-  if (toolName === "Glob") {
-    if (missingParams.includes("pattern") && !inferred.pattern) {
-      inferred.pattern = inferred.glob || inferred.path || inferred.search || "**/*";
-    }
-  }
-  if (toolName === "ToolSearch") {
-    if (missingParams.includes("max_results") && inferred.max_results === undefined) {
-      inferred.max_results = 5;
-      log("[ToolRecovery] Inferred max_results: 5 (default)");
-    }
-    if (missingParams.includes("query") && !inferred.query) {
-      inferred.query = inferred.search || inferred.keyword || inferred.tool || "";
-      if (inferred.query) {
-        log(`[ToolRecovery] Inferred ToolSearch query: "${inferred.query}"`);
-      }
-    }
-  }
-  return inferred;
+  return keepOnlyRealTools(extracted, knownToolNames, decodeToolName);
 }
 function validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent) {
   const schema = toolSchemas.find((t) => t.name === toolName);
@@ -20940,7 +21317,7 @@ function validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent)
     parsedArgs = argsStr ? JSON.parse(argsStr) : {};
   } catch (e) {
     if (textContent) {
-      const extracted = extractToolCallsFromText(textContent);
+      const extracted = extractToolCallsFromText(textContent, toolSchemas.map((t) => t.name), toolSchemas);
       const matching = extracted.find((tc) => tc.name === toolName);
       if (matching) {
         parsedArgs = matching.arguments;
@@ -20948,25 +21325,33 @@ function validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent)
       }
     }
   }
-  const required = schema.input_schema.required || [];
-  const missingParams = required.filter((param) => parsedArgs[param] === undefined || parsedArgs[param] === null || parsedArgs[param] === "");
-  if (missingParams.length === 0) {
-    return { valid: true, args: parsedArgs, repaired: false, missingParams: [] };
+  const input = schema.input_schema;
+  const renamed = renameToDeclaredKeys(input, parsedArgs);
+  const defaulted = applySchemaDefaults(input, renamed.args);
+  const coerced = coerceToSchema(input, defaulted.args);
+  const args = coerced.args;
+  const repaired = renamed.renamed.length > 0 || defaulted.applied.length > 0;
+  if (repaired) {
+    log(`[ToolRecovery] ${toolName}: applied schema defaults [${defaulted.applied}] ` + `and key renames [${renamed.renamed}] \u2014 nothing was invented`);
+  }
+  if (coerced.coerced.length > 0) {
+    log(`[ToolRecovery] ${toolName}: coerced to declared types [${coerced.coerced}]`);
   }
-  const repairedArgs = inferMissingParameters(toolName, parsedArgs, missingParams, textContent);
-  const stillMissing = required.filter((param) => repairedArgs[param] === undefined || repairedArgs[param] === null || repairedArgs[param] === "");
-  if (stillMissing.length === 0) {
-    log(`[ToolRecovery] Successfully repaired tool call ${toolName}`);
-    return { valid: true, args: repairedArgs, repaired: true, missingParams: [] };
+  const missingParams = missingRequired(input, args);
+  if (missingParams.length === 0) {
+    return { valid: true, args, repaired, missingParams: [] };
   }
-  return { valid: false, args: repairedArgs, repaired: false, missingParams: stillMissing };
+  return { valid: false, args, repaired: false, missingParams };
 }
-var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT;
+var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT, FUNCTION_TAG_AT_CURSOR, PARAMETER_TAG_AT_CURSOR;
 var init_tool_call_recovery = __esm(() => {
   init_tool_name_utils();
   init_logger();
+  init_schema_validate();
   FUNCTION_TAG_SOURCE = `<function=(${TOOL_NAME_SOURCE})>([\\s\\S]*?)(?=<function=|$)`;
   FUNCTION_TAG_PRESENT = new RegExp(`<function=${TOOL_NAME_SOURCE}>`);
+  FUNCTION_TAG_AT_CURSOR = new RegExp(`<function=(${TOOL_NAME_SOURCE})>`, "y");
+  PARAMETER_TAG_AT_CURSOR = /<parameter=([^>\s]+)>/y;
 });
 
 // src/handlers/shared/web-search-detector.ts
@@ -20983,11 +21368,218 @@ var init_web_search_detector = __esm(() => {
   WEB_SEARCH_NAMES = new Set(["web_search", "brave_web_search", "tavily_search"]);
 });
 
+// src/handlers/shared/stream-parsers/block-writer.ts
+function createBlockWriter(send) {
+  let nextIndex = 0;
+  let openRef = null;
+  let anyBlockEmitted = false;
+  const emittedToolRefs = [];
+  const stopped = new Set;
+  const describe = (ref) => ref ? `${ref.kind}@${ref.index}` : "none";
+  const spendableIndex = (requested, kind) => {
+    if (requested === undefined)
+      return nextIndex++;
+    if (!stopped.has(requested))
+      return requested;
+    const replacement = nextIndex++;
+    log(`[BlockWriter] open error: index ${requested} was already stopped; ${kind} block re-indexed to ${replacement}`);
+    return replacement;
+  };
+  const closeCurrent = () => {
+    if (!openRef)
+      return;
+    send("content_block_stop", { type: "content_block_stop", index: openRef.index });
+    stopped.add(openRef.index);
+    openRef = null;
+  };
+  const start = (ref, contentBlock) => {
+    send("content_block_start", {
+      type: "content_block_start",
+      index: ref.index,
+      content_block: contentBlock
+    });
+    openRef = ref;
+    anyBlockEmitted = true;
+    return ref;
+  };
+  const writer = {
+    openText(opts) {
+      if (openRef?.kind === "text") {
+        if (opts?.index !== undefined && opts.index !== openRef.index) {
+          log(`[BlockWriter] reusing open text block @${openRef.index}; reserved index ${opts.index} goes unused`);
+        }
+        return openRef;
+      }
+      closeCurrent();
+      const index = spendableIndex(opts?.index, "text");
+      return start({ index, kind: "text" }, { type: "text", text: "" });
+    },
+    openThinking() {
+      if (openRef?.kind === "thinking")
+        return openRef;
+      closeCurrent();
+      return start({ index: nextIndex++, kind: "thinking" }, { type: "thinking", thinking: "" });
+    },
+    openTool({ id, name, index }) {
+      closeCurrent();
+      const ref = {
+        index: spendableIndex(index, "tool_use"),
+        kind: "tool_use",
+        toolId: id
+      };
+      start(ref, { type: "tool_use", id, name, input: {} });
+      emittedToolRefs.push(ref);
+      return ref;
+    },
+    append(ref, payload) {
+      if (!openRef || openRef.index !== ref.index || openRef.kind !== ref.kind) {
+        log(`[BlockWriter] append error: ${describe(ref)} is not the open block (open=${describe(openRef)}); ${payload.length} chars withheld for the caller to handle`);
+        return false;
+      }
+      const delta = ref.kind === "text" ? { type: "text_delta", text: payload } : ref.kind === "thinking" ? { type: "thinking_delta", thinking: payload } : { type: "input_json_delta", partial_json: payload };
+      send("content_block_delta", { type: "content_block_delta", index: ref.index, delta });
+      return true;
+    },
+    close(ref) {
+      if (openRef && openRef.index === ref.index && openRef.kind === ref.kind) {
+        closeCurrent();
+        return;
+      }
+      if (stopped.has(ref.index))
+        return;
+      log(`[BlockWriter] close error: ${describe(ref)} was never opened and is not stopped (open=${describe(openRef)})`);
+    },
+    closeCurrent,
+    reserve() {
+      return nextIndex++;
+    },
+    get openRef() {
+      return openRef;
+    },
+    get anyBlockEmitted() {
+      return anyBlockEmitted;
+    },
+    get emittedToolRefs() {
+      return emittedToolRefs;
+    }
+  };
+  return writer;
+}
+var init_block_writer = __esm(() => {
+  init_logger();
+});
+
 // src/handlers/shared/stream-parsers/message-start-usage.ts
 function messageStartUsage(priorInputTokens) {
   return {
     input_tokens: priorInputTokens && priorInputTokens > 0 ? priorInputTokens : 100,
-    output_tokens: 1
+    output_tokens: 1,
+    cache_read_input_tokens: 0,
+    cache_creation_input_tokens: 0
+  };
+}
+
+// src/handlers/shared/stream-parsers/think-tag-splitter.ts
+function createThinkTagSplitter() {
+  let phase = "deciding";
+  let pending = "";
+  let openArmed = true;
+  const heldSuffixLength = (s) => {
+    for (let n = Math.min(CLOSE.length - 1, s.length);n > 0; n--) {
+      if (CLOSE.startsWith(s.slice(s.length - n)))
+        return n;
+    }
+    return 0;
+  };
+  const consumeThinking = (chunk) => {
+    pending += chunk;
+    const at = pending.indexOf(CLOSE);
+    if (at >= 0) {
+      const thinking = pending.slice(0, at);
+      const text = pending.slice(at + CLOSE.length);
+      pending = "";
+      phase = "passthrough";
+      return { thinking, text };
+    }
+    const hold = heldSuffixLength(pending);
+    const thinking = pending.slice(0, pending.length - hold);
+    pending = hold === 0 ? "" : pending.slice(pending.length - hold);
+    return { thinking, text: "" };
+  };
+  const decide = (isFlush) => {
+    const lead = pending.replace(/^\s+/, "");
+    const releaseAsText = () => {
+      phase = "passthrough";
+      const text = pending;
+      pending = "";
+      return { thinking: "", text };
+    };
+    if (lead === "")
+      return isFlush ? releaseAsText() : EMPTY;
+    if (openArmed && lead.startsWith(OPEN)) {
+      phase = "thinking";
+      pending = "";
+      return consumeThinking(lead.slice(OPEN.length));
+    }
+    if (lead.startsWith(CLOSE)) {
+      phase = "passthrough";
+      pending = "";
+      return { thinking: "", text: lead.slice(CLOSE.length) };
+    }
+    if (openArmed && OPEN.startsWith(lead) || CLOSE.startsWith(lead)) {
+      return isFlush ? releaseAsText() : EMPTY;
+    }
+    return releaseAsText();
+  };
+  return {
+    push(chunk) {
+      if (!chunk)
+        return EMPTY;
+      if (phase === "passthrough")
+        return { thinking: "", text: chunk };
+      if (phase === "thinking")
+        return consumeThinking(chunk);
+      pending += chunk;
+      return decide(false);
+    },
+    flush() {
+      if (phase === "passthrough")
+        return EMPTY;
+      if (phase === "thinking") {
+        const thinking = pending;
+        pending = "";
+        return { thinking, text: "" };
+      }
+      return decide(true);
+    },
+    disarmOpen() {
+      openArmed = false;
+    },
+    get inThinking() {
+      return phase === "thinking";
+    }
+  };
+}
+var OPEN = "<think>", CLOSE = "</think>", EMPTY;
+var init_think_tag_splitter = __esm(() => {
+  EMPTY = { thinking: "", text: "" };
+});
+
+// src/handlers/shared/stream-parsers/usage-cache-split.ts
+function nonNegativeInt(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function splitPromptTokens(usage) {
+  const u = usage ?? {};
+  const promptTokens = nonNegativeInt(u.prompt_tokens);
+  const details = u.prompt_tokens_details ?? {};
+  const cacheReadTokens = Math.min(nonNegativeInt(details.cached_tokens), promptTokens);
+  const cacheCreationTokens = Math.min(nonNegativeInt(details.cache_write_tokens), promptTokens - cacheReadTokens);
+  return {
+    promptTokens,
+    inputTokens: promptTokens - cacheReadTokens - cacheCreationTokens,
+    cacheReadTokens,
+    cacheCreationTokens
   };
 }
 
@@ -21014,12 +21606,9 @@ function createStreamingState() {
   return {
     usage: null,
     finalized: false,
-    textStarted: false,
-    textIdx: -1,
-    reasoningStarted: false,
-    reasoningIdx: -1,
-    curIdx: 0,
     tools: new Map,
+    pendingToolArgs: new Map,
+    pendingToolName: new Map,
     toolIds: new Set,
     lastActivity: Date.now(),
     accumulatedText: "",
@@ -21066,6 +21655,24 @@ data: ${JSON.stringify(d)}
       };
       const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
       const state = createStreamingState();
+      const writer = createBlockWriter(send);
+      const thinkSplitter = createThinkTagSplitter();
+      const emitSplitContent = ({ thinking, text }) => {
+        if (thinking) {
+          behavior?.onAssistantText?.(thinking, "reasoning");
+          writer.append(writer.openThinking(), thinking);
+        }
+        if (!text)
+          return;
+        state.accumulatedText += text;
+        const hasStructuredToolPattern = hasExtractableFunctionTag(state.accumulatedText) || /\{\s*"(?:name|tool)"\s*:\s*"(?:Task|Read|Write|Edit|Bash|Grep|Glob)"/i.test(state.accumulatedText) || /<tool_call>/.test(state.accumulatedText);
+        const shouldHoldBack = hasStructuredToolPattern && state.accumulatedText.length < 1000;
+        if (shouldHoldBack) {
+          log(`[Streaming] Text held back (structured tool pattern): ${state.accumulatedText.length} chars accumulated`);
+          return;
+        }
+        writer.append(writer.openText(), text);
+      };
       send("message_start", {
         type: "message_start",
         message: {
@@ -21110,67 +21717,50 @@ data: ${JSON.stringify(d)}
         }
         state.finalized = true;
         try {
+          emitSplitContent(thinkSplitter.flush());
+          for (const [idx, pending] of state.pendingToolArgs) {
+            log(`[Streaming] Tool argument error: discarding ${pending.length} buffered chars for tool_calls index ${idx} \u2014 function.name never arrived`);
+          }
+          state.pendingToolArgs.clear();
           if (state.accumulatedText.length > 0) {
             const preview = state.accumulatedText.slice(0, 500).replace(/\n/g, "\\n");
             log(`[Streaming] Accumulated text (${state.accumulatedText.length} chars): ${preview}...`);
           }
-          const textToolCalls = state.tools.size > 0 ? [] : extractToolCallsFromText(state.accumulatedText, toolSchemas?.map((t) => t?.name).filter((n) => !!n));
+          const textToolCalls = state.tools.size > 0 ? [] : extractToolCallsFromText(state.accumulatedText, toolSchemas?.map((t) => t?.name).filter((n) => !!n), toolSchemas, toolNameMap ? (name) => toolNameMap.get(name) ?? name : undefined);
           if (state.tools.size > 0 && state.accumulatedText.length > 0) {
             log(`[Streaming] Skipping text-based tool extraction: ${state.tools.size} structured tool call(s) already present`);
           }
           log(`[Streaming] Text-based tool calls found: ${textToolCalls.length}`);
-          if (textToolCalls.length > 0) {
+          const producedContent = state.accumulatedText.length > 0 || writer.anyBlockEmitted || state.tools.size > 0 || textToolCalls.length > 0;
+          const toolInFlight = writer.emittedToolRefs.length > 0 || Array.from(state.tools.values()).some((t) => !t.closed && (t.started || t.buffered)) || textToolCalls.length > 0;
+          const ending = reason === "error" ? "failure" : state.finishReason !== null || !producedContent ? "success" : toolInFlight ? "failure" : "silent-truncation";
+          if (ending !== "success") {
+            log(`[Streaming] Stream ending error: reason=${reason} finish_reason=${state.finishReason ?? "null"} content=${producedContent} tool_in_flight=${toolInFlight} \u2192 ${ending}`);
+          }
+          const emitToolCalls = ending !== "failure";
+          if (textToolCalls.length > 0 && !emitToolCalls) {
+            log(`[Streaming] Suppressing ${textToolCalls.length} text-recovered tool call(s): the turn ended in failure`);
+          } else if (textToolCalls.length > 0) {
             log(`[Streaming] Found ${textToolCalls.length} text-based tool call(s), converting to structured format`);
-            if (state.textStarted) {
-              send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
-              state.textStarted = false;
-            }
             for (const tc of textToolCalls) {
-              const toolIdx = state.curIdx++;
+              const toolIdx = writer.reserve();
               const toolId = `tool_${Date.now()}_${toolIdx}`;
-              send("content_block_start", {
-                type: "content_block_start",
-                index: toolIdx,
-                content_block: { type: "tool_use", id: toolId, name: tc.name }
-              });
-              send("content_block_delta", {
-                type: "content_block_delta",
-                index: toolIdx,
-                delta: {
-                  type: "input_json_delta",
-                  partial_json: repairArgs(tc.name, JSON.stringify(tc.arguments))
-                }
-              });
-              send("content_block_stop", { type: "content_block_stop", index: toolIdx });
+              const ref = writer.openTool({ id: toolId, name: tc.name, index: toolIdx });
+              writer.append(ref, repairArgs(tc.name, JSON.stringify(tc.arguments)));
+              writer.close(ref);
             }
           }
-          if (state.reasoningStarted) {
-            send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
-          }
-          if (state.textStarted) {
-            send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
-          }
-          for (const t of Array.from(state.tools.values())) {
+          writer.closeCurrent();
+          for (const t of emitToolCalls ? Array.from(state.tools.values()) : []) {
             if (!t.closed && t.buffered && !t.started) {
               if (toolSchemas && toolSchemas.length > 0) {
                 const validation = validateToolArguments(t.name, t.arguments, toolSchemas, state.accumulatedText);
                 if (validation.valid || validation.repaired && validation.repairedArgs) {
                   const argsJson = repairArgs(t.name, JSON.stringify(validation.repaired ? validation.repairedArgs : validation.parsedArgs));
                   log(`[Streaming] Sending buffered tool call (finish_reason!=tool_calls): ${t.name} with args: ${argsJson}`);
-                  send("content_block_start", {
-                    type: "content_block_start",
-                    index: t.blockIndex,
-                    content_block: { type: "tool_use", id: t.id, name: t.name }
-                  });
-                  send("content_block_delta", {
-                    type: "content_block_delta",
-                    index: t.blockIndex,
-                    delta: { type: "input_json_delta", partial_json: argsJson }
-                  });
-                  send("content_block_stop", {
-                    type: "content_block_stop",
-                    index: t.blockIndex
-                  });
+                  t.ref = writer.openTool({ id: t.id, name: t.name, index: t.blockIndex });
+                  writer.append(t.ref, argsJson);
+                  writer.close(t.ref);
                   t.started = true;
                   t.closed = true;
                 } else {
@@ -21180,20 +21770,9 @@ data: ${JSON.stringify(d)}
               } else {
                 const argsJson = repairArgs(t.name, t.arguments || "{}");
                 log(`[Streaming] Sending buffered tool call (no validation): ${t.name} with args: ${argsJson}`);
-                send("content_block_start", {
-                  type: "content_block_start",
-                  index: t.blockIndex,
-                  content_block: { type: "tool_use", id: t.id, name: t.name }
-                });
-                send("content_block_delta", {
-                  type: "content_block_delta",
-                  index: t.blockIndex,
-                  delta: { type: "input_json_delta", partial_json: argsJson }
-                });
-                send("content_block_stop", {
-                  type: "content_block_stop",
-                  index: t.blockIndex
-                });
+                t.ref = writer.openTool({ id: t.id, name: t.name, index: t.blockIndex });
+                writer.append(t.ref, argsJson);
+                writer.close(t.ref);
                 t.started = true;
                 t.closed = true;
               }
@@ -21201,28 +21780,41 @@ data: ${JSON.stringify(d)}
           }
           for (const t of Array.from(state.tools.values())) {
             if (t.started && !t.closed) {
-              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+              if (t.ref)
+                writer.close(t.ref);
               t.closed = true;
             }
           }
           if (middlewareManager) {
             await middlewareManager.afterStreamComplete(target, streamMetadata);
           }
-          if (reason === "error") {
-            send("error", { type: "error", error: { type: "api_error", message: err } });
+          if (ending === "failure") {
+            const message = err ?? "Upstream stream ended with no finish_reason while a tool call was in flight. " + "The tool call is incomplete and was not dispatched.";
+            send("error", { type: "error", error: { type: "api_error", message } });
           } else {
             const hasStructuredTools = Array.from(state.tools.values()).some((t) => t.started);
-            const truncated = state.finishReason === "length";
+            const truncated = state.finishReason === "length" || ending === "silent-truncation";
             const refused = state.finishReason === "content_filter";
             const stopReason = refused ? "refusal" : truncated ? "max_tokens" : textToolCalls.length > 0 || hasStructuredTools ? "tool_use" : "end_turn";
             if (truncated || refused) {
               log(`[Streaming] Upstream finish_reason=${state.finishReason} \u2192 stop_reason=${stopReason} (${state.accumulatedText.length} chars produced)`);
             }
+            if (stopReason === "end_turn" && !writer.anyBlockEmitted) {
+              log(`[Streaming] Contentless turn error: end_turn with no content block emitted (finish_reason=${state.finishReason ?? "null"}) \u2014 emitting an empty text block`);
+              writer.close(writer.openText());
+            }
+            const split = splitPromptTokens(state.usage);
+            const fullyCached = split.promptTokens > 0 && split.inputTokens === 0;
+            const wireInput = fullyCached ? split.promptTokens : split.inputTokens;
+            const wireCacheRead = fullyCached ? 0 : split.cacheReadTokens;
+            const wireCacheCreation = fullyCached ? 0 : split.cacheCreationTokens;
             send("message_delta", {
               type: "message_delta",
               delta: { stop_reason: stopReason, stop_sequence: null },
               usage: {
-                ...state.usage?.prompt_tokens ? { input_tokens: state.usage.prompt_tokens } : {},
+                input_tokens: wireInput,
+                cache_read_input_tokens: wireCacheRead,
+                cache_creation_input_tokens: wireCacheCreation,
                 output_tokens: state.usage?.completion_tokens || 0
               }
             });
@@ -21232,7 +21824,11 @@ data: ${JSON.stringify(d)}
           if (onTokenUpdate) {
             if (state.usage) {
               log(`[Streaming] Final usage: prompt=${state.usage.prompt_tokens || 0}, completion=${state.usage.completion_tokens || 0}`);
-              onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
+              const costSplit = splitPromptTokens(state.usage);
+              onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0, {
+                cacheReadTokens: costSplit.cacheReadTokens,
+                cacheCreationTokens: costSplit.cacheCreationTokens
+              });
             } else {
               const estimatedOutputTokens = Math.ceil(state.accumulatedText.length / 4);
               log(`[Streaming] No usage data from provider, estimating: ~${estimatedOutputTokens} output tokens`);
@@ -21287,22 +21883,10 @@ data: ${JSON.stringify(d)}
                 }
                 const reasoningText = delta.reasoning_content || delta.reasoning;
                 if (reasoningText) {
+                  thinkSplitter.disarmOpen();
                   behavior?.onAssistantText?.(reasoningText, "reasoning");
                   state.lastActivity = Date.now();
-                  if (!state.reasoningStarted) {
-                    state.reasoningIdx = state.curIdx++;
-                    send("content_block_start", {
-                      type: "content_block_start",
-                      index: state.reasoningIdx,
-                      content_block: { type: "thinking", thinking: "" }
-                    });
-                    state.reasoningStarted = true;
-                  }
-                  send("content_block_delta", {
-                    type: "content_block_delta",
-                    index: state.reasoningIdx,
-                    delta: { type: "thinking_delta", thinking: reasoningText }
-                  });
+                  writer.append(writer.openThinking(), reasoningText);
                 }
                 const txt = delta.content || "";
                 if (txt)
@@ -21310,42 +21894,13 @@ data: ${JSON.stringify(d)}
                 log(`[Streaming] Text chunk: "${txt.substring(0, 30).replace(/\n/g, "\\n")}" (${txt.length} chars)`);
                 if (txt) {
                   state.lastActivity = Date.now();
-                  if (state.reasoningStarted) {
-                    send("content_block_stop", {
-                      type: "content_block_stop",
-                      index: state.reasoningIdx
-                    });
-                    state.reasoningStarted = false;
-                  }
                   const res = adapter.processTextContent(txt, "");
                   log(`[Streaming] After adapter: "${res.cleanedText.substring(0, 30).replace(/\n/g, "\\n")}" (${res.cleanedText.length} chars, transformed=${res.wasTransformed})`);
                   if (txt.length > 0 && res.cleanedText.length === 0) {
                     log(`[Streaming] Text filtered out by adapter: "${txt.substring(0, 50)}"`);
                   }
                   if (res.cleanedText) {
-                    state.accumulatedText += res.cleanedText;
-                    const hasStructuredToolPattern = hasExtractableFunctionTag(state.accumulatedText) || /\{\s*"(?:name|tool)"\s*:\s*"(?:Task|Read|Write|Edit|Bash|Grep|Glob)"/i.test(state.accumulatedText) || /<tool_call>/.test(state.accumulatedText);
-                    const shouldHoldBack = hasStructuredToolPattern && state.accumulatedText.length < 1000;
-                    if (shouldHoldBack) {
-                      log(`[Streaming] Text held back (structured tool pattern): ${state.accumulatedText.length} chars accumulated`);
-                    }
-                    if (!shouldHoldBack) {
-                      if (!state.textStarted) {
-                        state.textIdx = state.curIdx++;
-                        send("content_block_start", {
-                          type: "content_block_start",
-                          index: state.textIdx,
-                          content_block: { type: "text", text: "" }
-                        });
-                        state.textStarted = true;
-                        log(`[Streaming] Started text block at index ${state.textIdx}`);
-                      }
-                      send("content_block_delta", {
-                        type: "content_block_delta",
-                        index: state.textIdx,
-                        delta: { type: "text_delta", text: res.cleanedText }
-                      });
-                    }
+                    emitSplitContent(thinkSplitter.push(res.cleanedText));
                   }
                 }
                 if (delta.tool_calls) {
@@ -21354,57 +21909,62 @@ data: ${JSON.stringify(d)}
                     const idx = tc.index;
                     let t = state.tools.get(idx);
                     if (tc.function?.name) {
+                      const accumulatedName = (state.pendingToolName.get(idx) ?? "") + tc.function.name;
+                      state.pendingToolName.set(idx, accumulatedName);
+                      const restoredName = toolNameMap?.get(accumulatedName) || accumulatedName;
                       if (!t) {
-                        if (state.reasoningStarted) {
-                          send("content_block_stop", {
-                            type: "content_block_stop",
-                            index: state.reasoningIdx
-                          });
-                          state.reasoningStarted = false;
-                        }
-                        if (state.textStarted) {
-                          send("content_block_stop", {
-                            type: "content_block_stop",
-                            index: state.textIdx
-                          });
-                          state.textStarted = false;
-                        }
-                        const rawName = tc.function.name;
-                        const restoredName = toolNameMap?.get(rawName) || rawName;
                         t = {
                           id: tc.id || `tool_${Date.now()}_${idx}`,
                           name: restoredName,
-                          blockIndex: state.curIdx++,
+                          blockIndex: writer.reserve(),
                           started: false,
                           closed: false,
-                          arguments: "",
+                          arguments: state.pendingToolArgs.get(idx) ?? "",
+                          ref: null,
                           buffered: !!toolSchemas && toolSchemas.length > 0 || behavior?.shouldBufferTool?.(restoredName) === true
                         };
+                        if (t.arguments) {
+                          log(`[Streaming] tool ${t.name} (index ${idx}): seeded ${t.arguments.length} argument chars that arrived before function.name`);
+                        }
+                        state.pendingToolArgs.delete(idx);
                         state.tools.set(idx, t);
                         if (isWebSearchToolCall(restoredName)) {
                           warnWebSearchUnsupported(restoredName, target);
                         }
+                      } else if (t.name !== restoredName) {
+                        if (t.started) {
+                          log(`[Streaming] error: tool block ${t.blockIndex} was started as "${t.name}" but the full name is "${restoredName}" \u2014 the client sees the wrong name`);
+                        } else {
+                          t.name = restoredName;
+                          t.buffered = !!toolSchemas && toolSchemas.length > 0 || behavior?.shouldBufferTool?.(restoredName) === true;
+                          if (isWebSearchToolCall(restoredName)) {
+                            warnWebSearchUnsupported(restoredName, target);
+                          }
+                        }
                       }
                       if (!t.started && !t.buffered) {
-                        send("content_block_start", {
-                          type: "content_block_start",
-                          index: t.blockIndex,
-                          content_block: { type: "tool_use", id: t.id, name: t.name }
+                        t.ref = writer.openTool({
+                          id: t.id,
+                          name: t.name,
+                          index: t.blockIndex
                         });
                         t.started = true;
+                        if (t.arguments)
+                          writer.append(t.ref, t.arguments);
                       }
                     }
+                    if (tc.function?.arguments && !t) {
+                      state.pendingToolArgs.set(idx, (state.pendingToolArgs.get(idx) ?? "") + tc.function.arguments);
+                    }
                     if (tc.function?.arguments && t) {
                       t.arguments += tc.function.arguments;
                       if (!t.buffered) {
-                        send("content_block_delta", {
-                          type: "content_block_delta",
-                          index: t.blockIndex,
-                          delta: {
-                            type: "input_json_delta",
-                            partial_json: tc.function.arguments
-                          }
-                        });
+                        if (!t.ref || !writer.append(t.ref, tc.function.arguments)) {
+                          log(`[Streaming] tool ${t.name} (index ${idx}) lost its open block mid-arguments \u2014 buffering the rest`);
+                          t.buffered = true;
+                          t.started = false;
+                          t.ref = null;
+                        }
                       }
                     }
                   }
@@ -21420,110 +21980,74 @@ data: ${JSON.stringify(d)}
                         const repairedJson = repairArgs(t.name, JSON.stringify(validation.repairedArgs));
                         log(`[Streaming] Sending repaired tool call: ${t.name} with args: ${repairedJson}`);
                         if (t.buffered && !t.started) {
-                          send("content_block_start", {
-                            type: "content_block_start",
-                            index: t.blockIndex,
-                            content_block: { type: "tool_use", id: t.id, name: t.name }
-                          });
-                          send("content_block_delta", {
-                            type: "content_block_delta",
-                            index: t.blockIndex,
-                            delta: { type: "input_json_delta", partial_json: repairedJson }
-                          });
-                          send("content_block_stop", {
-                            type: "content_block_stop",
+                          t.ref = writer.openTool({
+                            id: t.id,
+                            name: t.name,
                             index: t.blockIndex
                           });
+                          writer.append(t.ref, repairedJson);
+                          writer.close(t.ref);
                           t.started = true;
                           t.closed = true;
                           continue;
                         }
                         if (t.started) {
-                          send("content_block_stop", {
-                            type: "content_block_stop",
-                            index: t.blockIndex
-                          });
-                          const repairedIdx = state.curIdx++;
+                          if (t.ref)
+                            writer.close(t.ref);
+                          const repairedIdx = writer.reserve();
                           const repairedId = `tool_repaired_${Date.now()}_${repairedIdx}`;
-                          send("content_block_start", {
-                            type: "content_block_start",
-                            index: repairedIdx,
-                            content_block: { type: "tool_use", id: repairedId, name: t.name }
-                          });
-                          send("content_block_delta", {
-                            type: "content_block_delta",
-                            index: repairedIdx,
-                            delta: { type: "input_json_delta", partial_json: repairedJson }
-                          });
-                          send("content_block_stop", {
-                            type: "content_block_stop",
+                          const repairedRef = writer.openTool({
+                            id: repairedId,
+                            name: t.name,
                             index: repairedIdx
                           });
+                          writer.append(repairedRef, repairedJson);
+                          writer.close(repairedRef);
+                          t.ref = repairedRef;
                           t.closed = true;
                           continue;
                         }
                       }
                       if (!validation.valid) {
                         log(`[Streaming] Tool call ${t.name} validation failed: ${validation.missingParams.join(", ")}`);
-                        const errorIdx = t.buffered ? t.blockIndex : state.curIdx++;
+                        const errorIdx = t.buffered ? t.blockIndex : undefined;
                         const errorMsg = `
 
 \u26A0\uFE0F Tool call "${t.name}" failed: missing required parameters: ${validation.missingParams.join(", ")}. Local models sometimes generate incomplete tool calls. Please try again or use a model with better tool support.`;
-                        send("content_block_start", {
-                          type: "content_block_start",
-                          index: errorIdx,
-                          content_block: { type: "text", text: "" }
-                        });
-                        send("content_block_delta", {
-                          type: "content_block_delta",
-                          index: errorIdx,
-                          delta: { type: "text_delta", text: errorMsg }
-                        });
-                        send("content_block_stop", {
-                          type: "content_block_stop",
-                          index: errorIdx
-                        });
-                        if (t.started && !t.buffered) {
-                          send("content_block_stop", {
-                            type: "content_block_stop",
-                            index: t.blockIndex
-                          });
+                        const errorRef = writer.openText({ index: errorIdx });
+                        writer.append(errorRef, errorMsg);
+                        writer.close(errorRef);
+                        if (t.started && !t.buffered && t.ref) {
+                          writer.close(t.ref);
                         }
                         t.closed = true;
                         continue;
                       }
                       if (t.buffered && !t.started) {
                         const argsJson = repairArgs(t.name, JSON.stringify(validation.parsedArgs));
-                        send("content_block_start", {
-                          type: "content_block_start",
-                          index: t.blockIndex,
-                          content_block: { type: "tool_use", id: t.id, name: t.name }
-                        });
-                        send("content_block_delta", {
-                          type: "content_block_delta",
-                          index: t.blockIndex,
-                          delta: { type: "input_json_delta", partial_json: argsJson }
-                        });
-                        send("content_block_stop", {
-                          type: "content_block_stop",
+                        t.ref = writer.openTool({
+                          id: t.id,
+                          name: t.name,
                           index: t.blockIndex
                         });
+                        writer.append(t.ref, argsJson);
+                        writer.close(t.ref);
                         t.started = true;
                         t.closed = true;
                         continue;
                       }
                     }
                     if (t.started && !t.closed) {
-                      send("content_block_stop", {
-                        type: "content_block_stop",
-                        index: t.blockIndex
-                      });
+                      if (t.ref)
+                        writer.close(t.ref);
                       t.closed = true;
                     }
                   }
                 }
               }
-            } catch (e) {}
+            } catch (e) {
+              log(`[Streaming] Chunk processing error (chunk dropped): ${e} \u2014 payload starts: ${dataStr.slice(0, 120)}`);
+            }
           }
         }
         await finalize("unexpected");
@@ -21549,10 +22073,13 @@ var init_openai_sse = __esm(() => {
   init_logger();
   init_tool_call_recovery();
   init_web_search_detector();
+  init_block_writer();
+  init_think_tag_splitter();
 });
 
 // src/handlers/shared/openai-compat.ts
 var init_openai_compat = __esm(() => {
+  init_openai_messages();
   init_openai_tools();
   init_openai_sse();
 });
@@ -21560,6 +22087,7 @@ var init_openai_compat = __esm(() => {
 // src/adapters/gemini-api-format.ts
 var GeminiAPIFormat;
 var init_gemini_api_format = __esm(() => {
+  init_openai_tools();
   init_gemini_schema();
   init_openai_compat();
   init_logger();
@@ -21704,6 +22232,11 @@ CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
       }
       if (tools && tools.length > 0) {
         payload.tools = tools;
+        const toolConfig = mapToolChoiceToGemini(claudeRequest.tool_choice);
+        if (toolConfig) {
+          payload.toolConfig = toolConfig;
+          log(`[GeminiAPIFormat] toolConfig.mode -> ${toolConfig.functionCallingConfig.mode} for ${this.modelId}`);
+        }
       }
       const effort = this.resolveEffortLevel(claudeRequest);
       if (effort) {
@@ -21825,6 +22358,7 @@ CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
 // src/adapters/litellm-api-format.ts
 var INLINE_IMAGE_MODEL_PATTERNS, LiteLLMAPIFormat;
 var init_litellm_api_format = __esm(() => {
+  init_openai_tools();
   init_logger();
   init_base_api_format();
   INLINE_IMAGE_MODEL_PATTERNS = ["minimax"];
@@ -21900,14 +22434,11 @@ var init_litellm_api_format = __esm(() => {
       if (tools.length > 0) {
         payload.tools = tools;
       }
-      if (claudeRequest.tool_choice) {
-        const { type, name } = claudeRequest.tool_choice;
-        if (type === "tool" && name) {
-          payload.tool_choice = { type: "function", function: { name } };
-        } else if (type === "auto" || type === "none") {
-          payload.tool_choice = type;
-        }
+      const toolChoice = mapToolChoiceToOpenAI(claudeRequest.tool_choice);
+      if (toolChoice !== undefined) {
+        payload.tool_choice = toolChoice;
       }
+      this.applyOpenAISamplingParams(payload, claudeRequest);
       return payload;
     }
     checkVisionSupport() {
@@ -22010,6 +22541,7 @@ var init_ollama_api_format = __esm(() => {
 // src/adapters/openai-api-format.ts
 var OpenAIAPIFormat;
 var init_openai_api_format = __esm(() => {
+  init_openai_tools();
   init_logger();
   init_base_api_format();
   init_model_catalog();
@@ -22027,13 +22559,6 @@ var init_openai_api_format = __esm(() => {
     getMaxToolCount() {
       return 128;
     }
-    prepareRequestCommon(request, _originalRequest) {
-      this.truncateToolNames(request);
-      if (request.messages) {
-        this.truncateToolNamesInMessages(request.messages);
-      }
-      return request;
-    }
     applyNativeReasoning(request, originalRequest) {
       if (this.supportsReasoningEffort() && request.reasoning_effort === undefined) {
         const effort = this.resolveReasoningEffort(originalRequest);
@@ -22187,13 +22712,9 @@ var init_openai_api_format = __esm(() => {
       if (tools.length > 0) {
         payload.tools = tools;
       }
-      if (claudeRequest.tool_choice) {
-        const { type, name } = claudeRequest.tool_choice;
-        if (type === "tool" && name) {
-          payload.tool_choice = { type: "function", function: { name } };
-        } else if (type === "auto" || type === "none") {
-          payload.tool_choice = type;
-        }
+      const toolChoice = mapToolChoiceToOpenAI(claudeRequest.tool_choice);
+      if (toolChoice !== undefined) {
+        payload.tool_choice = toolChoice;
       }
       if (this.supportsReasoningEffort()) {
         const effort = this.resolveReasoningEffort(claudeRequest);
@@ -22202,6 +22723,7 @@ var init_openai_api_format = __esm(() => {
           log(`[OpenAIAPIFormat] reasoning_effort -> ${effort} for ${this.modelId}`);
         }
       }
+      this.applyOpenAISamplingParams(payload, claudeRequest);
       return payload;
     }
   };
@@ -22688,30 +23210,30 @@ var init_grok_model_dialect = __esm(() => {
       return value;
     }
     recoverFromRejection(payload, errorText) {
-      if (!payload || payload.reasoning_effort === undefined)
-        return null;
-      if (isReasoningEffortRejection(errorText)) {
-        rememberReasoningEffortRejected(this.modelId);
-        const next = { ...payload };
-        delete next.reasoning_effort;
-        return { payload: next, note: `dropped reasoning_effort for ${this.modelId}` };
-      }
-      const rejected = rejectedReasoningEffortValue(errorText);
-      if (rejected) {
-        rememberReasoningEffortValueRejected(this.modelId, rejected);
-        const fallback = fallbackReasoningEffortValue(rejected);
-        const next = { ...payload };
-        if (fallback) {
-          next.reasoning_effort = fallback;
-          return {
-            payload: next,
-            note: `reasoning_effort "${rejected}" -> "${fallback}" for ${this.modelId}`
-          };
+      if (payload?.reasoning_effort !== undefined) {
+        if (isReasoningEffortRejection(errorText)) {
+          rememberReasoningEffortRejected(this.modelId);
+          const next = { ...payload };
+          delete next.reasoning_effort;
+          return { payload: next, note: `dropped reasoning_effort for ${this.modelId}` };
+        }
+        const rejected = rejectedReasoningEffortValue(errorText);
+        if (rejected) {
+          rememberReasoningEffortValueRejected(this.modelId, rejected);
+          const fallback = fallbackReasoningEffortValue(rejected);
+          const next = { ...payload };
+          if (fallback) {
+            next.reasoning_effort = fallback;
+            return {
+              payload: next,
+              note: `reasoning_effort "${rejected}" -> "${fallback}" for ${this.modelId}`
+            };
+          }
+          delete next.reasoning_effort;
+          return { payload: next, note: `dropped unsupported reasoning_effort for ${this.modelId}` };
         }
-        delete next.reasoning_effort;
-        return { payload: next, note: `dropped unsupported reasoning_effort for ${this.modelId}` };
       }
-      return null;
+      return super.recoverFromRejection(payload, errorText);
     }
     parseXmlParameters(xmlContent) {
       const params = {};
@@ -22738,6 +23260,7 @@ var init_grok_model_dialect = __esm(() => {
       return lookupModel(this.modelId)?.contextWindow ?? 0;
     }
     reset() {
+      super.reset();
       this.xmlBuffer = "";
     }
   };
@@ -22881,16 +23404,6 @@ var init_xiaomi_model_dialect = __esm(() => {
         wasTransformed: false
       };
     }
-    getToolNameLimit() {
-      return 64;
-    }
-    prepareRequestCommon(request, _originalRequest) {
-      this.truncateToolNames(request);
-      if (request.messages) {
-        this.truncateToolNamesInMessages(request.messages);
-      }
-      return request;
-    }
     applyNativeReasoning(request, originalRequest) {
       if (originalRequest.thinking) {
         log("[XiaomiModelDialect] Stripping thinking object (not supported by Xiaomi API)");
@@ -31672,6 +32185,31 @@ var init_stats = __esm(() => {
   });
 });
 
+// src/handlers/shared/request-shape.ts
+function isRequestShapeError(errorBody) {
+  if (!errorBody)
+    return false;
+  const lower = errorBody.toLowerCase();
+  return lower.includes("unknown_parameter") || lower.includes("unsupported_parameter") || lower.includes("invalid_parameter") || lower.includes("unknown parameter:") || lower.includes("unsupported parameter:") || lower.includes("invalid parameter:");
+}
+function isContextOverflowError(status, errorBody) {
+  if (!errorBody)
+    return false;
+  if (isRequestShapeError(errorBody))
+    return false;
+  const lower = errorBody.toLowerCase();
+  if (lower.includes("context_length_exceeded") || lower.includes("string_above_max_length") || lower.includes("request_too_large") || lower.includes("context_window_exceeded") || lower.includes("prompt_too_long")) {
+    return true;
+  }
+  if (lower.includes("maximum context length is") || lower.includes("reduce the length of the messages") || lower.includes("input is too long") || lower.includes(CONTEXT_OVERFLOW_PHRASE)) {
+    return true;
+  }
+  if (status === 413 && (lower.includes("token") || lower.includes("context")))
+    return true;
+  return false;
+}
+var CONTEXT_OVERFLOW_PHRASE = "prompt is too long";
+
 // src/handlers/shared/anthropic-error.ts
 function statusToErrorType(status) {
   switch (status) {
@@ -31750,6 +32288,8 @@ function isTerminalError(status, bodyText, terminal429) {
     return true;
   if (status === 429 && terminal429)
     return true;
+  if (isContextOverflowError(status, bodyText))
+    return true;
   const lower = (bodyText || "").toLowerCase();
   if (lower.includes("insufficient balance") || lower.includes("insufficient_balance") || lower.includes("insufficient_quota") || lower.includes("insufficient quota") || lower.includes("billing_not_active") || lower.includes("billing not active") || lower.includes("out of credits") || lower.includes("no credits remaining") || lower.includes("exceeded your current quota") || lower.includes("quota_exceeded")) {
     return true;
@@ -31763,11 +32303,13 @@ function isTerminalError(status, bodyText, terminal429) {
   return false;
 }
 function buildSurfacedErrorMessage(opts) {
-  const { providerDisplayName, status, hint, providerMessage } = opts;
+  const { providerDisplayName, status, hint, providerMessage, leadPhrase } = opts;
   const head = `${providerDisplayName} error (HTTP ${status})`;
   const parts = [head];
   if (hint)
     parts[0] = `${head}: ${hint}`;
+  if (leadPhrase && !parts[0].startsWith(leadPhrase))
+    parts[0] = `${leadPhrase} \u2014 ${parts[0]}`;
   const detail = (providerMessage || "").trim();
   if (detail && !parts[0].includes(detail)) {
     const trimmed = detail.length > 600 ? `${detail.slice(0, 600)}\u2026` : detail;
@@ -32177,14 +32719,6 @@ var init_model_unsupported = __esm(() => {
   ];
 });
 
-// src/handlers/shared/request-shape.ts
-function isRequestShapeError(errorBody) {
-  if (!errorBody)
-    return false;
-  const lower = errorBody.toLowerCase();
-  return lower.includes("unknown_parameter") || lower.includes("unsupported_parameter") || lower.includes("invalid_parameter") || lower.includes("unknown parameter:") || lower.includes("unsupported parameter:") || lower.includes("invalid parameter:");
-}
-
 // src/handlers/shared/stream-head-sniffer.ts
 function isRetryableStreamError(code, type, message) {
   if (RETRYABLE_ERROR_CODES.has(code))
@@ -33938,6 +34472,17 @@ function stripProviderPrefix(name) {
   const at = name.indexOf("@");
   return at === -1 ? name : name.slice(at + 1);
 }
+function computeCacheReadDiscount(pricing, billedInputTokens, detail) {
+  const cacheReadTokens = detail?.cacheReadTokens ?? 0;
+  if (cacheReadTokens <= 0 || billedInputTokens <= 0)
+    return 0;
+  const rate = pricing.cacheReadCostPer1M ?? pricing.inputCostPer1M;
+  const perMillionSaved = pricing.inputCostPer1M - rate;
+  if (!(perMillionSaved > 0))
+    return 0;
+  const discountedTokens = Math.min(cacheReadTokens, billedInputTokens);
+  return discountedTokens / 1e6 * perMillionSaved;
+}
 
 class TokenTracker {
   port;
@@ -33952,6 +34497,7 @@ class TokenTracker {
   toolCallsByName = new Map;
   startedAt = Date.now();
   sessionBilledInputTokens = 0;
+  sessionCacheReadTokens = 0;
   constructor(port, config) {
     this.port = port;
     this.config = config;
@@ -33987,27 +34533,32 @@ class TokenTracker {
   rewrite() {
     this.writeFile(this.getLastInputTokens(), this.sessionOutputTokens);
   }
-  update(inputTokens, outputTokens) {
+  update(inputTokens, outputTokens, detail) {
     this.sessionInputTokens = inputTokens;
     this.lastInputTokens = inputTokens;
     this.sessionOutputTokens += outputTokens;
     this.sessionBilledInputTokens += inputTokens;
+    this.sessionCacheReadTokens += detail?.cacheReadTokens ?? 0;
     const pricing = this.getPricing();
-    const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
+    const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M - this.cacheReadDiscount(pricing, inputTokens, detail);
     this.sessionTotalCost += cost;
     this.writeFile(inputTokens, this.sessionOutputTokens, pricing.isEstimate);
   }
-  accumulateBoth(inputTokens, outputTokens) {
+  accumulateBoth(inputTokens, outputTokens, detail) {
     this.sessionInputTokens += inputTokens;
     this.lastInputTokens = this.sessionInputTokens;
     this.sessionOutputTokens += outputTokens;
+    this.sessionCacheReadTokens += detail?.cacheReadTokens ?? 0;
     const pricing = this.getPricing();
-    const cost = this.sessionInputTokens / 1e6 * pricing.inputCostPer1M + this.sessionOutputTokens / 1e6 * pricing.outputCostPer1M;
+    const cost = this.sessionInputTokens / 1e6 * pricing.inputCostPer1M + this.sessionOutputTokens / 1e6 * pricing.outputCostPer1M - this.cacheReadDiscount(pricing, this.sessionInputTokens, {
+      cacheReadTokens: this.sessionCacheReadTokens,
+      cacheCreationTokens: 0
+    });
     this.sessionTotalCost = cost;
     this.sessionBilledInputTokens = this.sessionInputTokens;
     this.writeFile(this.sessionInputTokens, this.sessionOutputTokens, pricing.isEstimate);
   }
-  updateWithDelta(inputTokens, outputTokens) {
+  updateWithDelta(inputTokens, outputTokens, detail) {
     let incrementalInputTokens;
     this.lastInputTokens = inputTokens;
     if (inputTokens >= this.sessionInputTokens) {
@@ -34022,17 +34573,19 @@ class TokenTracker {
       log(`[TokenTracker] Ambiguous token decrease (${inputTokens} vs ${this.sessionInputTokens}), charging full input`);
     }
     this.sessionOutputTokens += outputTokens;
+    this.sessionCacheReadTokens += detail?.cacheReadTokens ?? 0;
     const pricing = this.getPricing();
     this.sessionBilledInputTokens += incrementalInputTokens;
-    const cost = incrementalInputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
+    const cost = incrementalInputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M - this.cacheReadDiscount(pricing, incrementalInputTokens, detail);
     this.sessionTotalCost += cost;
     this.writeFile(inputTokens, this.sessionOutputTokens, pricing.isEstimate);
   }
-  updateWithActualCost(inputTokens, outputTokens, actualCost) {
+  updateWithActualCost(inputTokens, outputTokens, actualCost, detail) {
     this.sessionInputTokens = inputTokens;
     this.lastInputTokens = inputTokens;
     this.sessionOutputTokens += outputTokens;
     this.sessionBilledInputTokens += inputTokens;
+    this.sessionCacheReadTokens += detail?.cacheReadTokens ?? 0;
     if (typeof actualCost === "number" && actualCost > 0) {
       this.sessionTotalCost += actualCost;
       log(`[TokenTracker] Actual cost from API: $${actualCost.toFixed(6)}`);
@@ -34040,11 +34593,11 @@ class TokenTracker {
       const pricing = this.getPricing();
       const inputCost = inputTokens / 1e6 * pricing.inputCostPer1M;
       const outputCost = outputTokens / 1e6 * pricing.outputCostPer1M;
-      this.sessionTotalCost += inputCost + outputCost;
+      this.sessionTotalCost += inputCost + outputCost - this.cacheReadDiscount(pricing, inputTokens, detail);
     }
     this.writeFile(inputTokens, this.sessionOutputTokens);
   }
-  updateLocal(inputTokens, outputTokens) {
+  updateLocal(inputTokens, outputTokens, _detail) {
     if (inputTokens > 0) {
       this.sessionInputTokens = inputTokens;
       this.lastInputTokens = inputTokens;
@@ -34074,6 +34627,9 @@ class TokenTracker {
   getPricing() {
     return getModelPricing(this.config.providerName, this.config.modelName);
   }
+  cacheReadDiscount(pricing, billedInputTokens, detail) {
+    return computeCacheReadDiscount(pricing, billedInputTokens, detail);
+  }
   getDisplayName() {
     if (this.config.providerDisplayName)
       return this.config.providerDisplayName;
@@ -34242,6 +34798,9 @@ class ComposedHandler {
     if (resolvedModelAdapter.getName() !== "DefaultAPIFormat") {
       this.modelAdapter = resolvedModelAdapter;
     }
+    const responseWire = this.resolveStreamFormat();
+    this.resolvedDialect.setResponseWireFormat(responseWire);
+    this.explicitAdapter?.setResponseWireFormat(responseWire);
     this.middlewareManager = new MiddlewareManager;
     if (this.bareModelName.includes("gemini") || this.bareModelName.includes("google/")) {
       this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
@@ -34508,9 +35067,15 @@ class ComposedHandler {
     log(`[${this.provider.displayName}] Response status: ${response.status}`);
     this.capturePlanUsage(response);
     if (!response.ok) {
-      if (response.status >= 400 && response.status < 500 && this.modelAdapter?.recoverFromRejection) {
-        const errorText = await response.clone().text();
-        const recovery = this.modelAdapter.recoverFromRejection(requestPayload, errorText);
+      if (response.status >= 400 && response.status < 500) {
+        const candidates = [this.modelAdapter, this.getAdapter()].filter((a, i, all) => !!a?.recoverFromRejection && all.indexOf(a) === i);
+        const errorText = candidates.length > 0 ? await response.clone().text() : "";
+        let recovery = null;
+        for (const candidate of candidates) {
+          recovery = candidate.recoverFromRejection(requestPayload, errorText);
+          if (recovery)
+            break;
+        }
         if (recovery) {
           log(`[${this.provider.displayName}] Parameter rejected \u2014 retrying: ${recovery.note}`);
           requestPayload = recovery.payload;
@@ -34690,7 +35255,8 @@ class ComposedHandler {
             providerDisplayName: this.provider.displayName,
             status: response.status,
             hint,
-            providerMessage: providerMsg
+            providerMessage: providerMsg,
+            leadPhrase: isContextOverflowError(response.status, errorText) ? CONTEXT_OVERFLOW_PHRASE : undefined
           });
           return c.json(wrapAnthropicError(400, surfaced, "invalid_request_error", response.status), 400);
         }
@@ -34913,20 +35479,20 @@ class ComposedHandler {
   }
   handleStream(c, response, adapter, claudeRequest, toolNameMap, onComplete, onApiError, behaviorSession) {
     let pendingOnComplete = onComplete;
-    const onTokenUpdate = (input, output) => {
+    const onTokenUpdate = (input, output, detail) => {
       const strategy = this.options.tokenStrategy || "standard";
       switch (strategy) {
         case "accumulate-both":
-          this.tokenTracker.accumulateBoth(input, output);
+          this.tokenTracker.accumulateBoth(input, output, detail);
           break;
         case "delta-aware":
-          this.tokenTracker.updateWithDelta(input, output);
+          this.tokenTracker.updateWithDelta(input, output, detail);
           break;
         case "local":
-          this.tokenTracker.updateLocal(input, output);
+          this.tokenTracker.updateLocal(input, output, detail);
           break;
         default:
-          this.tokenTracker.update(input, output);
+          this.tokenTracker.update(input, output, detail);
           break;
       }
       if (pendingOnComplete) {
@@ -34955,7 +35521,7 @@ class ComposedHandler {
         return createResponsesStreamHandler(c, response, {
           modelName: this.bareModelName,
           onTokenUpdate,
-          toolNameMap: adapter.getToolNameMap(),
+          toolNameMap,
           contextWindow: lookupModelForProvider(this.bareModelName, this.provider.name),
           onApiError,
           priorInputTokens,
@@ -35111,6 +35677,9 @@ function getRecoveryHint(status, errorText, providerName, transportTerminal429)
     }
     return "Request format may be incompatible with provider.";
   }
+  if (isContextOverflowError(status, errorText)) {
+    return "Input too large. Reduce message history or use a larger-context model.";
+  }
   if (status >= 500) {
     return "Server error \u2014 retry after a brief wait.";
   }
@@ -42866,8 +43435,10 @@ function accountStreamEvent(rawEvent) {
   if (typeof text === "string" && text.length > 0) {
     contentDelta = true;
     textChars = text.length;
-  } else if (parsed?.type === "content_block_delta" || parsed?.type === "content_block_start") {
+  } else if (parsed?.type === "content_block_delta") {
     contentDelta = true;
+  } else if (parsed?.type === "content_block_start") {
+    contentDelta = parsed.content_block?.type === "tool_use";
   }
   const outputTokens = parsed?.usage?.output_tokens ?? parsed?.message?.usage?.output_tokens ?? parsed?.usage?.completion_tokens;
   const stopReason = parsed?.delta?.stop_reason ?? (Array.isArray(parsed?.choices) ? parsed.choices[0]?.finish_reason : undefined);
@@ -44591,6 +45162,7 @@ var init_cors = () => {};
 // src/adapters/local-adapter.ts
 var LocalModelAdapter;
 var init_local_adapter = __esm(() => {
+  init_openai_tools();
   init_logger();
   init_base_api_format();
   init_dialect_manager();
@@ -44657,26 +45229,26 @@ ${messages[0].content}`;
         tools: tools.length > 0 ? tools : undefined,
         stream_options: { include_usage: true }
       };
-      if (claudeRequest.tool_choice && tools.length > 0) {
-        const { type, name } = claudeRequest.tool_choice;
-        if (type === "tool" && name) {
-          payload.tool_choice = { type: "function", function: { name } };
-        } else if (type === "auto" || type === "none") {
-          payload.tool_choice = type;
+      if (tools.length > 0) {
+        const toolChoice = mapToolChoiceToOpenAI(claudeRequest.tool_choice);
+        if (toolChoice !== undefined) {
+          payload.tool_choice = toolChoice;
         }
       }
+      this.applyOpenAISamplingParams(payload, claudeRequest);
       return payload;
     }
     prepareRequestCommon(request, originalRequest) {
       this.innerAdapter.prepareRequest(request, originalRequest);
-      for (const [k, v] of this.innerAdapter.getToolNameMap()) {
-        this.toolNameMap.set(k, v);
-      }
       delete request.enable_thinking;
       delete request.thinking_budget;
       delete request.thinking;
       return request;
     }
+    setResponseWireFormat(format) {
+      super.setResponseWireFormat(format);
+      this.innerAdapter.setResponseWireFormat(format);
+    }
     getToolNameMap() {
       const map = new Map(super.getToolNameMap());
       for (const [k, v] of this.innerAdapter.getToolNameMap()) {
@@ -44835,19 +45407,20 @@ ${text}`;
       if (claudeRequest.thinking) {
         payload.thinking = claudeRequest.thinking;
       }
-      if (claudeRequest.tool_choice) {
-        const { type, name } = claudeRequest.tool_choice;
-        if (type === "tool" && name) {
-          payload.tool_choice = { type: "function", function: { name } };
-        } else if (type === "auto" || type === "none") {
-          payload.tool_choice = type;
-        }
+      const toolChoice = mapToolChoiceToOpenAI(claudeRequest.tool_choice);
+      if (toolChoice !== undefined) {
+        payload.tool_choice = toolChoice;
       }
+      this.applyOpenAISamplingParams(payload, claudeRequest);
       return payload;
     }
     prepareRequestCommon(request, originalRequest) {
       return this.innerAdapter.prepareRequest(request, originalRequest);
     }
+    setResponseWireFormat(format) {
+      super.setResponseWireFormat(format);
+      this.innerAdapter.setResponseWireFormat(format);
+    }
     getToolNameMap() {
       const map = new Map(super.getToolNameMap());
       for (const [k, v] of this.innerAdapter.getToolNameMap()) {