extrait 0.7.3 → 0.7.4

package/dist/generate-output.d.ts

@@ -7,4 +7,15 @@ export declare function aggregateUsage<T extends {
     usage?: LLMUsage;
 }>(attempts: T[]): LLMUsage | undefined;
 export declare function mergeUsage(base: LLMUsage | undefined, next: LLMUsage | undefined): LLMUsage | undefined;
+/**
+ * Drops a trailing run of `value` that could be the start of a `<think>` /
+ * `</think>` tag whose remaining characters have not streamed in yet (e.g. a
+ * chunk ending in `<th`). Streaming consumers diff successive snapshots to emit
+ * deltas; without this, a partial tag is emitted as a delta and then can never
+ * be retracted once it resolves into a real tag that sanitization removes.
+ *
+ * Only safe for incremental streaming snapshots — never apply it to a final
+ * result, where a legitimate trailing `<` must survive.
+ */
+export declare function withoutTrailingThinkTagPrefix(value: string): string;
 export declare function toStreamDataFingerprint(value: unknown): string;

package/dist/index.cjs

@@ -40,6 +40,7 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   wrapMCPClient: () => wrapMCPClient,
+  withoutTrailingThinkTagPrefix: () => withoutTrailingThinkTagPrefix,
   withFormat: () => withFormat,
   structured: () => structured,
   sanitizeThink: () => sanitizeThink,
