extrait 0.6.0 → 0.7.0

package/dist/index.js

@@ -700,36 +700,36 @@ function unwrap(schema) {
   let optional = false;
   let nullable = false;
   while (true) {
-    const typeName = current?._def?.type;
+    const typeName = current?.def?.type;
     if (!typeName) {
       break;
     }
     if (typeName === "optional") {
       optional = true;
-      current = current._def?.innerType ?? current;
+      current = current.def?.innerType ?? current;
       continue;
     }
     if (typeName === "default") {
       optional = true;
-      current = current._def?.innerType ?? current;
+      current = current.def?.innerType ?? current;
       continue;
     }
     if (typeName === "nullable") {
       nullable = true;
-      current = current._def?.innerType ?? current;
+      current = current.def?.innerType ?? current;
       continue;
     }
     if (typeName === "pipe") {
-      const outType = current._def?.out?._def?.type;
+      const outType = current.def?.out?.def?.type;
       if (outType === "transform") {
-        current = current._def?.in ?? current;
+        current = current.def?.in ?? current;
       } else {
-        current = current._def?.out ?? current;
+        current = current.def?.out ?? current;
       }
       continue;
     }
     if (typeName === "catch" || typeName === "readonly") {
-      current = current._def?.innerType ?? current;
+      current = current.def?.innerType ?? current;
       continue;
     }
     break;
@@ -745,7 +745,7 @@ function formatCore(schema, depth, seen) {
     return "unknown";
   }
   seen.add(schema);
-  const typeName = schema?._def?.type;
+  const typeName = schema?.def?.type;
   switch (typeName) {
     case "string":
       return "string";
@@ -770,44 +770,44 @@ function formatCore(schema, depth, seen) {
     case "void":
       return "void";
     case "literal": {
-      const value = schema._def?.values?.[0];
+      const value = schema.def?.values?.[0];
       return JSON.stringify(value);
     }
     case "enum": {
-      const entries = schema._def?.entries;
+      const entries = schema.def?.entries;
       const values = Object.values(entries ?? {});
       const unique = [...new Set(values.filter((v) => typeof v !== "string" || Number.isNaN(Number(v))))];
       return unique.map((v) => JSON.stringify(v)).join(" | ") || "string";
     }
     case "array": {
-      const inner = formatType(schema._def?.element ?? schema, depth, seen);
+      const inner = formatType(schema.def?.element ?? schema, depth, seen);
       return requiresParentheses(inner) ? `(${inner})[]` : `${inner}[]`;
     }
     case "tuple": {
-      const items = (schema._def?.items ?? []).map((item) => formatType(item, depth, seen));
+      const items = (schema.def?.items ?? []).map((item) => formatType(item, depth, seen));
       return `[${items.join(", ")}]`;
     }
     case "union": {
-      const options = (schema._def?.options ?? []).map((option) => formatType(option, depth, seen));
+      const options = (schema.def?.options ?? []).map((option) => formatType(option, depth, seen));
       return options.join(" | ") || "unknown";
     }
     case "intersection": {
-      const left = formatType(schema._def?.left ?? schema, depth, seen);
-      const right = formatType(schema._def?.right ?? schema, depth, seen);
+      const left = formatType(schema.def?.left ?? schema, depth, seen);
+      const right = formatType(schema.def?.right ?? schema, depth, seen);
       return `${left} & ${right}`;
     }
     case "record": {
-      const keyType = formatType(schema._def?.keyType ?? schema, depth, seen);
-      const valueType = formatType(schema._def?.valueType ?? schema, depth, seen);
+      const keyType = formatType(schema.def?.keyType ?? schema, depth, seen);
+      const valueType = formatType(schema.def?.valueType ?? schema, depth, seen);
       return `Record<${keyType}, ${valueType}>`;
     }
     case "map": {
-      const keyType = formatType(schema._def?.keyType ?? schema, depth, seen);
-      const valueType = formatType(schema._def?.valueType ?? schema, depth, seen);
+      const keyType = formatType(schema.def?.keyType ?? schema, depth, seen);
+      const valueType = formatType(schema.def?.valueType ?? schema, depth, seen);
       return `Map<${keyType}, ${valueType}>`;
     }
     case "set": {
-      const valueType = formatType(schema._def?.valueType ?? schema, depth, seen);
+      const valueType = formatType(schema.def?.valueType ?? schema, depth, seen);
       return `Set<${valueType}>`;
     }
     case "object":
@@ -821,7 +821,7 @@ function formatCore(schema, depth, seen) {
 function formatObject(schema, depth, seen) {
   const indent = "  ".repeat(depth);
   const innerIndent = "  ".repeat(depth + 1);
-  const rawShape = schema._def?.shape;
+  const rawShape = schema.def?.shape;
   const shape = typeof rawShape === "function" ? rawShape() : rawShape ?? {};
   const entries = Object.entries(shape);
   if (entries.length === 0) {
@@ -847,27 +847,27 @@ function requiresParentheses(typeText) {
   return typeText.includes(" | ") || typeText.includes(" & ");
 }
 function isIntegerNumber(schema) {
-  const checks = schema._def?.checks ?? [];
+  const checks = schema.def?.checks ?? [];
   return checks.some((check) => check.isInt === true);
 }
 function readSchemaDescription(schema) {
   let current = schema;
-  while (current?._def?.type) {
+  while (current?.def?.type) {
     const desc = current.description;
     if (typeof desc === "string" && desc.trim().length > 0) {
       return sanitizeDescription(desc);
     }
-    const typeName = current._def.type;
+    const typeName = current.def.type;
     if (typeName === "optional" || typeName === "default" || typeName === "nullable") {
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     if (typeName === "pipe") {
-      current = current._def.in ?? current;
+      current = current.def.in ?? current;
       continue;
     }
     if (typeName === "catch" || typeName === "readonly") {
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     break;
@@ -1130,7 +1130,7 @@ function findSSEBoundary(buffer) {
 }
 
 // src/providers/mcp-runtime.ts
-var DEFAULT_MAX_TOOL_ROUNDS = 8;
+var DEFAULT_MAX_TOOL_ROUNDS = 100;
 async function resolveMCPToolset(clients) {
   if (!Array.isArray(clients) || clients.length === 0) {
     return {
@@ -1463,7 +1463,15 @@ function normalizeBaseURL(baseURL) {
   return baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
 }
 function buildURL(baseURL, path) {
-  return new URL(path, normalizeBaseURL(baseURL)).toString();
+  try {
+    return new URL(path).toString();
+  } catch {}
+  const base = new URL(normalizeBaseURL(baseURL));
+  const resolvedPath = new URL(path, "http://provider-path.local");
+  base.pathname = mergePathnames(base.pathname, resolvedPath.pathname);
+  base.search = resolvedPath.search;
+  base.hash = resolvedPath.hash;
+  return base.toString();
 }
 function safeJSONParse(input) {
   try {
@@ -1538,6 +1546,36 @@ function addOptional(a, b) {
   }
   return (a ?? 0) + (b ?? 0);
 }
+function mergePathnames(basePathname, pathPathname) {
+  const baseSegments = splitPathSegments(basePathname);
+  const pathSegments = splitPathSegments(pathPathname);
+  const overlap = findPathOverlap(baseSegments, pathSegments);
+  const mergedSegments = [...baseSegments, ...pathSegments.slice(overlap)];
+  if (mergedSegments.length === 0) {
+    return "/";
+  }
+  const mergedPathname = `/${mergedSegments.join("/")}`;
+  return pathPathname.endsWith("/") && pathPathname !== "/" ? `${mergedPathname}/` : mergedPathname;
+}
+function splitPathSegments(pathname) {
+  return pathname.split("/").filter((segment) => segment.length > 0);
+}
+function findPathOverlap(baseSegments, pathSegments) {
+  const maxOverlap = Math.min(baseSegments.length, pathSegments.length);
+  for (let size = maxOverlap;size > 0; size -= 1) {
+    let matches = true;
+    for (let index = 0;index < size; index += 1) {
+      if (baseSegments[baseSegments.length - size + index] !== pathSegments[index]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      return size;
+    }
+  }
+  return 0;
+}
 
 // src/providers/openai-compatible.ts
 function createOpenAICompatibleAdapter(options) {
@@ -1696,7 +1734,7 @@ async function completeWithChatCompletionsPassThrough(options, fetcher, path, re
     const message = await response.text();
     throw new Error(`HTTP ${response.status}: ${message}`);
   }
-  const payload = await response.json();
+  const payload = await parseOpenAICompatibleJSONResponse(response, "Failed to parse OpenAI-compatible chat completion response");
   const assistantMessage = pickAssistantMessage(payload);
   if (!assistantMessage) {
     throw new Error("No assistant message in OpenAI-compatible response.");
@@ -1712,6 +1750,25 @@ async function completeWithChatCompletionsPassThrough(options, fetcher, path, re
     toolCalls: toolCalls.length > 0 ? toolCalls : undefined
   };
 }
+async function parseOpenAICompatibleJSONResponse(response, context) {
+  const rawBody = await response.text();
+  try {
+    return JSON.parse(rawBody);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${context} (HTTP ${response.status}): ${message}. Raw body: ${formatResponseBodyForError(rawBody)}`);
+  }
+}
+function formatResponseBodyForError(rawBody, maxLength = 2000) {
+  const normalized = rawBody.trim();
+  if (normalized.length === 0) {
+    return "[empty body]";
+  }
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength)}...[truncated ${normalized.length - maxLength} chars]`;
+}
 async function completeWithChatCompletionsWithMCP(options, fetcher, path, request) {
   const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
   let messages = buildMessages(request);
@@ -1720,6 +1777,7 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
   let lastPayload;
   const toolCalls = [];
   const toolExecutions = [];
+  const reasoningBlocks = [];
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
     const transportTools = toProviderFunctionTools(mcpToolset);
@@ -1750,14 +1808,17 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
     finishReason = pickFinishReason(payload);
     const assistantMessage = pickAssistantMessage(payload);
     const calledTools = pickChatToolCalls(payload);
+    const roundReasoning = pickAssistantReasoning(payload);
+    pushReasoningBlock(reasoningBlocks, round, roundReasoning);
     if (!assistantMessage) {
       throw new Error("No assistant message in OpenAI-compatible response.");
     }
     if (calledTools.length === 0) {
-      const reasoning = pickAssistantReasoning(payload);
+      const reasoning = joinReasoningBlocks(reasoningBlocks) || undefined;
       return {
         text: pickAssistantText(payload),
-        reasoning: reasoning.length > 0 ? reasoning : undefined,
+        reasoning,
+        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
         raw: payload,
         usage: aggregatedUsage,
         finishReason,
@@ -1785,10 +1846,8 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
   }
   return {
     text: pickAssistantText(lastPayload ?? {}),
-    reasoning: (() => {
-      const value = pickAssistantReasoning(lastPayload ?? {});
-      return value.length > 0 ? value : undefined;
-    })(),
+    reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+    reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
@@ -1836,6 +1895,7 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
   let lastPayload;
   const executedToolCalls = [];
   const toolExecutions = [];
+  const reasoningBlocks = [];
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
     const transportTools = toResponsesTools(toProviderFunctionTools(mcpToolset));
@@ -1865,12 +1925,15 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
     lastPayload = payload;
     aggregatedUsage = mergeUsage(aggregatedUsage, pickUsage(payload));
     finishReason = pickResponsesFinishReason(payload) ?? finishReason;
+    pushReasoningBlock(reasoningBlocks, round, pickResponsesReasoning(payload));
     const providerToolCalls = pickResponsesToolCalls(payload);
     const functionCalls = providerToolCalls.filter((toolCall) => toolCall.type === "function" && typeof toolCall.id === "string" && typeof toolCall.name === "string");
     if (functionCalls.length === 0) {
       const text = pickResponsesText(payload) || pickAssistantText(payload);
       return {
         text,
+        reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
         raw: payload,
         usage: aggregatedUsage,
         finishReason,
@@ -1898,6 +1961,8 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
   }
   return {
     text: pickResponsesText(lastPayload ?? {}) || pickAssistantText(lastPayload ?? {}),
+    reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+    reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
@@ -1913,9 +1978,9 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
   let lastPayload;
   const executedToolCalls = [];
   const toolExecutions = [];
+  const reasoningBlocks = [];
   callbacks.onStart?.();
   let lastRoundText = "";
-  let lastRoundReasoning = "";
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
     const transportTools = toProviderFunctionTools(mcpToolset);
@@ -1977,6 +2042,7 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         const chunk = {
           textDelta: delta,
           reasoningDelta: reasoningDelta || undefined,
+          turnIndex: round,
           raw: json,
           usage: chunkUsage,
           finishReason: chunkFinishReason
@@ -1989,22 +2055,41 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
       finishReason = roundFinishReason;
     }
     const calledTools = buildOpenAIStreamToolCalls(streamedToolCalls);
+    pushReasoningBlock(reasoningBlocks, round, roundReasoning);
+    request.onTurnTransition?.({
+      turnIndex: round,
+      kind: "reasoningComplete",
+      reasoningText: roundReasoning
+    });
     if (calledTools.length === 0) {
       const out2 = {
         text: roundText,
-        reasoning: roundReasoning.length > 0 ? roundReasoning : undefined,
+        reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
         raw: lastPayload,
         usage: aggregatedUsage,
         finishReason,
         toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
         toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
       };
+      request.onTurnTransition?.({ turnIndex: round, kind: "streamEnd" });
       callbacks.onComplete?.(out2);
       return out2;
     }
     if (round > maxToolRounds) {
       throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
     }
+    request.onTurnTransition?.({
+      turnIndex: round,
+      kind: "toolCallsEmit",
+      toolCalls: calledTools
+    });
+    callbacks.onChunk?.({
+      textDelta: "",
+      turnIndex: round,
+      toolCalls: calledTools,
+      finishReason: roundFinishReason
+    });
     const outputs = await executeMCPToolCalls(calledTools, mcpToolset, {
       round,
       request,
@@ -2013,8 +2098,8 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
     });
     executedToolCalls.push(...outputs.map((entry) => entry.call));
     toolExecutions.push(...outputs.map((entry) => entry.execution));
+    request.onTurnTransition?.({ turnIndex: round, kind: "toolResultsReceived" });
     lastRoundText = roundText;
-    lastRoundReasoning = roundReasoning;
     const assistantMessage = buildOpenAIAssistantToolMessage(roundText, calledTools, {
       reasoning: roundReasoning,
       reasoningFieldName
@@ -2028,13 +2113,15 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
   }
   const out = {
     text: lastRoundText,
-    reasoning: lastRoundReasoning.length > 0 ? lastRoundReasoning : undefined,
+    reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+    reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
     toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
     toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
   };
+  request.onTurnTransition?.({ turnIndex: maxToolRounds + 1, kind: "streamEnd" });
   callbacks.onComplete?.(out);
   return out;
 }
@@ -2117,6 +2204,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
   let lastPayload;
   const executedToolCalls = [];
   const toolExecutions = [];
+  const reasoningBlocks = [];
   callbacks.onStart?.();
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
@@ -2145,6 +2233,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
       throw new Error(`HTTP ${response.status}: ${message}`);
     }
     let roundText = "";
+    let roundReasoning = "";
     let roundUsage;
     let roundFinishReason;
     let roundPayload;
@@ -2163,6 +2252,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
         lastPayload = payload;
       }
       const delta = pickResponsesStreamTextDelta(json);
+      const reasoningDelta = pickResponsesStreamReasoningDelta(json);
       const chunkUsage = pickResponsesStreamUsage(json);
       const chunkFinishReason = pickResponsesStreamFinishReason(json);
       collectResponsesStreamToolCalls(json, streamedToolCalls);
@@ -2174,9 +2264,14 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
         roundText += delta;
         callbacks.onToken?.(delta);
       }
-      if (delta || chunkUsage || chunkFinishReason) {
+      if (reasoningDelta) {
+        roundReasoning += reasoningDelta;
+      }
+      if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
         const chunk = {
           textDelta: delta,
+          reasoningDelta: reasoningDelta || undefined,
+          turnIndex: round,
           raw: json,
           usage: chunkUsage,
           finishReason: chunkFinishReason
@@ -2192,25 +2287,48 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
       finishReason = pickResponsesFinishReason(roundPayload) ?? finishReason;
     }
     const payloadToolCalls = roundPayload ? pickResponsesToolCalls(roundPayload) : [];
+    if (roundPayload && roundReasoning.length === 0) {
+      roundReasoning = pickResponsesReasoning(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");
+    pushReasoningBlock(reasoningBlocks, round, roundReasoning);
+    request.onTurnTransition?.({
+      turnIndex: round,
+      kind: "reasoningComplete",
+      reasoningText: roundReasoning
+    });
     if (functionCalls.length === 0) {
       const finalText = roundText.length > 0 ? roundText : roundPayload ? pickResponsesText(roundPayload) || pickAssistantText(roundPayload) : "";
       const out2 = {
         text: finalText,
+        reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
         raw: roundPayload ?? lastPayload,
         usage: aggregatedUsage,
         finishReason,
         toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
         toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
       };
+      request.onTurnTransition?.({ turnIndex: round, kind: "streamEnd" });
       callbacks.onComplete?.(out2);
       return out2;
     }
     if (round > maxToolRounds) {
       throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
     }
+    request.onTurnTransition?.({
+      turnIndex: round,
+      kind: "toolCallsEmit",
+      toolCalls: functionCalls
+    });
+    callbacks.onChunk?.({
+      textDelta: "",
+      turnIndex: round,
+      toolCalls: functionCalls,
+      finishReason: roundFinishReason
+    });
     const outputs = await executeMCPToolCalls(functionCalls, mcpToolset, {
       round,
       request,
@@ -2219,6 +2337,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
     });
     executedToolCalls.push(...outputs.map((entry) => entry.call));
     toolExecutions.push(...outputs.map((entry) => entry.execution));
+    request.onTurnTransition?.({ turnIndex: round, kind: "toolResultsReceived" });
     input = outputs.map((entry) => ({
       type: "function_call_output",
       call_id: entry.call.id,
@@ -2228,12 +2347,15 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
   }
   const out = {
     text: pickResponsesText(lastPayload ?? {}) || pickAssistantText(lastPayload ?? {}),
+    reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
+    reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
     toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
     toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
   };
+  request.onTurnTransition?.({ turnIndex: maxToolRounds + 1, kind: "streamEnd" });
   callbacks.onComplete?.(out);
   return out;
 }
@@ -2518,6 +2640,20 @@ function pickResponsesStreamTextDelta(payload) {
   }
   return "";
 }
+function pickResponsesStreamReasoningDelta(payload) {
+  const eventType = pickString(payload.type) ?? "";
+  if (!eventType.includes("reasoning") && !eventType.includes("thinking")) {
+    return "";
+  }
+  const direct = pickString(payload.delta);
+  if (direct) {
+    return direct;
+  }
+  if (isRecord2(payload.delta)) {
+    return pickReasoningText(payload.delta) || pickString(payload.delta.text) || pickString(payload.delta.summary_text) || "";
+  }
+  return "";
+}
 function pickResponsesStreamUsage(payload) {
   const direct = pickUsage(payload);
   if (direct) {
@@ -2652,6 +2788,30 @@ function pickResponsesText(payload) {
     }).join("");
   }).join("");
 }
+function pickResponsesReasoning(payload) {
+  const direct = pickReasoningText(payload);
+  if (direct) {
+    return direct;
+  }
+  const output = payload.output;
+  if (!Array.isArray(output)) {
+    return "";
+  }
+  return output.map((item) => {
+    if (!isRecord2(item)) {
+      return "";
+    }
+    const itemReasoning = pickReasoningText(item);
+    if (itemReasoning) {
+      return itemReasoning;
+    }
+    const itemType = pickString(item.type) ?? "";
+    if ((itemType.includes("reasoning") || itemType.includes("thinking")) && Array.isArray(item.content)) {
+      return item.content.map((part) => isRecord2(part) ? pickTextLike(part) : "").join("");
+    }
+    return "";
+  }).join("");
+}
 function pickAssistantText(payload) {
   const message = pickAssistantMessage(payload);
   if (message) {
@@ -2672,6 +2832,18 @@ function pickAssistantText(payload) {
 function pickReasoningText(value) {
   return pickTextLike(value.reasoning) || pickTextLike(value.reasoning_content);
 }
+function pushReasoningBlock(blocks, turnIndex, text) {
+  const clean = text?.replace(/<\/?think\s*>/gi, "").trim();
+  if (!clean) {
+    return;
+  }
+  blocks.push({ turnIndex, text: clean });
+}
+function joinReasoningBlocks(blocks) {
+  return blocks.map((block) => block.text).filter(Boolean).join(`
+
+`);
+}
 function pickTextFromOpenAIContent(value) {
   return pickTextLike(value);
 }
@@ -2852,6 +3024,7 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
   let lastPayload;
   const toolCalls = [];
   const toolExecutions = [];
+  const reasoningBlocks = [];
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
     const tools = toAnthropicTools(toProviderFunctionTools(mcpToolset));
@@ -2881,9 +3054,12 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
     finishReason = pickFinishReason2(payload);
     const content = Array.isArray(payload.content) ? payload.content : [];
     const calledTools = pickAnthropicToolCalls(payload).filter((call) => call.type === "function");
+    pushReasoningBlock2(reasoningBlocks, round, extractAnthropicReasoning(payload));
     if (calledTools.length === 0) {
       return {
         text: extractAnthropicText(payload),
+        reasoning: joinReasoningBlocks2(reasoningBlocks) || undefined,
+        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
         raw: payload,
         usage: aggregatedUsage,
         finishReason,
@@ -2919,6 +3095,8 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
   }
   return {
     text: extractAnthropicText(lastPayload ?? {}),
+    reasoning: joinReasoningBlocks2(reasoningBlocks) || undefined,
+    reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
@@ -2935,6 +3113,7 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
   let lastPayload;
   const toolCalls = [];
   const toolExecutions = [];
+  const reasoningBlocks = [];
   callbacks.onStart?.();
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
@@ -2960,6 +3139,7 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
       throw new Error(`HTTP ${response.status}: ${message}`);
     }
     let roundText = "";
+    let roundReasoning = "";
     let roundUsage;
     let roundFinishReason;
     const streamedToolCalls = new Map;
@@ -2973,6 +3153,7 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
       }
       lastPayload = json;
       const delta = pickAnthropicDelta(json);
+      const reasoningDelta = pickAnthropicReasoningDelta(json);
       const chunkUsage = pickUsage2(json);
       const chunkFinishReason = pickFinishReason2(json);
       collectAnthropicStreamToolCalls(json, streamedToolCalls);
@@ -2984,9 +3165,14 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
         roundText += delta;
         callbacks.onToken?.(delta);
       }
-      if (delta || chunkUsage || chunkFinishReason) {
+      if (reasoningDelta) {
+        roundReasoning += reasoningDelta;
+      }
+      if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
         const chunk = {
           textDelta: delta,
+          reasoningDelta: reasoningDelta || undefined,
+          turnIndex: round,
           raw: json,
           usage: chunkUsage,
           finishReason: chunkFinishReason
@@ -2999,21 +3185,41 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
       finishReason = roundFinishReason;
     }
     const calledTools = buildAnthropicStreamToolCalls(streamedToolCalls);
+    pushReasoningBlock2(reasoningBlocks, round, roundReasoning);
+    request.onTurnTransition?.({
+      turnIndex: round,
+      kind: "reasoningComplete",
+      reasoningText: roundReasoning
+    });
     if (calledTools.length === 0) {
       const out2 = {
         text: roundText,
+        reasoning: joinReasoningBlocks2(reasoningBlocks) || undefined,
+        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
         raw: lastPayload,
         usage: aggregatedUsage,
         finishReason,
         toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
         toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
       };
+      request.onTurnTransition?.({ turnIndex: round, kind: "streamEnd" });
       callbacks.onComplete?.(out2);
       return out2;
     }
     if (round > maxToolRounds) {
       throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
     }
+    request.onTurnTransition?.({
+      turnIndex: round,
+      kind: "toolCallsEmit",
+      toolCalls: calledTools
+    });
+    callbacks.onChunk?.({
+      textDelta: "",
+      turnIndex: round,
+      toolCalls: calledTools,
+      finishReason: roundFinishReason
+    });
     const toolResultContent = [];
     const outputs = await executeMCPToolCalls(calledTools, mcpToolset, {
       round,
@@ -3023,6 +3229,7 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
     });
     toolCalls.push(...outputs.map((entry) => entry.call));
     toolExecutions.push(...outputs.map((entry) => entry.execution));
+    request.onTurnTransition?.({ turnIndex: round, kind: "toolResultsReceived" });
     for (const entry of outputs) {
       toolResultContent.push({
         type: "tool_result",
@@ -3039,12 +3246,15 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
   }
   const out = {
     text: "",
+    reasoning: joinReasoningBlocks2(reasoningBlocks) || undefined,
+    reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
     toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
     toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
   };
+  request.onTurnTransition?.({ turnIndex: maxToolRounds + 1, kind: "streamEnd" });
   callbacks.onComplete?.(out);
   return out;
 }
@@ -3165,6 +3375,22 @@ function extractAnthropicText(payload) {
     return typeof text === "string" ? text : "";
   }).join("");
 }
+function extractAnthropicReasoning(payload) {
+  const content = payload.content;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => {
+    if (!isRecord2(part)) {
+      return "";
+    }
+    const type = pickString(part.type) ?? "";
+    if (type !== "thinking" && type !== "reasoning") {
+      return "";
+    }
+    return pickString(part.thinking) ?? pickString(part.text) ?? pickString(part.reasoning) ?? "";
+  }).join("");
+}
 function pickAnthropicToolCalls(payload) {
   const content = payload.content;
   if (!Array.isArray(content)) {
@@ -3195,6 +3421,35 @@ function pickAnthropicDelta(payload) {
   }
   return "";
 }
+function pickAnthropicReasoningDelta(payload) {
+  const deltaObject = payload.delta;
+  if (isRecord2(deltaObject)) {
+    const type = pickString(deltaObject.type) ?? "";
+    if (type === "thinking_delta" || type === "reasoning_delta") {
+      return pickString(deltaObject.thinking) ?? pickString(deltaObject.text) ?? "";
+    }
+  }
+  const contentBlock = payload.content_block;
+  if (isRecord2(contentBlock)) {
+    const type = pickString(contentBlock.type) ?? "";
+    if (type === "thinking" || type === "reasoning") {
+      return pickString(contentBlock.thinking) ?? pickString(contentBlock.text) ?? "";
+    }
+  }
+  return "";
+}
+function pushReasoningBlock2(blocks, turnIndex, text) {
+  const clean = text?.replace(/<\/?think\s*>/gi, "").trim();
+  if (!clean) {
+    return;
+  }
+  blocks.push({ turnIndex, text: clean });
+}
+function joinReasoningBlocks2(blocks) {
+  return blocks.map((block) => block.text).filter(Boolean).join(`
+
+`);
+}
 function collectAnthropicStreamToolCalls(payload, state) {
   const eventType = pickString(payload.type);
   if (!eventType) {
@@ -3668,6 +3923,7 @@ function normalizeStreamConfig(option) {
   return {
     enabled: option.enabled ?? true,
     onData: option.onData,
+    onTurnTransition: option.onTurnTransition,
     to: option.to
   };
 }
@@ -3735,6 +3991,7 @@ async function callModel(adapter, options) {
     transformToolCallParams: options.request?.transformToolCallParams,
     unknownToolError: options.request?.unknownToolError,
     toolDebug: options.request?.toolDebug,
+    onTurnTransition: options.stream.onTurnTransition,
     body: options.request?.body,
     signal: requestSignal
   };
@@ -3762,13 +4019,21 @@ async function callModel(adapter, options) {
     let latestFinishReason;
     let streamedProviderText = "";
     let streamedDedicatedReasoning = "";
+    let currentTurnIndex;
+    let currentToolCalls;
+    let streamedReasoningBlocks;
     let lastSnapshotFingerprint;
     let previousSnapshotText = "";
     let previousSnapshotReasoning = "";
     const emitStreamingData = (done, usage2, finishReason2) => {
-      const normalized2 = normalizeModelOutput(streamedProviderText, streamedDedicatedReasoning);
+      const normalized2 = normalizeModelOutput(streamedProviderText, streamedDedicatedReasoning, streamedReasoningBlocks);
       const snapshot = options.buildSnapshot(normalized2);
-      const fingerprint = toStreamDataFingerprint(snapshot);
+      const fingerprint = toStreamDataFingerprint({
+        snapshot,
+        done,
+        turnIndex: currentTurnIndex,
+        toolCalls: currentToolCalls
+      });
       if (!done && fingerprint === lastSnapshotFingerprint) {
         return;
       }
@@ -3784,7 +4049,9 @@ async function callModel(adapter, options) {
         snapshot,
         done,
         usage: usage2,
-        finishReason: finishReason2
+        finishReason: finishReason2,
+        turnIndex: currentTurnIndex,
+        toolCalls: currentToolCalls
       });
       if (options.stream.to === "stdout" && delta.text) {
         process.stdout.write(delta.text);
@@ -3819,8 +4086,21 @@ async function callModel(adapter, options) {
       streamedDedicatedReasoning += delta;
       emitStreamingData(false);
     };
-    const response2 = await adapter.stream(requestPayload, {
+    const streamRequestPayload = {
+      ...requestPayload,
+      onTurnTransition: (transition) => {
+        if (transition.kind === "reasoningComplete") {
+          streamedReasoningBlocks = appendReasoningBlock(streamedReasoningBlocks, transition);
+        }
+        options.stream.onTurnTransition?.(transition);
+      }
+    };
+    const response2 = await adapter.stream(streamRequestPayload, {
       onChunk: (chunk) => {
+        if (chunk.turnIndex !== undefined) {
+          currentTurnIndex = chunk.turnIndex;
+        }
+        currentToolCalls = chunk.toolCalls;
         if (chunk.textDelta) {
           handleTextDelta(chunk.textDelta);
         }
@@ -3833,11 +4113,15 @@ async function callModel(adapter, options) {
         if (chunk.finishReason) {
           latestFinishReason = chunk.finishReason;
         }
+        if (!chunk.textDelta && !chunk.reasoningDelta && (chunk.turnIndex !== undefined || chunk.toolCalls)) {
+          emitStreamingData(false, chunk.usage, chunk.finishReason);
+        }
       }
     });
     streamedProviderText = typeof response2.text === "string" ? response2.text : streamedProviderText;
     streamedDedicatedReasoning = typeof response2.reasoning === "string" ? response2.reasoning : streamedDedicatedReasoning;
-    const finalNormalized = normalizeModelOutput(streamedProviderText, streamedDedicatedReasoning);
+    streamedReasoningBlocks = response2.reasoningBlocks ?? streamedReasoningBlocks;
+    const finalNormalized = normalizeModelOutput(streamedProviderText, streamedDedicatedReasoning, streamedReasoningBlocks);
     const usage = preferLatestUsage(latestUsage, response2.usage);
     const finishReason = response2.finishReason ?? latestFinishReason;
     emitStreamingData(true, usage, finishReason);
@@ -3869,11 +4153,12 @@ async function callModel(adapter, options) {
       parseSource: finalNormalized.parseSource,
       via: "stream",
       usage,
-      finishReason
+      finishReason,
+      reasoningBlocks: finalNormalized.reasoningBlocks
     };
   }
   const response = await adapter.complete(requestPayload);
-  const normalized = normalizeModelOutput(response.text, response.reasoning);
+  const normalized = normalizeModelOutput(response.text, response.reasoning, response.reasoningBlocks);
   options.observe?.(options.buildEvent({
     stage: "llm.response",
     message: "Completion response received.",
@@ -3902,10 +4187,11 @@ async function callModel(adapter, options) {
     parseSource: normalized.parseSource,
     via: "complete",
     usage: response.usage,
-    finishReason: response.finishReason
+    finishReason: response.finishReason,
+    reasoningBlocks: normalized.reasoningBlocks
   };
 }
-function normalizeModelOutput(text, dedicatedReasoning) {
+function normalizeModelOutput(text, dedicatedReasoning, reasoningBlocks) {
   const sanitized = sanitizeThink(text);
   const visibleText = stripThinkBlocks(text, sanitized.thinkBlocks);
   const reasoning = joinReasoningSegments([
@@ -3915,10 +4201,29 @@ function normalizeModelOutput(text, dedicatedReasoning) {
   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;
@@ -4078,7 +4383,8 @@ async function generate(adapter, promptOrOptions, callOptions) {
     }),
     buildSnapshot: (model) => ({
       text: model.text,
-      reasoning: model.reasoning
+      reasoning: model.reasoning,
+      ...model.reasoningBlocks ? { reasoningBlocks: model.reasoningBlocks } : {}
     }),
     debug: debugConfig,
     debugLabel: "generate",
@@ -4093,7 +4399,8 @@ async function generate(adapter, promptOrOptions, callOptions) {
     text: response.text,
     reasoning: response.reasoning,
     usage: response.usage,
-    finishReason: response.finishReason
+    finishReason: response.finishReason,
+    ...response.reasoningBlocks ? { reasoningBlocks: response.reasoningBlocks } : {}
   };
   const attempts = [attempt];
   normalized.observe?.({
@@ -4110,7 +4417,8 @@ async function generate(adapter, promptOrOptions, callOptions) {
     reasoning: attempt.reasoning,
     attempts,
     usage: aggregateUsage(attempts),
-    finishReason: attempt.finishReason
+    finishReason: attempt.finishReason,
+    ...attempt.reasoningBlocks ? { reasoningBlocks: attempt.reasoningBlocks } : {}
   };
 }
 function normalizeGenerateInput(promptOrOptions, callOptions) {
@@ -4930,6 +5238,7 @@ async function executeAttempt(adapter, input) {
     success: parsed.success,
     usage: response.usage,
     finishReason: response.finishReason,
+    ...response.reasoningBlocks ? { reasoningBlocks: response.reasoningBlocks } : {},
     parsed
   };
   return {
@@ -4950,6 +5259,7 @@ async function callModel2(adapter, options) {
     buildSnapshot: (normalized) => ({
       text: normalized.text,
       reasoning: normalized.reasoning,
+      ...normalized.reasoningBlocks ? { reasoningBlocks: normalized.reasoningBlocks } : {},
       data: parseStreamingStructuredData(normalized.parseSource) ?? null
     }),
     debugLabel: "structured"
@@ -5050,7 +5360,8 @@ function buildSuccessResult(data, attempts) {
     json: final?.json ?? null,
     attempts,
     usage: aggregateUsage(attempts),
-    finishReason: final?.finishReason
+    finishReason: final?.finishReason,
+    ...final?.reasoningBlocks ? { reasoningBlocks: final.reasoningBlocks } : {}
   };
 }
 function toStructuredError(attempt) {
@@ -5517,11 +5828,11 @@ function inferSchemaExample(schema) {
 }
 function getObjectShape(schema) {
   const unwrapped = unwrap2(schema).schema;
-  const typeName = unwrapped._def?.type;
+  const typeName = unwrapped.def?.type;
   if (typeName !== "object") {
     return null;
   }
-  const rawShape = unwrapped._def?.shape;
+  const rawShape = unwrapped.def?.shape;
   if (typeof rawShape === "function") {
     return rawShape();
   }
@@ -5529,11 +5840,11 @@ function getObjectShape(schema) {
 }
 function readDefaultValue(schema) {
   let current = schema;
-  while (current?._def?.type) {
-    const typeName = current._def.type;
+  while (current?.def?.type) {
+    const typeName = current.def.type;
     if (typeName === "default") {
       try {
-        const raw = current._def.defaultValue;
+        const raw = current.def.defaultValue;
         if (typeof raw === "function") {
           return raw();
         }
@@ -5543,11 +5854,11 @@ function readDefaultValue(schema) {
       }
     }
     if (typeName === "optional" || typeName === "nullable" || typeName === "catch" || typeName === "readonly") {
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     if (typeName === "pipe") {
-      current = current._def.in ?? current;
+      current = current.def.in ?? current;
       continue;
     }
     return;
@@ -5556,22 +5867,22 @@ function readDefaultValue(schema) {
 }
 function readSchemaDescription2(schema) {
   let current = schema;
-  while (current?._def?.type) {
+  while (current?.def?.type) {
     const desc = current.description;
     if (typeof desc === "string" && desc.trim().length > 0) {
       return desc.trim();
     }
-    const typeName = current._def.type;
+    const typeName = current.def.type;
     if (typeName === "optional" || typeName === "default" || typeName === "nullable") {
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     if (typeName === "catch" || typeName === "readonly") {
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     if (typeName === "pipe") {
-      current = current._def.in ?? current;
+      current = current.def.in ?? current;
       continue;
     }
     break;
@@ -5581,19 +5892,19 @@ function readSchemaDescription2(schema) {
 function unwrap2(schema) {
   let current = schema;
   let optional = false;
-  while (current?._def?.type) {
-    const typeName = current._def.type;
+  while (current?.def?.type) {
+    const typeName = current.def.type;
     if (typeName === "optional" || typeName === "default") {
       optional = true;
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     if (typeName === "nullable" || typeName === "catch" || typeName === "readonly") {
-      current = current._def.innerType ?? current;
+      current = current.def.innerType ?? current;
       continue;
     }
     if (typeName === "pipe") {
-      current = current._def.in ?? current;
+      current = current.def.in ?? current;
       continue;
     }
     break;