extrait 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -1597,8 +1597,14 @@ function createOpenAICompatibleAdapter(options) {
     async stream(request, callbacks = {}) {
       const usesResponses = shouldUseResponsesAPI(options, request);
       const usesMCP = hasMCPClients(request.mcpClients);
-      if (usesResponses || usesMCP) {
-        return streamViaComplete(callbacks, () => completeOpenAIRequest(options, fetcher, path, responsesPath, request));
+      if (usesResponses) {
+        if (usesMCP) {
+          return streamWithResponsesAPIWithMCP(options, fetcher, responsesPath, request, callbacks);
+        }
+        return streamWithResponsesAPIPassThrough(options, fetcher, responsesPath, request, callbacks);
+      }
+      if (usesMCP) {
+        return streamWithChatCompletionsWithMCP(options, fetcher, path, request, callbacks);
       }
       const response = await fetcher(buildURL(options.baseURL, path), {
         method: "POST",
@@ -1883,6 +1889,316 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
     toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
   };
 }
+async function streamWithChatCompletionsWithMCP(options, fetcher, path, request, callbacks) {
+  const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
+  let messages = buildMessages(request);
+  let aggregatedUsage;
+  let finishReason;
+  let lastPayload;
+  const executedToolCalls = [];
+  const toolExecutions = [];
+  callbacks.onStart?.();
+  for (let round = 1;round <= maxToolRounds + 1; round += 1) {
+    const mcpToolset = await resolveMCPToolset(request.mcpClients);
+    const transportTools = toProviderFunctionTools(mcpToolset);
+    const response = await fetcher(buildURL(options.baseURL, path), {
+      method: "POST",
+      headers: buildHeaders(options),
+      body: JSON.stringify(cleanUndefined({
+        ...options.defaultBody,
+        ...request.body,
+        model: options.model,
+        messages,
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        tools: transportTools,
+        tool_choice: request.toolChoice,
+        parallel_tool_calls: request.parallelToolCalls,
+        stream: true
+      }))
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      throw new Error(`HTTP ${response.status}: ${message}`);
+    }
+    let roundText = "";
+    let roundUsage;
+    let roundFinishReason;
+    const streamedToolCalls = new Map;
+    await consumeSSE(response, (data) => {
+      if (data === "[DONE]") {
+        return;
+      }
+      const json = safeJSONParse(data);
+      if (!isRecord2(json)) {
+        return;
+      }
+      lastPayload = json;
+      const delta = pickAssistantDelta(json);
+      const chunkUsage = pickUsage(json);
+      const chunkFinishReason = pickFinishReason(json);
+      collectOpenAIStreamToolCalls(json, streamedToolCalls);
+      roundUsage = mergeUsage(roundUsage, chunkUsage);
+      if (chunkFinishReason) {
+        roundFinishReason = chunkFinishReason;
+      }
+      if (delta) {
+        roundText += delta;
+        callbacks.onToken?.(delta);
+      }
+      if (delta || chunkUsage || chunkFinishReason) {
+        const chunk = {
+          textDelta: delta,
+          raw: json,
+          usage: chunkUsage,
+          finishReason: chunkFinishReason
+        };
+        callbacks.onChunk?.(chunk);
+      }
+    });
+    aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
+    if (roundFinishReason) {
+      finishReason = roundFinishReason;
+    }
+    const calledTools = buildOpenAIStreamToolCalls(streamedToolCalls);
+    if (calledTools.length === 0) {
+      const out2 = {
+        text: roundText,
+        raw: lastPayload,
+        usage: aggregatedUsage,
+        finishReason,
+        toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
+        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+      };
+      callbacks.onComplete?.(out2);
+      return out2;
+    }
+    if (round > maxToolRounds) {
+      throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
+    }
+    const outputs = await executeMCPToolCalls(calledTools, mcpToolset, {
+      round,
+      request,
+      provider: "openai-compatible",
+      model: options.model
+    });
+    executedToolCalls.push(...outputs.map((entry) => entry.call));
+    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    const assistantMessage = buildOpenAIAssistantToolMessage(roundText, calledTools);
+    const toolMessages = outputs.map((entry) => ({
+      role: "tool",
+      tool_call_id: entry.call.id,
+      content: stringifyToolOutput(entry.call.error ? { error: entry.call.error } : entry.call.output)
+    }));
+    messages = [...messages, assistantMessage, ...toolMessages];
+  }
+  const out = {
+    text: "",
+    raw: lastPayload,
+    usage: aggregatedUsage,
+    finishReason,
+    toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
+    toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+  };
+  callbacks.onComplete?.(out);
+  return out;
+}
+async function streamWithResponsesAPIPassThrough(options, fetcher, path, request, callbacks) {
+  const body = isRecord2(request.body) ? request.body : undefined;
+  const response = await fetcher(buildURL(options.baseURL, path), {
+    method: "POST",
+    headers: buildHeaders(options),
+    body: JSON.stringify(cleanUndefined({
+      ...options.defaultBody,
+      ...request.body,
+      model: options.model,
+      input: buildResponsesInput(request),
+      previous_response_id: pickString(body?.previous_response_id),
+      temperature: request.temperature,
+      max_output_tokens: request.maxTokens,
+      stream: true
+    }))
+  });
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  callbacks.onStart?.();
+  let text = "";
+  let usage;
+  let finishReason;
+  let lastPayload;
+  await consumeSSE(response, (data) => {
+    if (data === "[DONE]") {
+      return;
+    }
+    const json = safeJSONParse(data);
+    if (!isRecord2(json)) {
+      return;
+    }
+    const roundPayload = pickResponsesStreamPayload(json);
+    if (roundPayload) {
+      lastPayload = roundPayload;
+    }
+    const delta = pickResponsesStreamTextDelta(json);
+    const chunkUsage = pickResponsesStreamUsage(json);
+    const chunkFinishReason = pickResponsesStreamFinishReason(json);
+    usage = mergeUsage(usage, chunkUsage);
+    if (chunkFinishReason) {
+      finishReason = chunkFinishReason;
+    }
+    if (delta) {
+      text += delta;
+      callbacks.onToken?.(delta);
+    }
+    if (delta || chunkUsage || chunkFinishReason) {
+      const chunk = {
+        textDelta: delta,
+        raw: json,
+        usage: chunkUsage,
+        finishReason: chunkFinishReason
+      };
+      callbacks.onChunk?.(chunk);
+    }
+  });
+  const finalPayload = lastPayload ?? {};
+  const out = {
+    text: text.length > 0 ? text : pickResponsesText(finalPayload) || pickAssistantText(finalPayload),
+    raw: finalPayload,
+    usage: mergeUsage(usage, pickUsage(finalPayload)),
+    finishReason: finishReason ?? pickResponsesFinishReason(finalPayload) ?? pickFinishReason(finalPayload)
+  };
+  callbacks.onComplete?.(out);
+  return out;
+}
+async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, callbacks) {
+  const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
+  let input = buildResponsesInput(request);
+  let previousResponseId = pickString(isRecord2(request.body) ? request.body.previous_response_id : undefined);
+  let aggregatedUsage;
+  let finishReason;
+  let lastPayload;
+  const executedToolCalls = [];
+  const toolExecutions = [];
+  callbacks.onStart?.();
+  for (let round = 1;round <= maxToolRounds + 1; round += 1) {
+    const mcpToolset = await resolveMCPToolset(request.mcpClients);
+    const transportTools = toResponsesTools(toProviderFunctionTools(mcpToolset));
+    const response = await fetcher(buildURL(options.baseURL, path), {
+      method: "POST",
+      headers: buildHeaders(options),
+      body: JSON.stringify(cleanUndefined({
+        ...options.defaultBody,
+        ...request.body,
+        model: options.model,
+        input,
+        previous_response_id: previousResponseId,
+        temperature: request.temperature,
+        max_output_tokens: request.maxTokens,
+        tools: transportTools,
+        tool_choice: request.toolChoice,
+        parallel_tool_calls: request.parallelToolCalls,
+        stream: true
+      }))
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      throw new Error(`HTTP ${response.status}: ${message}`);
+    }
+    let roundText = "";
+    let roundUsage;
+    let roundFinishReason;
+    let roundPayload;
+    const streamedToolCalls = new Map;
+    await consumeSSE(response, (data) => {
+      if (data === "[DONE]") {
+        return;
+      }
+      const json = safeJSONParse(data);
+      if (!isRecord2(json)) {
+        return;
+      }
+      const payload = pickResponsesStreamPayload(json);
+      if (payload) {
+        roundPayload = payload;
+        lastPayload = payload;
+      }
+      const delta = pickResponsesStreamTextDelta(json);
+      const chunkUsage = pickResponsesStreamUsage(json);
+      const chunkFinishReason = pickResponsesStreamFinishReason(json);
+      collectResponsesStreamToolCalls(json, streamedToolCalls);
+      roundUsage = mergeUsage(roundUsage, chunkUsage);
+      if (chunkFinishReason) {
+        roundFinishReason = chunkFinishReason;
+      }
+      if (delta) {
+        roundText += delta;
+        callbacks.onToken?.(delta);
+      }
+      if (delta || chunkUsage || chunkFinishReason) {
+        const chunk = {
+          textDelta: delta,
+          raw: json,
+          usage: chunkUsage,
+          finishReason: chunkFinishReason
+        };
+        callbacks.onChunk?.(chunk);
+      }
+    });
+    aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
+    const payloadUsage = roundPayload ? pickUsage(roundPayload) : undefined;
+    aggregatedUsage = mergeUsage(aggregatedUsage, payloadUsage);
+    if (roundFinishReason) {
+      finishReason = roundFinishReason;
+    } else if (roundPayload) {
+      finishReason = pickResponsesFinishReason(roundPayload) ?? finishReason;
+    }
+    const payloadToolCalls = roundPayload ? pickResponsesToolCalls(roundPayload) : [];
+    const streamedCalls = buildResponsesStreamToolCalls(streamedToolCalls);
+    const providerToolCalls = payloadToolCalls.length > 0 ? payloadToolCalls : streamedCalls;
+    const functionCalls = providerToolCalls.filter((toolCall) => toolCall.type === "function" && typeof toolCall.id === "string" && typeof toolCall.name === "string");
+    if (functionCalls.length === 0) {
+      const finalText = roundText.length > 0 ? roundText : roundPayload ? pickResponsesText(roundPayload) || pickAssistantText(roundPayload) : "";
+      const out2 = {
+        text: finalText,
+        raw: roundPayload ?? lastPayload,
+        usage: aggregatedUsage,
+        finishReason,
+        toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
+        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+      };
+      callbacks.onComplete?.(out2);
+      return out2;
+    }
+    if (round > maxToolRounds) {
+      throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
+    }
+    const outputs = await executeMCPToolCalls(functionCalls, mcpToolset, {
+      round,
+      request,
+      provider: "openai-compatible",
+      model: options.model
+    });
+    executedToolCalls.push(...outputs.map((entry) => entry.call));
+    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    input = outputs.map((entry) => ({
+      type: "function_call_output",
+      call_id: entry.call.id,
+      output: stringifyToolOutput(entry.call.error ? { error: entry.call.error } : entry.call.output)
+    }));
+    previousResponseId = pickString(roundPayload?.id);
+  }
+  const out = {
+    text: pickResponsesText(lastPayload ?? {}) || pickAssistantText(lastPayload ?? {}),
+    raw: lastPayload,
+    usage: aggregatedUsage,
+    finishReason,
+    toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
+    toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+  };
+  callbacks.onComplete?.(out);
+  return out;
+}
 function shouldUseResponsesAPI(options, request) {
   if (options.path?.includes("/responses")) {
     return true;
@@ -2039,6 +2355,190 @@ function pickAssistantDelta(payload) {
   }
   return "";
 }
+function collectOpenAIStreamToolCalls(payload, state) {
+  const choices = payload.choices;
+  if (!Array.isArray(choices) || choices.length === 0 || !isRecord2(choices[0])) {
+    return;
+  }
+  const delta = choices[0].delta;
+  if (!isRecord2(delta) || !Array.isArray(delta.tool_calls)) {
+    return;
+  }
+  for (const rawToolCall of delta.tool_calls) {
+    if (!isRecord2(rawToolCall)) {
+      continue;
+    }
+    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;
+    }
+    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) {
+      existing.argumentsText += argumentsDelta;
+    }
+    state.set(toolIndex, existing);
+  }
+}
+function buildOpenAIStreamToolCalls(state) {
+  return [...state.values()].sort((a, b) => a.index - b.index).map((entry) => ({
+    id: entry.id ?? "",
+    type: entry.type ?? "function",
+    name: entry.name,
+    arguments: entry.argumentsText.length > 0 ? entry.argumentsText : {}
+  }));
+}
+function buildOpenAIAssistantToolMessage(text, toolCalls) {
+  return {
+    role: "assistant",
+    content: text,
+    tool_calls: toolCalls.map((call) => ({
+      id: call.id,
+      type: "function",
+      function: {
+        name: call.name,
+        arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments ?? {})
+      }
+    }))
+  };
+}
+function pickResponsesStreamPayload(payload) {
+  if (isRecord2(payload.response)) {
+    return payload.response;
+  }
+  if ("output" in payload || "output_text" in payload || "status" in payload || "id" in payload) {
+    return payload;
+  }
+  return;
+}
+function pickResponsesStreamTextDelta(payload) {
+  const eventType = pickString(payload.type) ?? "";
+  if (!eventType.includes("output_text.delta")) {
+    return "";
+  }
+  const direct = pickString(payload.delta);
+  if (direct) {
+    return direct;
+  }
+  if (isRecord2(payload.delta)) {
+    return pickString(payload.delta.text) ?? pickString(payload.delta.output_text) ?? "";
+  }
+  return "";
+}
+function pickResponsesStreamUsage(payload) {
+  const direct = pickUsage(payload);
+  if (direct) {
+    return direct;
+  }
+  if (isRecord2(payload.response)) {
+    return pickUsage(payload.response);
+  }
+  return;
+}
+function pickResponsesStreamFinishReason(payload) {
+  const eventType = pickString(payload.type);
+  if (eventType === "response.completed") {
+    return "completed";
+  }
+  if (eventType === "response.failed") {
+    return "failed";
+  }
+  const directStatus = pickString(payload.status);
+  if (directStatus) {
+    return directStatus;
+  }
+  if (isRecord2(payload.response)) {
+    return pickString(payload.response.status);
+  }
+  return;
+}
+function collectResponsesStreamToolCalls(payload, state) {
+  if (isRecord2(payload.response)) {
+    collectResponsesStreamToolCallsFromOutput(payload.response.output, state);
+  }
+  collectResponsesStreamToolCallsFromOutput(payload.output, state);
+  if (isRecord2(payload.item)) {
+    const itemKey = pickString(payload.item_id) ?? pickString(payload.call_id);
+    collectResponsesStreamToolCallsFromItem(payload.item, state, itemKey);
+  }
+  if (isRecord2(payload.output_item)) {
+    const itemKey = pickString(payload.item_id) ?? pickString(payload.call_id);
+    collectResponsesStreamToolCallsFromItem(payload.output_item, state, itemKey);
+  }
+  const eventType = pickString(payload.type) ?? "";
+  if (eventType.includes("function_call_arguments.delta")) {
+    const key = pickString(payload.item_id) ?? pickString(payload.call_id) ?? "function_call";
+    const existing = state.get(key) ?? {
+      key,
+      argumentsText: ""
+    };
+    const delta = pickString(payload.delta) ?? (isRecord2(payload.delta) ? pickString(payload.delta.text) ?? pickString(payload.delta.arguments) : undefined) ?? pickString(payload.arguments_delta);
+    if (delta) {
+      existing.argumentsText += delta;
+    }
+    state.set(key, existing);
+  }
+}
+function collectResponsesStreamToolCallsFromOutput(output, state) {
+  if (!Array.isArray(output)) {
+    return;
+  }
+  for (const item of output) {
+    if (!isRecord2(item)) {
+      continue;
+    }
+    collectResponsesStreamToolCallsFromItem(item, state);
+  }
+}
+function collectResponsesStreamToolCallsFromItem(item, state, forcedKey) {
+  const type = pickString(item.type);
+  if (type !== "function_call" && !type?.includes("tool") && !type?.includes("mcp")) {
+    return;
+  }
+  const key = forcedKey ?? pickString(item.call_id) ?? pickString(item.id) ?? `call_${state.size}`;
+  const existing = state.get(key) ?? {
+    key,
+    argumentsText: ""
+  };
+  const callId = pickString(item.call_id) ?? pickString(item.id);
+  if (callId) {
+    existing.id = callId;
+  }
+  if (type) {
+    existing.type = type;
+  }
+  const name = pickString(item.name);
+  if (name) {
+    existing.name = name;
+  }
+  const argumentsText = pickString(item.arguments);
+  if (argumentsText && argumentsText.length >= existing.argumentsText.length) {
+    existing.argumentsText = argumentsText;
+  }
+  state.set(key, existing);
+}
+function buildResponsesStreamToolCalls(state) {
+  return [...state.values()].map((entry) => ({
+    id: entry.id ?? entry.key,
+    type: entry.type === "function_call" ? "function" : entry.type ?? "function",
+    name: entry.name,
+    arguments: entry.argumentsText.length > 0 ? entry.argumentsText : {}
+  }));
+}
 function pickResponsesText(payload) {
   const outputText = payload.output_text;
   if (typeof outputText === "string") {
@@ -2131,22 +2631,6 @@ function pickResponsesFinishReason(payload) {
   }
   return;
 }
-async function streamViaComplete(callbacks, complete) {
-  callbacks.onStart?.();
-  const response = await complete();
-  if (response.text.length > 0) {
-    callbacks.onToken?.(response.text);
-  }
-  callbacks.onChunk?.({
-    textDelta: response.text,
-    raw: response.raw,
-    done: true,
-    usage: response.usage,
-    finishReason: response.finishReason
-  });
-  callbacks.onComplete?.(response);
-  return response;
-}
 
 // src/providers/anthropic-compatible.ts
 var DEFAULT_ANTHROPIC_MAX_TOKENS = 1024;
@@ -2165,7 +2649,7 @@ function createAnthropicCompatibleAdapter(options) {
     },
     async stream(request, callbacks = {}) {
       if (hasMCPClients(request.mcpClients)) {
-        return streamViaComplete2(callbacks, () => this.complete(request));
+        return streamWithMCPToolLoop(options, fetcher, path, request, callbacks);
       }
       const response = await fetcher(buildURL(options.baseURL, path), {
         method: "POST",
@@ -2339,6 +2823,127 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
     toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
   };
 }
+async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks) {
+  const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
+  let messages = [{ role: "user", content: request.prompt }];
+  let aggregatedUsage;
+  let finishReason;
+  let lastPayload;
+  const toolCalls = [];
+  const toolExecutions = [];
+  callbacks.onStart?.();
+  for (let round = 1;round <= maxToolRounds + 1; round += 1) {
+    const mcpToolset = await resolveMCPToolset(request.mcpClients);
+    const tools = toAnthropicTools(toProviderFunctionTools(mcpToolset));
+    const response = await fetcher(buildURL(options.baseURL, path), {
+      method: "POST",
+      headers: buildHeaders2(options),
+      body: JSON.stringify(cleanUndefined({
+        ...options.defaultBody,
+        ...request.body,
+        model: options.model,
+        system: request.systemPrompt,
+        messages,
+        temperature: request.temperature,
+        max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
+        tools,
+        tool_choice: toAnthropicToolChoice(request.toolChoice),
+        stream: true
+      }))
+    });
+    if (!response.ok) {
+      const message = await response.text();
+      throw new Error(`HTTP ${response.status}: ${message}`);
+    }
+    let roundText = "";
+    let roundUsage;
+    let roundFinishReason;
+    const streamedToolCalls = new Map;
+    await consumeSSE(response, (data) => {
+      if (data === "[DONE]") {
+        return;
+      }
+      const json = safeJSONParse(data);
+      if (!isRecord2(json)) {
+        return;
+      }
+      lastPayload = json;
+      const delta = pickAnthropicDelta(json);
+      const chunkUsage = pickUsage2(json);
+      const chunkFinishReason = pickFinishReason2(json);
+      collectAnthropicStreamToolCalls(json, streamedToolCalls);
+      roundUsage = mergeUsage(roundUsage, chunkUsage);
+      if (chunkFinishReason) {
+        roundFinishReason = chunkFinishReason;
+      }
+      if (delta) {
+        roundText += delta;
+        callbacks.onToken?.(delta);
+      }
+      if (delta || chunkUsage || chunkFinishReason) {
+        const chunk = {
+          textDelta: delta,
+          raw: json,
+          usage: chunkUsage,
+          finishReason: chunkFinishReason
+        };
+        callbacks.onChunk?.(chunk);
+      }
+    });
+    aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
+    if (roundFinishReason) {
+      finishReason = roundFinishReason;
+    }
+    const calledTools = buildAnthropicStreamToolCalls(streamedToolCalls);
+    if (calledTools.length === 0) {
+      const out2 = {
+        text: roundText,
+        raw: lastPayload,
+        usage: aggregatedUsage,
+        finishReason,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+      };
+      callbacks.onComplete?.(out2);
+      return out2;
+    }
+    if (round > maxToolRounds) {
+      throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
+    }
+    const toolResultContent = [];
+    const outputs = await executeMCPToolCalls(calledTools, mcpToolset, {
+      round,
+      request,
+      provider: "anthropic-compatible",
+      model: options.model
+    });
+    toolCalls.push(...outputs.map((entry) => entry.call));
+    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    for (const entry of outputs) {
+      toolResultContent.push({
+        type: "tool_result",
+        tool_use_id: entry.call.id,
+        ...entry.call.error ? { is_error: true } : {},
+        content: stringifyToolOutput(entry.call.error ? { error: entry.call.error } : entry.call.output)
+      });
+    }
+    messages = [
+      ...messages,
+      { role: "assistant", content: buildAnthropicAssistantToolContent(roundText, calledTools) },
+      { role: "user", content: toolResultContent }
+    ];
+  }
+  const out = {
+    text: "",
+    raw: lastPayload,
+    usage: aggregatedUsage,
+    finishReason,
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+  };
+  callbacks.onComplete?.(out);
+  return out;
+}
 function buildHeaders2(options) {
   return {
     "content-type": "application/json",
@@ -2401,6 +3006,83 @@ function pickAnthropicDelta(payload) {
   }
   return "";
 }
+function collectAnthropicStreamToolCalls(payload, state) {
+  const eventType = pickString(payload.type);
+  if (!eventType) {
+    return;
+  }
+  if (eventType === "content_block_start" && isRecord2(payload.content_block)) {
+    const block = payload.content_block;
+    if (pickString(block.type) !== "tool_use") {
+      return;
+    }
+    const index = pickContentBlockIndex(payload.index);
+    const existing = state.get(index) ?? {
+      index,
+      argumentsText: ""
+    };
+    const id = pickString(block.id);
+    if (id) {
+      existing.id = id;
+    }
+    const name = pickString(block.name);
+    if (name) {
+      existing.name = name;
+    }
+    if ("input" in block) {
+      existing.input = block.input;
+    }
+    state.set(index, existing);
+    return;
+  }
+  if (eventType === "content_block_delta" && isRecord2(payload.delta)) {
+    const delta = payload.delta;
+    if (pickString(delta.type) !== "input_json_delta") {
+      return;
+    }
+    const index = pickContentBlockIndex(payload.index);
+    const existing = state.get(index) ?? {
+      index,
+      argumentsText: ""
+    };
+    const partial = pickString(delta.partial_json);
+    if (partial) {
+      existing.argumentsText += partial;
+    }
+    state.set(index, existing);
+  }
+}
+function pickContentBlockIndex(value) {
+  const numeric = toFiniteNumber(value);
+  if (numeric !== undefined) {
+    return Math.floor(numeric);
+  }
+  return 0;
+}
+function buildAnthropicStreamToolCalls(state) {
+  return [...state.values()].sort((a, b) => a.index - b.index).map((entry) => ({
+    id: entry.id ?? "",
+    type: "function",
+    name: entry.name,
+    arguments: entry.argumentsText.length > 0 ? entry.argumentsText : entry.input ?? {}
+  }));
+}
+function buildAnthropicAssistantToolContent(text, toolCalls) {
+  const content = [];
+  if (text.length > 0) {
+    content.push({ type: "text", text });
+  }
+  for (const call of toolCalls) {
+    const parsedArguments = typeof call.arguments === "string" ? parseToolArguments(call.arguments) : call.arguments;
+    content.push({
+      type: "tool_use",
+      id: call.id,
+      name: call.name,
+      input: isRecord2(parsedArguments) ? parsedArguments : {}
+    });
+  }
+  return content;
+}
 function pickUsage2(payload) {
   const fromUsage = extractUsageObject(payload.usage);
   if (fromUsage) {
@@ -2480,22 +3162,6 @@ function toAnthropicToolChoice(value) {
   }
   return value;
 }
-async function streamViaComplete2(callbacks, complete) {
-  callbacks.onStart?.();
-  const response = await complete();
-  if (response.text.length > 0) {
-    callbacks.onToken?.(response.text);
-  }
-  callbacks.onChunk?.({
-    textDelta: response.text,
-    raw: response.raw,
-    done: true,
-    usage: response.usage,
-    finishReason: response.finishReason
-  });
-  callbacks.onComplete?.(response);
-  return response;
-}
 
 // src/providers/registry.ts
 class InMemoryProviderRegistry {