@@ -49,6 +50,7 @@ __export(exports_src, {
   registerBuiltinProviders: () => registerBuiltinProviders,
   prompt: () => prompt,
   parseLLMOutput: () => parseLLMOutput,
+  normalizeModelOutput: () => normalizeModelOutput,
   inspectSchemaMetadata: () => inspectSchemaMetadata,
   inferSchemaExample: () => inferSchemaExample,
   images: () => images,
@@ -1168,6 +1170,110 @@ function countHiddenChars(value) {
 function maskKeepingLineBreaks(value) {
   return value.replace(RE_NON_LINE_BREAK, " ");
 }
+// src/generate-output.ts
+var RE_THINK_TAGS = /<\/?think\s*>/gi;
+function normalizeModelOutput(text, dedicatedReasoning, reasoningBlocks) {
+  const sanitized = sanitizeThink(text);
+  const visibleText = stripThinkBlocks(text, sanitized.thinkBlocks);
+  const reasoning = joinReasoningSegments([
+    sanitizeReasoningText(dedicatedReasoning),
+    ...sanitized.thinkBlocks.map((block) => block.content)
+  ]);
+  return {
+    text: visibleText,
+    reasoning,
+    reasoningBlocks: normalizeReasoningBlocks(reasoningBlocks),
+    thinkBlocks: sanitized.thinkBlocks,
+    parseSource: composeParseSource(visibleText, reasoning)
+  };
+}
+function normalizeReasoningBlocks(blocks) {
+  if (!Array.isArray(blocks)) {
+    return;
+  }
+  const normalized = blocks.map((block) => ({
+    turnIndex: block.turnIndex,
+    text: block.text.replace(RE_THINK_TAGS, "").trim()
+  })).filter((block) => Number.isFinite(block.turnIndex) && block.text.length > 0);
+  return normalized.length > 0 ? normalized : undefined;
+}
+function appendReasoningBlock(blocks, transition) {
+  const text = transition.reasoningText?.replace(RE_THINK_TAGS, "").trim();
+  if (!text) {
+    return blocks;
+  }
+  const next = [...blocks ?? [], { turnIndex: transition.turnIndex, text }];
+  return normalizeReasoningBlocks(next);
+}
+function composeParseSource(text, reasoning) {
+  if (typeof reasoning !== "string" || reasoning.length === 0) {
+    return text;
+  }
+  const sanitized = reasoning.replace(RE_THINK_TAGS, "");
+  if (sanitized.length === 0) {
+    return text;
+  }
+  return `<think>${sanitized}</think>${text}`;
+}
+function aggregateUsage(attempts) {
+  let usage;
+  for (const attempt of attempts) {
+    usage = mergeUsage(usage, attempt.usage);
+  }
+  return usage;
+}
+function mergeUsage(base, next) {
+  if (!base && !next) {
+    return;
+  }
+  return {
+    inputTokens: (base?.inputTokens ?? 0) + (next?.inputTokens ?? 0),
+    outputTokens: (base?.outputTokens ?? 0) + (next?.outputTokens ?? 0),
+    totalTokens: (base?.totalTokens ?? 0) + (next?.totalTokens ?? 0),
+    cost: (base?.cost ?? 0) + (next?.cost ?? 0)
+  };
+}
+function joinReasoningSegments(parts) {
+  return parts.map((value) => value?.trim()).filter((value) => Boolean(value)).join(`
+
+`);
+}
+function sanitizeReasoningText(value) {
+  const sanitized = value?.replace(RE_THINK_TAGS, "").trim();
+  return sanitized ? sanitized : undefined;
+}
+var THINK_TAG_VARIANTS = ["<think>", "</think>"];
+var MAX_THINK_TAG_PREFIX = Math.max(...THINK_TAG_VARIANTS.map((tag) => tag.length)) - 1;
+function withoutTrailingThinkTagPrefix(value) {
+  const max = Math.min(value.length, MAX_THINK_TAG_PREFIX);
+  for (let length = max;length > 0; length -= 1) {
+    const suffix = value.slice(value.length - length);
+    if (THINK_TAG_VARIANTS.some((tag) => tag.length > suffix.length && tag.startsWith(suffix))) {
+      return value.slice(0, value.length - length);
+    }
+  }
+  return value;
+}
+function stripThinkBlocks(text, thinkBlocks) {
+  if (thinkBlocks.length === 0) {
+    return text;
+  }
+  let output = "";
+  let cursor = 0;
+  for (const block of thinkBlocks) {
+    output += text.slice(cursor, block.start);
+    cursor = block.end;
+  }
+  output += text.slice(cursor);
+  return output;
+}
+function toStreamDataFingerprint(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "__unserializable__";
+  }
+}
 // src/providers/stream-utils.ts
 var RE_LINE_ENDING = /\r?\n/;
 async function consumeSSE(response, onEvent) {
@@ -1597,7 +1703,7 @@ function pickString(value) {
 function toFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function mergeUsage(base, next) {
+function mergeUsage2(base, next) {
   if (!base && !next) {
     return;
   }
@@ -1722,6 +1828,8 @@ async function streamWithChatCompletionsPassThrough(options, fetcher, path, requ
   let reasoning = "";
   let usage;
   let finishReason;
+  const streamedToolCalls = new Map;
+  const nativeToolCalls = new NativeToolCallStreamState(requestDeclaresTools(options, request));
   await consumeSSE(response, (data) => {
     if (data === "[DONE]") {
       return;
@@ -1730,10 +1838,14 @@ async function streamWithChatCompletionsPassThrough(options, fetcher, path, requ
     if (!isRecord2(json)) {
       return;
     }
-    const delta = pickAssistantDelta(json);
+    const rawDelta = pickAssistantDelta(json);
     const reasoningDelta = pickAssistantReasoningDelta(json);
     const chunkUsage = pickUsage(json);
     const chunkFinishReason = pickFinishReason(json);
+    collectOpenAIStreamToolCalls(json, streamedToolCalls);
+    const nativeDelta = nativeToolCalls.push(rawDelta);
+    const delta = nativeDelta.textDelta;
+    const chunkToolCalls = mergeToolCalls(buildOpenAIStreamToolCalls(streamedToolCalls), nativeDelta.toolCalls);
     usage = preferLatestUsage(usage, chunkUsage);
     if (chunkFinishReason) {
       finishReason = chunkFinishReason;
@@ -1745,13 +1857,21 @@ async function streamWithChatCompletionsPassThrough(options, fetcher, path, requ
     if (reasoningDelta) {
       reasoning += reasoningDelta;
     }
-    emitOpenAIStreamChunk(callbacks, undefined, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
+    emitOpenAIStreamChunk(callbacks, undefined, json, delta, reasoningDelta, chunkUsage, chunkFinishReason, chunkToolCalls.length > 0 ? chunkToolCalls : undefined);
   });
+  const tail = nativeToolCalls.flush();
+  if (tail.textDelta) {
+    text += tail.textDelta;
+    callbacks.onToken?.(tail.textDelta);
+    emitOpenAIStreamChunk(callbacks, undefined, {}, tail.textDelta, "", undefined, undefined);
+  }
+  const toolCalls = mergeToolCalls(buildOpenAIStreamToolCalls(streamedToolCalls), nativeToolCalls.calls);
   const out = {
     text,
     reasoning: reasoning.length > 0 ? reasoning : undefined,
     usage,
-    finishReason
+    finishReason: finishReason ?? (toolCalls.length > 0 ? "tool_calls" : undefined),
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined
   };
   callbacks.onComplete?.(out);
   return out;
@@ -1861,15 +1981,16 @@ function buildResponsesMCPResult(state, text, raw) {
     toolExecutions: state.toolExecutions.length > 0 ? state.toolExecutions : undefined
   };
 }
-function emitOpenAIStreamChunk(callbacks, round, raw, delta, reasoningDelta, usage, finishReason) {
-  if (delta || reasoningDelta || usage || finishReason) {
+function emitOpenAIStreamChunk(callbacks, round, raw, delta, reasoningDelta, usage, finishReason, toolCalls) {
+  if (delta || reasoningDelta || usage || finishReason || toolCalls) {
     callbacks.onChunk?.({
       textDelta: delta,
       reasoningDelta: reasoningDelta || undefined,
       ...round !== undefined ? { turnIndex: round } : {},
       raw,
       usage,
-      finishReason
+      finishReason,
+      toolCalls
     });
   }
 }
@@ -1936,7 +2057,7 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
       parallel_tool_calls: request.parallelToolCalls
     }));
     lastPayload = payload;
-    aggregatedUsage = mergeUsage(aggregatedUsage, pickUsage(payload));
+    aggregatedUsage = mergeUsage2(aggregatedUsage, pickUsage(payload));
     finishReason = pickFinishReason(payload);
     const assistantMessage = pickAssistantMessage(payload);
     const calledTools = pickChatToolCalls(payload);
@@ -2016,7 +2137,7 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
       parallel_tool_calls: request.parallelToolCalls
     }));
     state.lastPayload = payload;
-    state.aggregatedUsage = mergeUsage(state.aggregatedUsage, pickUsage(payload));
+    state.aggregatedUsage = mergeUsage2(state.aggregatedUsage, pickUsage(payload));
     state.finishReason = pickResponsesFinishReason(payload) ?? state.finishReason;
     pushReasoningBlock(state.reasoningBlocks, round, pickResponsesReasoning(payload));
     const providerToolCalls = pickResponsesToolCalls(payload);
@@ -2076,6 +2197,7 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
     let roundUsage;
     let roundFinishReason;
     const streamedToolCalls = new Map;
+    const nativeToolCalls = new NativeToolCallStreamState;
     let reasoningFieldName;
     await consumeSSE(response, (data) => {
       if (data === "[DONE]") {
@@ -2086,10 +2208,12 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         return;
       }
       lastPayload = json;
-      const delta = pickAssistantDelta(json);
+      const rawDelta = pickAssistantDelta(json);
       const reasoningDelta = pickAssistantReasoningDelta(json);
       const chunkUsage = pickUsage(json);
       const chunkFinishReason = pickFinishReason(json);
+      const nativeDelta = nativeToolCalls.push(rawDelta);
+      const delta = nativeDelta.textDelta;
       collectOpenAIStreamToolCalls(json, streamedToolCalls);
       roundUsage = preferLatestUsage(roundUsage, chunkUsage);
       if (chunkFinishReason) {
@@ -2103,13 +2227,20 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         roundReasoning += reasoningDelta;
         reasoningFieldName ??= pickAssistantReasoningDeltaFieldName(json);
       }
-      emitOpenAIStreamChunk(callbacks, round, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
+      const chunkToolCalls = nativeDelta.toolCalls.length > 0 ? mergeToolCalls(buildOpenAIStreamToolCalls(streamedToolCalls), nativeDelta.toolCalls) : undefined;
+      emitOpenAIStreamChunk(callbacks, round, json, delta, reasoningDelta, chunkUsage, chunkFinishReason, chunkToolCalls);
     });
-    aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
+    const tail = nativeToolCalls.flush();
+    if (tail.textDelta) {
+      roundText += tail.textDelta;
+      callbacks.onToken?.(tail.textDelta);
+      emitOpenAIStreamChunk(callbacks, round, {}, tail.textDelta, "", undefined, undefined);
+    }
+    aggregatedUsage = mergeUsage2(aggregatedUsage, roundUsage);
     if (roundFinishReason) {
       finishReason = roundFinishReason;
     }
-    const calledTools = buildOpenAIStreamToolCalls(streamedToolCalls);
+    const calledTools = mergeToolCalls(buildOpenAIStreamToolCalls(streamedToolCalls), nativeToolCalls.calls);
     pushReasoningBlock(reasoningBlocks, round, roundReasoning);
     request.onTurnTransition?.({
       turnIndex: round,
@@ -2196,6 +2327,7 @@ async function streamWithResponsesAPIPassThrough(options, fetcher, path, request
   let usage;
   let finishReason;
   let lastPayload;
+  const streamedToolCalls = new Map;
   await consumeSSE(response, (data) => {
     if (data === "[DONE]") {
       return;
@@ -2211,6 +2343,8 @@ async function streamWithResponsesAPIPassThrough(options, fetcher, path, request
     const delta = pickResponsesStreamTextDelta(json);
     const chunkUsage = pickResponsesStreamUsage(json);
     const chunkFinishReason = pickResponsesStreamFinishReason(json);
+    collectResponsesStreamToolCalls(json, streamedToolCalls);
+    const chunkToolCalls = buildResponsesStreamToolCalls(streamedToolCalls);
     usage = preferLatestUsage(usage, chunkUsage);
     if (chunkFinishReason) {
       finishReason = chunkFinishReason;
@@ -2219,14 +2353,16 @@ async function streamWithResponsesAPIPassThrough(options, fetcher, path, request
       text += delta;
       callbacks.onToken?.(delta);
     }
-    emitOpenAIStreamChunk(callbacks, undefined, json, delta, "", chunkUsage, chunkFinishReason);
+    emitOpenAIStreamChunk(callbacks, undefined, json, delta, "", chunkUsage, chunkFinishReason, chunkToolCalls.length > 0 ? chunkToolCalls : undefined);
   });
   const finalPayload = lastPayload ?? {};
+  const toolCalls = buildResponsesStreamToolCalls(streamedToolCalls);
   const out = {
     text: text.length > 0 ? text : pickResponsesText(finalPayload) || pickAssistantText(finalPayload),
     raw: finalPayload,
     usage: preferLatestUsage(usage, pickUsage(finalPayload)),
-    finishReason: finishReason ?? pickResponsesFinishReason(finalPayload) ?? pickFinishReason(finalPayload)
+    finishReason: finishReason ?? pickResponsesFinishReason(finalPayload) ?? pickFinishReason(finalPayload),
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined
   };
   callbacks.onComplete?.(out);
   return out;
@@ -2288,7 +2424,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
       emitOpenAIStreamChunk(callbacks, round, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
     });
     const resolvedRoundUsage = preferLatestUsage(roundUsage, roundPayload ? pickUsage(roundPayload) : undefined);
-    state.aggregatedUsage = mergeUsage(state.aggregatedUsage, resolvedRoundUsage);
+    state.aggregatedUsage = mergeUsage2(state.aggregatedUsage, resolvedRoundUsage);
     if (roundFinishReason) {
       state.finishReason = roundFinishReason;
     } else if (roundPayload) {
@@ -2542,43 +2678,204 @@ function pickAssistantReasoningDeltaFieldName(payload) {
   }
   return;
 }
-function collectOpenAIStreamToolCalls(payload, state) {
-  const choices = payload.choices;
-  if (!Array.isArray(choices) || choices.length === 0 || !isRecord2(choices[0])) {
+var NATIVE_TOOL_CALL_OPEN = "<tool_call";
+var NATIVE_TOOL_CALL_CLOSE = "</tool_call>";
+
+class NativeToolCallStreamState {
+  enabled;
+  calls = [];
+  pending = "";
+  constructor(enabled = true) {
+    this.enabled = enabled;
+  }
+  push(delta) {
+    if (!delta || !this.enabled) {
+      return { textDelta: delta, toolCalls: [] };
+    }
+    this.pending += delta;
+    return this.drain(false);
+  }
+  flush() {
+    return this.enabled ? this.drain(true) : { textDelta: "", toolCalls: [] };
+  }
+  drain(flush) {
+    let textDelta = "";
+    const toolCalls = [];
+    while (this.pending.length > 0) {
+      const openIndex = this.pending.indexOf(NATIVE_TOOL_CALL_OPEN);
+      if (openIndex < 0) {
+        const keep = flush ? 0 : nativeToolCallPrefixSuffixLength(this.pending);
+        const emitLength = this.pending.length - keep;
+        if (emitLength > 0) {
+          textDelta += this.pending.slice(0, emitLength);
+          this.pending = this.pending.slice(emitLength);
+        }
+        break;
+      }
+      if (openIndex > 0) {
+        textDelta += this.pending.slice(0, openIndex);
+        this.pending = this.pending.slice(openIndex);
+        continue;
+      }
+      const closeIndex = this.pending.indexOf(NATIVE_TOOL_CALL_CLOSE);
+      if (closeIndex < 0) {
+        if (flush) {
+          this.pending = "";
+        }
+        break;
+      }
+      const blockEnd = closeIndex + NATIVE_TOOL_CALL_CLOSE.length;
+      const call = parseNativeToolCallBlock(this.pending.slice(0, blockEnd), this.calls.length);
+      if (call) {
+        this.calls.push(call);
+        toolCalls.push(call);
+      }
+      this.pending = this.pending.slice(blockEnd);
+    }
+    return { textDelta, toolCalls };
+  }
+}
+function requestDeclaresTools(options, request) {
+  const hasTools = (body) => Array.isArray(body?.tools) && body.tools.length > 0;
+  return hasTools(request.body) || hasTools(options.defaultBody);
+}
+var NATIVE_FUNCTION_PATTERN = /<function=([^>\s]+)\s*>([\s\S]*?)<\/function>/;
+var NATIVE_PARAMETER_PATTERN = /<parameter=([^>\s]+)\s*>([\s\S]*?)<\/parameter>/g;
+function parseNativeToolCallBlock(block, index) {
+  const inner = extractNativeToolCallInner(block);
+  if (inner === undefined) {
     return;
   }
-  const delta = choices[0].delta;
-  if (!isRecord2(delta) || !Array.isArray(delta.tool_calls)) {
+  return parseNativeJsonToolCall(inner, index) ?? parseNativeXmlToolCall(inner, index);
+}
+function extractNativeToolCallInner(block) {
+  const openEnd = block.indexOf(">");
+  const closeStart = block.lastIndexOf(NATIVE_TOOL_CALL_CLOSE);
+  if (openEnd < 0 || closeStart < 0 || closeStart <= openEnd) {
     return;
   }
-  for (const rawToolCall of delta.tool_calls) {
-    if (!isRecord2(rawToolCall)) {
-      continue;
+  return block.slice(openEnd + 1, closeStart).trim();
+}
+function parseNativeXmlToolCall(inner, index) {
+  const functionMatch = NATIVE_FUNCTION_PATTERN.exec(inner);
+  const functionName = functionMatch?.[1];
+  const functionBody = functionMatch?.[2];
+  if (!functionName || functionBody === undefined) {
+    return;
+  }
+  const args = {};
+  for (const [, key, rawValue] of functionBody.matchAll(NATIVE_PARAMETER_PATTERN)) {
+    if (key && rawValue !== undefined) {
+      args[key] = coerceNativeParameterValue(rawValue.trim());
     }
-    const index = toFiniteNumber(rawToolCall.index);
-    const toolIndex = index !== undefined ? Math.floor(index) : 0;
-    const existing = state.get(toolIndex) ?? {
-      index: toolIndex,
-      argumentsText: ""
-    };
-    const id = pickString(rawToolCall.id);
-    if (id) {
-      existing.id = id;
+  }
+  return {
+    id: `call_native_${index}`,
+    type: "function",
+    name: functionName,
+    arguments: JSON.stringify(args)
+  };
+}
+function coerceNativeParameterValue(value) {
+  if (value.length === 0) {
+    return "";
+  }
+  const parsed = safeJSONParse(value);
+  if (parsed === null) {
+    return value === "null" ? null : value;
+  }
+  return parsed;
+}
+function nativeToolCallPrefixSuffixLength(value) {
+  const max = Math.min(value.length, NATIVE_TOOL_CALL_OPEN.length - 1);
+  for (let length = max;length > 0; length -= 1) {
+    if (NATIVE_TOOL_CALL_OPEN.startsWith(value.slice(-length))) {
+      return length;
+    }
+  }
+  return 0;
+}
+function parseNativeJsonToolCall(inner, index) {
+  const parsed = safeJSONParse(inner);
+  if (!isRecord2(parsed)) {
+    return;
+  }
+  const name = pickString(parsed.name) ?? pickString(parsed.function);
+  if (!name) {
+    return;
+  }
+  const rawArguments = parsed.arguments ?? parsed.parameters ?? {};
+  const args = typeof rawArguments === "string" ? rawArguments : JSON.stringify(rawArguments);
+  return {
+    id: pickString(parsed.id) ?? `call_native_${index}`,
+    type: "function",
+    name,
+    arguments: args
+  };
+}
+function mergeToolCalls(...groups) {
+  const merged = [];
+  const seen = new Set;
+  for (const group of groups) {
+    for (const call of group) {
+      const key = call.id || `${call.name ?? ""}:${String(call.arguments ?? "")}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      merged.push(call);
     }
-    const type = pickString(rawToolCall.type);
-    if (type) {
-      existing.type = type;
+  }
+  return merged;
+}
+function collectOpenAIStreamToolCalls(payload, state) {
+  const choices = payload.choices;
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return;
+  }
+  for (const choice of choices) {
+    if (!isRecord2(choice)) {
+      continue;
     }
-    const functionCall = isRecord2(rawToolCall.function) ? rawToolCall.function : undefined;
-    const name = pickString(functionCall?.name);
-    if (name) {
-      existing.name = `${existing.name ?? ""}${name}`;
+    const delta = isRecord2(choice.delta) ? choice.delta : undefined;
+    const message = isRecord2(choice.message) ? choice.message : undefined;
+    const toolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : Array.isArray(message?.tool_calls) ? message.tool_calls : Array.isArray(choice.tool_calls) ? choice.tool_calls : undefined;
+    if (!toolCalls) {
+      continue;
     }
-    const argumentsDelta = pickString(functionCall?.arguments);
-    if (argumentsDelta) {
-      existing.argumentsText += argumentsDelta;
+    for (const rawToolCall of toolCalls) {
+      if (!isRecord2(rawToolCall)) {
+        continue;
+      }
+      const index = toFiniteNumber(rawToolCall.index);
+      const toolIndex = index !== undefined ? Math.floor(index) : state.size;
+      const existing = state.get(toolIndex) ?? {
+        index: toolIndex,
+        argumentsText: ""
+      };
+      const id = pickString(rawToolCall.id);
+      if (id) {
+        existing.id = id;
+      }
+      const type = pickString(rawToolCall.type);
+      if (type) {
+        existing.type = type;
+      }
+      const functionCall = isRecord2(rawToolCall.function) ? rawToolCall.function : undefined;
+      const name = pickString(functionCall?.name);
+      if (name) {
+        existing.name = `${existing.name ?? ""}${name}`;
+      }
+      const argumentsDelta = pickString(functionCall?.arguments);
+      if (argumentsDelta) {
+        if (message?.tool_calls === toolCalls || choice.tool_calls === toolCalls) {
+          existing.argumentsText = argumentsDelta;
+        } else {
+          existing.argumentsText += argumentsDelta;
+        }
+      }
+      state.set(toolIndex, existing);
     }
-    state.set(toolIndex, existing);
   }
 }
 function buildOpenAIStreamToolCalls(state) {
@@ -3026,7 +3323,7 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
     }
     const payload = await response.json();
     lastPayload = payload;
-    aggregatedUsage = mergeUsage(aggregatedUsage, pickUsage2(payload));
+    aggregatedUsage = mergeUsage2(aggregatedUsage, pickUsage2(payload));
     finishReason = pickFinishReason2(payload);
     const content = Array.isArray(payload.content) ? payload.content : [];
     const calledTools = pickAnthropicToolCalls(payload).filter((call) => call.type === "function");
@@ -3147,7 +3444,7 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
         callbacks.onChunk?.(chunk);
       }
     });
-    aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
+    aggregatedUsage = mergeUsage2(aggregatedUsage, roundUsage);
     if (roundFinishReason) {
       finishReason = roundFinishReason;
     }
@@ -3806,95 +4103,6 @@ function withToolTimeout(client, toolTimeoutMs) {
 function applyToolTimeout(clients, toolTimeoutMs) {
   return clients.map((client) => withToolTimeout(client, toolTimeoutMs));
 }
-// src/generate-output.ts
-var RE_THINK_TAGS = /<\/?think\s*>/gi;
-function normalizeModelOutput(text, dedicatedReasoning, reasoningBlocks) {
-  const sanitized = sanitizeThink(text);
-  const visibleText = stripThinkBlocks(text, sanitized.thinkBlocks);
-  const reasoning = joinReasoningSegments([
-    dedicatedReasoning,
-    ...sanitized.thinkBlocks.map((block) => block.content)
-  ]);
-  return {
-    text: visibleText,
-    reasoning,
-    reasoningBlocks: normalizeReasoningBlocks(reasoningBlocks),
-    thinkBlocks: sanitized.thinkBlocks,
-    parseSource: composeParseSource(visibleText, reasoning)
-  };
-}
-function normalizeReasoningBlocks(blocks) {
-  if (!Array.isArray(blocks)) {
-    return;
-  }
-  const normalized = blocks.map((block) => ({
-    turnIndex: block.turnIndex,
-    text: block.text.replace(RE_THINK_TAGS, "").trim()
-  })).filter((block) => Number.isFinite(block.turnIndex) && block.text.length > 0);
-  return normalized.length > 0 ? normalized : undefined;
-}
-function appendReasoningBlock(blocks, transition) {
-  const text = transition.reasoningText?.replace(RE_THINK_TAGS, "").trim();
-  if (!text) {
-    return blocks;
-  }
-  const next = [...blocks ?? [], { turnIndex: transition.turnIndex, text }];
-  return normalizeReasoningBlocks(next);
-}
-function composeParseSource(text, reasoning) {
-  if (typeof reasoning !== "string" || reasoning.length === 0) {
-    return text;
-  }
-  const sanitized = reasoning.replace(RE_THINK_TAGS, "");
-  if (sanitized.length === 0) {
-    return text;
-  }
-  return `<think>${sanitized}</think>${text}`;
-}
-function aggregateUsage(attempts) {
-  let usage;
-  for (const attempt of attempts) {
-    usage = mergeUsage2(usage, attempt.usage);
-  }
-  return usage;
-}
-function mergeUsage2(base, next) {
-  if (!base && !next) {
-    return;
-  }
-  return {
-    inputTokens: (base?.inputTokens ?? 0) + (next?.inputTokens ?? 0),
-    outputTokens: (base?.outputTokens ?? 0) + (next?.outputTokens ?? 0),
-    totalTokens: (base?.totalTokens ?? 0) + (next?.totalTokens ?? 0),
-    cost: (base?.cost ?? 0) + (next?.cost ?? 0)
-  };
-}
-function joinReasoningSegments(parts) {
-  return parts.map((value) => value?.trim()).filter((value) => Boolean(value)).join(`
-
-`);
-}
-function stripThinkBlocks(text, thinkBlocks) {
-  if (thinkBlocks.length === 0) {
-    return text;
-  }
-  let output = "";
-  let cursor = 0;
-  for (const block of thinkBlocks) {
-    output += text.slice(cursor, block.start);
-    cursor = block.end;
-  }
-  output += text.slice(cursor);
-  return output;
-}
-function toStreamDataFingerprint(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "__unserializable__";
-  }
-}
-
 // src/utils/debug-colors.ts
 var ANSI = {
   reset: "\x1B[0m",
@@ -4056,13 +4264,15 @@ async function callModel(adapter, options) {
       if (!done && fingerprint === lastSnapshotFingerprint) {
         return;
       }
+      const stableText = done ? normalized2.text : withoutTrailingThinkTagPrefix(normalized2.text);
+      const stableReasoning = done ? normalized2.reasoning : withoutTrailingThinkTagPrefix(normalized2.reasoning);
       const delta = {
-        text: normalized2.text.startsWith(previousSnapshotText) ? normalized2.text.slice(previousSnapshotText.length) : "",
-        reasoning: normalized2.reasoning.startsWith(previousSnapshotReasoning) ? normalized2.reasoning.slice(previousSnapshotReasoning.length) : ""
+        text: stableText.startsWith(previousSnapshotText) ? stableText.slice(previousSnapshotText.length) : "",
+        reasoning: stableReasoning.startsWith(previousSnapshotReasoning) ? stableReasoning.slice(previousSnapshotReasoning.length) : ""
       };
       lastSnapshotFingerprint = fingerprint;
-      previousSnapshotText = normalized2.text;
-      previousSnapshotReasoning = normalized2.reasoning;
+      previousSnapshotText = stableText;
+      previousSnapshotReasoning = stableReasoning;
       options.stream.onData?.({
         delta,
         snapshot,