extrait 0.1.2 → 0.3.0

package/dist/index.js

@@ -219,6 +219,9 @@ function isOnlyWhitespace(value) {
 }
 
 // src/extract.ts
+var RE_EMPTY_OBJECT = /^\{\s*\}$/;
+var RE_EMPTY_ARRAY = /^\[\s*\]$/;
+var RE_BOUNDARY_CHAR = /[\s,.;:!?`"'()\[\]{}<>]/;
 var DEFAULT_EXTRACTION_HEURISTICS = {
   firstPassMin: 12,
   firstPassCap: 30,
@@ -443,7 +446,7 @@ function jsonShapeScore(content, acceptArrays) {
   const commaCount = countChar(trimmed, ",");
   const quoteCount = countChar(trimmed, '"');
   if (root === "{") {
-    if (/^\{\s*\}$/.test(trimmed)) {
+    if (RE_EMPTY_OBJECT.test(trimmed)) {
       score += 12;
     } else if (colonCount > 0) {
       score += 22;
@@ -454,7 +457,7 @@ function jsonShapeScore(content, acceptArrays) {
       score += quoteCount % 2 === 0 ? 8 : -8;
     }
   } else {
-    score += /^\[\s*\]$/.test(trimmed) ? 8 : 4;
+    score += RE_EMPTY_ARRAY.test(trimmed) ? 8 : 4;
     if (colonCount > 0) {
       score += 4;
     }
@@ -487,7 +490,7 @@ function isBoundary(char) {
   if (!char) {
     return true;
   }
-  return /[\s,.;:!?`"'()[\]{}<>]/.test(char);
+  return RE_BOUNDARY_CHAR.test(char);
 }
 function lengthScore(length) {
   return Math.min(120, Math.floor(Math.sqrt(length) * 6));
@@ -676,6 +679,8 @@ function clamp(value, min, max) {
   return Math.max(min, Math.min(max, Math.floor(value)));
 }
 // src/schema.ts
+var RE_SIMPLE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RE_WHITESPACE = /\s+/g;
 function formatZodSchemaLikeTypeScript(schema) {
   return formatType(schema, 0, new WeakSet);
 }
@@ -847,7 +852,7 @@ ${lines.join(`
 ${indent}}`;
 }
 function formatKey(key) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+  return RE_SIMPLE_IDENTIFIER.test(key) ? key : JSON.stringify(key);
 }
 function requiresParentheses(typeText) {
   return typeText.includes(" | ") || typeText.includes(" & ");
@@ -893,7 +898,7 @@ function readSchemaDescription(schema) {
   return;
 }
 function sanitizeDescription(value) {
-  return value.replace(/\s+/g, " ").trim();
+  return value.replace(RE_WHITESPACE, " ").trim();
 }
 
 // src/format.ts
@@ -918,6 +923,8 @@ function resolveSchemaInstruction(instruction) {
 }
 // src/think.ts
 var THINK_TAG_NAME = "think";
+var RE_IDENTIFIER_CHAR = /[a-zA-Z0-9:_-]/;
+var RE_NON_LINE_BREAK = /[^\r\n]/g;
 function sanitizeThink(input) {
   const thinkBlocks = [];
   const diagnostics = {
@@ -1016,6 +1023,9 @@ function parseThinkTagAt(input, index) {
   if (input[cursor] === "/") {
     closing = true;
     cursor += 1;
+    while (cursor < input.length && isWhitespace(input[cursor])) {
+      cursor += 1;
+    }
   }
   if (!matchesIgnoreCase(input, cursor, THINK_TAG_NAME)) {
     return null;
@@ -1072,7 +1082,7 @@ function matchesIgnoreCase(input, index, expected) {
   return input.slice(index, index + expected.length).toLowerCase() === expected;
 }
 function isIdentifierChar(char) {
-  return /[a-zA-Z0-9:_-]/.test(char);
+  return RE_IDENTIFIER_CHAR.test(char);
 }
 function countHiddenChars(value) {
   let count = 0;
@@ -1086,9 +1096,10 @@ function countHiddenChars(value) {
   return count;
 }
 function maskKeepingLineBreaks(value) {
-  return value.replace(/[^\r\n]/g, " ");
+  return value.replace(RE_NON_LINE_BREAK, " ");
 }
 // src/providers/stream-utils.ts
+var RE_LINE_ENDING = /\r?\n/;
 async function consumeSSE(response, onEvent) {
   if (!response.body) {
     return;
@@ -1111,7 +1122,7 @@ async function consumeSSE(response, onEvent) {
       buffer = buffer.slice(boundary + (buffer.startsWith(`\r
 \r
 `, boundary) ? 4 : 2));
-      const dataLines = rawEvent.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+      const dataLines = rawEvent.split(RE_LINE_ENDING).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
       if (dataLines.length === 0) {
         continue;
       }
@@ -1121,7 +1132,7 @@ async function consumeSSE(response, onEvent) {
   }
   const remainder = buffer.trim();
   if (remainder.length > 0) {
-    const dataLines = remainder.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+    const dataLines = remainder.split(RE_LINE_ENDING).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
     if (dataLines.length > 0) {
       onEvent(dataLines.join(`
 `));
@@ -1411,13 +1422,18 @@ function describeTool(clientId, tool, hasCollision) {
   }
   return;
 }
+var RE_NON_ALPHANUMERIC = /[^A-Za-z0-9_]/g;
+var RE_MULTIPLE_UNDERSCORES = /_+/g;
+var RE_LEADING_UNDERSCORES = /^_+/;
+var RE_TRAILING_UNDERSCORES = /_+$/;
+var RE_STARTS_WITH_DIGIT = /^[0-9]/;
 function sanitizeToolName(input) {
-  const sanitized = input.replace(/[^A-Za-z0-9_]/g, "_").replace(/_+/g, "_");
-  const trimmed = sanitized.replace(/^_+/, "").replace(/_+$/, "");
+  const sanitized = input.replace(RE_NON_ALPHANUMERIC, "_").replace(RE_MULTIPLE_UNDERSCORES, "_");
+  const trimmed = sanitized.replace(RE_LEADING_UNDERSCORES, "").replace(RE_TRAILING_UNDERSCORES, "");
   if (!trimmed) {
     return "tool";
   }
-  if (/^[0-9]/.test(trimmed)) {
+  if (RE_STARTS_WITH_DIGIT.test(trimmed)) {
     return `tool_${trimmed}`;
   }
   return trimmed;
@@ -1502,8 +1518,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",
@@ -1608,8 +1630,6 @@ async function completeWithChatCompletionsPassThrough(options, fetcher, path, re
   };
 }
 async function completeWithChatCompletionsWithMCP(options, fetcher, path, request) {
-  const mcpToolset = await resolveMCPToolset(request.mcpClients);
-  const transportTools = toProviderFunctionTools(mcpToolset);
   const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
   let messages = buildMessages(request);
   let aggregatedUsage;
@@ -1618,6 +1638,8 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
   const toolCalls = [];
   const toolExecutions = [];
   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),
@@ -1713,8 +1735,6 @@ async function completeWithResponsesAPIPassThrough(options, fetcher, path, reque
   };
 }
 async function completeWithResponsesAPIWithMCP(options, fetcher, path, request) {
-  const mcpToolset = await resolveMCPToolset(request.mcpClients);
-  const transportTools = toResponsesTools(toProviderFunctionTools(mcpToolset));
   const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
   let input = buildResponsesInput(request);
   let previousResponseId = pickString(isRecord2(request.body) ? request.body.previous_response_id : undefined);
@@ -1724,6 +1744,8 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
   const executedToolCalls = [];
   const toolExecutions = [];
   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),
@@ -1788,6 +1810,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;
@@ -1944,6 +2276,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") {
@@ -2036,22 +2552,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;
@@ -2070,7 +2570,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",
@@ -2163,8 +2663,6 @@ async function completePassThrough(options, fetcher, path, request) {
   };
 }
 async function completeWithMCPToolLoop(options, fetcher, path, request) {
-  const mcpToolset = await resolveMCPToolset(request.mcpClients);
-  const tools = toAnthropicTools(toProviderFunctionTools(mcpToolset));
   const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
   let messages = [{ role: "user", content: request.prompt }];
   let aggregatedUsage;
@@ -2173,6 +2671,8 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
   const toolCalls = [];
   const toolExecutions = [];
   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),
@@ -2244,6 +2744,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",
@@ -2306,6 +2927,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) {
@@ -2385,22 +3083,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 {
@@ -2982,6 +3664,9 @@ var DEFAULT_SELF_HEAL_PROTOCOL = "extrait.self-heal.v2";
 var DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS = 12000;
 var DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS = true;
 var DEFAULT_SELF_HEAL_MAX_ERRORS = 8;
+var RE_SIMPLE_IDENTIFIER2 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RE_ESCAPE_QUOTE = /"/g;
+var RE_WHITESPACE2 = /\s+/g;
 var DEFAULT_SELF_HEAL_MAX_DIAGNOSTICS = 8;
 var structuredOutdent = createOutdent({
   trimLeadingNewline: true,
@@ -3326,11 +4011,11 @@ function formatIssuePath(path) {
       out += `[${segment}]`;
       continue;
     }
-    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
+    if (RE_SIMPLE_IDENTIFIER2.test(segment)) {
       out += `.${segment}`;
       continue;
     }
-    out += `["${segment.replace(/"/g, "\\\"")}"]`;
+    out += `["${segment.replace(RE_ESCAPE_QUOTE, "\\\"")}"]`;
   }
   return out;
 }
@@ -3373,7 +4058,7 @@ function buildSelfHealFailureFingerprint(attempt) {
   return [issues, errors, source].join("::");
 }
 function normalizeWhitespace(value) {
-  return value.replace(/\s+/g, " ").trim();
+  return value.replace(RE_WHITESPACE2, " ").trim();
 }
 function normalizeStreamConfig(option) {
   if (typeof option === "boolean") {