extrait 0.6.1 → 0.7.1

package/dist/index.js

@@ -1,9 +1,6 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/extract.ts
-import { jsonrepair } from "jsonrepair";
-
 // src/utils/common.ts
 function toErrorMessage(error) {
   if (error instanceof Error) {
@@ -221,184 +218,77 @@ function isOnlyWhitespace(value) {
   return true;
 }
 
-// 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,
-  firstPassMultiplier: 6,
-  secondPassMin: 4,
-  secondPassCap: 8,
-  secondPassMultiplier: 2,
-  hintMaxLength: 50000
-};
-function extractJsonCandidates(input, options = {}) {
-  const maxCandidates = options.maxCandidates ?? 5;
-  const acceptArrays = options.acceptArrays ?? true;
-  const allowRepairHints = options.allowRepairHints ?? true;
-  const heuristics = resolveExtractionHeuristics(options.heuristics);
-  const extractionInput = input;
-  const candidates = [];
-  candidates.push(...extractFromMarkdown(extractionInput, acceptArrays));
-  candidates.push(...scanBalancedSegments(extractionInput, acceptArrays));
-  if (candidates.length === 0 && extractionInput.trim()) {
-    const content = extractionInput.trim();
-    candidates.push({
-      id: "raw:fallback",
-      source: "raw",
-      content,
-      start: 0,
-      end: extractionInput.length,
-      score: 10 + Math.floor(lengthScore(content.length) / 3)
-    });
-  }
-  const prefiltered = prefilterByJsonShape(candidates, acceptArrays);
-  const firstPassLimit = clamp(maxCandidates * heuristics.firstPassMultiplier, heuristics.firstPassMin, heuristics.firstPassCap);
-  const firstPass = prefiltered.slice(0, firstPassLimit);
-  const secondPassLimit = Math.min(firstPass.length, clamp(maxCandidates * heuristics.secondPassMultiplier, heuristics.secondPassMin, heuristics.secondPassCap));
-  for (let i = 0;i < secondPassLimit; i += 1) {
-    const candidate = firstPass[i];
-    if (!candidate) {
-      continue;
-    }
-    const parseHint = buildParseHint(candidate.content, allowRepairHints, heuristics.hintMaxLength);
-    if (!parseHint) {
-      continue;
-    }
-    candidate.parseHint = parseHint;
-    candidate.score += parseHintBonus(parseHint);
+// src/extract-parse-hint.ts
+import { jsonrepair } from "jsonrepair";
+function buildParseHint(content, allowRepair, hintMaxLength) {
+  if (content.length > hintMaxLength) {
+    return null;
   }
-  const sorted = sortCandidates(firstPass);
-  const deduped = dedupeCandidates(sorted);
-  return deduped.slice(0, maxCandidates).map((candidate, index) => ({
-    id: `${candidate.source}:${index}`,
-    source: candidate.source,
-    content: candidate.content,
-    language: candidate.language,
-    parseHint: candidate.parseHint,
-    start: candidate.start,
-    end: candidate.end,
-    score: candidate.score
-  }));
-}
-function prefilterByJsonShape(candidates, acceptArrays) {
-  const shaped = candidates.map((candidate) => {
-    const shapeScore = jsonShapeScore(candidate.content, acceptArrays);
+  try {
     return {
-      ...candidate,
-      shapeScore,
-      score: candidate.score + shapeScore
+      success: true,
+      parsed: JSON.parse(content),
+      repaired: null,
+      usedRepair: false,
+      stage: "parse",
+      error: ""
     };
-  });
-  const sorted = sortCandidates(shaped);
-  const deduped = dedupeCandidates(sorted);
-  const filtered = deduped.filter((candidate) => passesShapeFilter(candidate));
-  if (filtered.length > 0) {
-    const fallback = deduped.find((candidate) => !passesShapeFilter(candidate));
-    if (fallback) {
-      filtered.push(fallback);
+  } catch (directError) {
+    if (!allowRepair) {
+      return {
+        success: false,
+        parsed: null,
+        repaired: null,
+        usedRepair: false,
+        stage: "parse",
+        error: toErrorMessage(directError)
+      };
     }
-    return sortCandidates(filtered);
-  }
-  return deduped.slice(0, Math.min(1, deduped.length));
-}
-function extractFromMarkdown(input, acceptArrays) {
-  const blocks = extractMarkdownCodeBlocks(input);
-  return blocks.flatMap((block, index) => {
-    const language = block.language || null;
-    const content = block.code.trim();
-    if (!content) {
-      return [];
+    let repaired;
+    try {
+      repaired = jsonrepair(content);
+    } catch (repairError) {
+      return {
+        success: false,
+        parsed: null,
+        repaired: null,
+        usedRepair: true,
+        stage: "repair",
+        error: toErrorMessage(repairError)
+      };
     }
-    if (!looksLikeJsonEnvelope(content, acceptArrays)) {
-      return [];
+    try {
+      return {
+        success: true,
+        parsed: JSON.parse(repaired),
+        repaired,
+        usedRepair: true,
+        stage: "parse",
+        error: ""
+      };
+    } catch (parseError) {
+      return {
+        success: false,
+        parsed: null,
+        repaired,
+        usedRepair: true,
+        stage: "parse",
+        error: toErrorMessage(parseError || directError)
+      };
     }
-    const langBonus = languageBonus(language);
-    return [
-      {
-        id: `fenced:${index}`,
-        source: "fenced",
-        language,
-        content,
-        start: block.start,
-        end: block.end,
-        score: 260 + langBonus + lengthScore(content.length)
-      }
-    ];
-  });
+  }
 }
-function scanBalancedSegments(input, acceptArrays) {
-  const results = [];
-  const stack = [];
-  let inString = false;
-  let quote = null;
-  let escaped = false;
-  for (let i = 0;i < input.length; i += 1) {
-    const char = input[i];
-    if (!char) {
-      continue;
-    }
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (char === "\\") {
-        escaped = true;
-        continue;
-      }
-      if (char === quote) {
-        inString = false;
-        quote = null;
-      }
-      continue;
-    }
-    const allowSingleQuoted = stack.length > 0;
-    if (char === '"' || allowSingleQuoted && (char === "'" || char === "`")) {
-      inString = true;
-      quote = char;
-      continue;
-    }
-    if (char === "{" || char === "[") {
-      stack.push({ char, index: i });
-      continue;
-    }
-    if (char !== "}" && char !== "]") {
-      continue;
-    }
-    const expectedOpen = char === "}" ? "{" : "[";
-    while (stack.length > 0 && stack[stack.length - 1]?.char !== expectedOpen) {
-      stack.pop();
-    }
-    const opened = stack.pop();
-    if (!opened) {
-      continue;
-    }
-    if (stack.length > 0) {
-      continue;
-    }
-    if (!acceptArrays && opened.char === "[") {
-      continue;
-    }
-    const content = input.slice(opened.index, i + 1).trim();
-    if (!content) {
-      continue;
-    }
-    const rootBonus = opened.char === "{" ? 40 : 20;
-    const boundaryBonus = boundaryScore(input, opened.index, i + 1);
-    results.push({
-      id: `scan:${results.length}`,
-      source: "scan",
-      content,
-      start: opened.index,
-      end: i + 1,
-      score: 120 + rootBonus + boundaryBonus + lengthScore(content.length)
-    });
+function parseHintBonus(hint) {
+  if (hint.success) {
+    return hint.usedRepair ? 70 : 120;
   }
-  return results;
+  return hint.usedRepair ? -20 : -10;
 }
+
+// src/extract-shape.ts
+var RE_EMPTY_OBJECT = /^\{\s*\}$/;
+var RE_EMPTY_ARRAY = /^\[\s*\]$/;
+var RE_BOUNDARY_CHAR = /[\s,.;:!?`"'()[\]{}<>]/;
 function looksLikeJsonEnvelope(content, acceptArrays) {
   const trimmed = content.trim();
   if (trimmed.startsWith("{")) {
@@ -507,95 +397,6 @@ function passesShapeFilter(candidate) {
   }
   return candidate.shapeScore >= 35;
 }
-function buildParseHint(content, allowRepair, hintMaxLength) {
-  if (content.length > hintMaxLength) {
-    return null;
-  }
-  try {
-    return {
-      success: true,
-      parsed: JSON.parse(content),
-      repaired: null,
-      usedRepair: false,
-      stage: "parse",
-      error: ""
-    };
-  } catch (directError) {
-    if (!allowRepair) {
-      return {
-        success: false,
-        parsed: null,
-        repaired: null,
-        usedRepair: false,
-        stage: "parse",
-        error: toErrorMessage(directError)
-      };
-    }
-    let repaired;
-    try {
-      repaired = jsonrepair(content);
-    } catch (repairError) {
-      return {
-        success: false,
-        parsed: null,
-        repaired: null,
-        usedRepair: true,
-        stage: "repair",
-        error: toErrorMessage(repairError)
-      };
-    }
-    try {
-      return {
-        success: true,
-        parsed: JSON.parse(repaired),
-        repaired,
-        usedRepair: true,
-        stage: "parse",
-        error: ""
-      };
-    } catch (parseError) {
-      return {
-        success: false,
-        parsed: null,
-        repaired,
-        usedRepair: true,
-        stage: "parse",
-        error: toErrorMessage(parseError || directError)
-      };
-    }
-  }
-}
-function resolveExtractionHeuristics(input) {
-  const merged = {
-    ...DEFAULT_EXTRACTION_HEURISTICS,
-    ...input
-  };
-  const firstPassMin = normalizeInteger(merged.firstPassMin, DEFAULT_EXTRACTION_HEURISTICS.firstPassMin);
-  const firstPassCap = Math.max(firstPassMin, normalizeInteger(merged.firstPassCap, DEFAULT_EXTRACTION_HEURISTICS.firstPassCap));
-  const secondPassMin = normalizeInteger(merged.secondPassMin, DEFAULT_EXTRACTION_HEURISTICS.secondPassMin);
-  const secondPassCap = Math.max(secondPassMin, normalizeInteger(merged.secondPassCap, DEFAULT_EXTRACTION_HEURISTICS.secondPassCap));
-  return {
-    firstPassMin,
-    firstPassCap,
-    firstPassMultiplier: normalizeInteger(merged.firstPassMultiplier, DEFAULT_EXTRACTION_HEURISTICS.firstPassMultiplier),
-    secondPassMin,
-    secondPassCap,
-    secondPassMultiplier: normalizeInteger(merged.secondPassMultiplier, DEFAULT_EXTRACTION_HEURISTICS.secondPassMultiplier),
-    hintMaxLength: normalizeInteger(merged.hintMaxLength, DEFAULT_EXTRACTION_HEURISTICS.hintMaxLength)
-  };
-}
-function normalizeInteger(value, fallback) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return fallback;
-  }
-  return Math.max(0, Math.floor(value));
-}
-function parseHintBonus(hint) {
-  if (hint.success) {
-    return hint.usedRepair ? 70 : 120;
-  }
-  return hint.usedRepair ? -20 : -10;
-}
 function hasBalancedJsonDelimiters(input) {
   const stack = [];
   let inString = false;
@@ -681,6 +482,207 @@ function dedupeCandidates(candidates) {
 function clamp(value, min, max) {
   return Math.max(min, Math.min(max, Math.floor(value)));
 }
+function normalizeInteger(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function resolveExtractionHeuristics(input, defaults) {
+  const merged = {
+    ...defaults,
+    ...input
+  };
+  const firstPassMin = normalizeInteger(merged.firstPassMin, defaults.firstPassMin);
+  const firstPassCap = Math.max(firstPassMin, normalizeInteger(merged.firstPassCap, defaults.firstPassCap));
+  const secondPassMin = normalizeInteger(merged.secondPassMin, defaults.secondPassMin);
+  const secondPassCap = Math.max(secondPassMin, normalizeInteger(merged.secondPassCap, defaults.secondPassCap));
+  return {
+    firstPassMin,
+    firstPassCap,
+    firstPassMultiplier: normalizeInteger(merged.firstPassMultiplier, defaults.firstPassMultiplier),
+    secondPassMin,
+    secondPassCap,
+    secondPassMultiplier: normalizeInteger(merged.secondPassMultiplier, defaults.secondPassMultiplier),
+    hintMaxLength: normalizeInteger(merged.hintMaxLength, defaults.hintMaxLength)
+  };
+}
+
+// src/extract.ts
+var DEFAULT_EXTRACTION_HEURISTICS = {
+  firstPassMin: 12,
+  firstPassCap: 30,
+  firstPassMultiplier: 6,
+  secondPassMin: 4,
+  secondPassCap: 8,
+  secondPassMultiplier: 2,
+  hintMaxLength: 50000
+};
+function extractJsonCandidates(input, options = {}) {
+  const maxCandidates = options.maxCandidates ?? 5;
+  const acceptArrays = options.acceptArrays ?? true;
+  const allowRepairHints = options.allowRepairHints ?? true;
+  const heuristics = resolveExtractionHeuristics(options.heuristics, DEFAULT_EXTRACTION_HEURISTICS);
+  const extractionInput = input;
+  const candidates = [];
+  candidates.push(...extractFromMarkdown(extractionInput, acceptArrays));
+  candidates.push(...scanBalancedSegments(extractionInput, acceptArrays));
+  if (candidates.length === 0 && extractionInput.trim()) {
+    const content = extractionInput.trim();
+    candidates.push({
+      id: "raw:fallback",
+      source: "raw",
+      content,
+      start: 0,
+      end: extractionInput.length,
+      score: 10 + Math.floor(lengthScore(content.length) / 3)
+    });
+  }
+  const prefiltered = prefilterByJsonShape(candidates, acceptArrays);
+  const firstPassLimit = clamp(maxCandidates * heuristics.firstPassMultiplier, heuristics.firstPassMin, heuristics.firstPassCap);
+  const firstPass = prefiltered.slice(0, firstPassLimit);
+  const secondPassLimit = Math.min(firstPass.length, clamp(maxCandidates * heuristics.secondPassMultiplier, heuristics.secondPassMin, heuristics.secondPassCap));
+  for (let i = 0;i < secondPassLimit; i += 1) {
+    const candidate = firstPass[i];
+    if (!candidate) {
+      continue;
+    }
+    const parseHint = buildParseHint(candidate.content, allowRepairHints, heuristics.hintMaxLength);
+    if (!parseHint) {
+      continue;
+    }
+    candidate.parseHint = parseHint;
+    candidate.score += parseHintBonus(parseHint);
+  }
+  const sorted = sortCandidates(firstPass);
+  const deduped = dedupeCandidates(sorted);
+  return deduped.slice(0, maxCandidates).map((candidate, index) => ({
+    id: `${candidate.source}:${index}`,
+    source: candidate.source,
+    content: candidate.content,
+    language: candidate.language,
+    parseHint: candidate.parseHint,
+    start: candidate.start,
+    end: candidate.end,
+    score: candidate.score
+  }));
+}
+function prefilterByJsonShape(candidates, acceptArrays) {
+  const shaped = candidates.map((candidate) => {
+    const shapeScore = jsonShapeScore(candidate.content, acceptArrays);
+    return {
+      ...candidate,
+      shapeScore,
+      score: candidate.score + shapeScore
+    };
+  });
+  const sorted = sortCandidates(shaped);
+  const deduped = dedupeCandidates(sorted);
+  const filtered = deduped.filter((candidate) => passesShapeFilter(candidate));
+  if (filtered.length > 0) {
+    const fallback = deduped.find((candidate) => !passesShapeFilter(candidate));
+    if (fallback) {
+      filtered.push(fallback);
+    }
+    return sortCandidates(filtered);
+  }
+  return deduped.slice(0, Math.min(1, deduped.length));
+}
+function extractFromMarkdown(input, acceptArrays) {
+  const blocks = extractMarkdownCodeBlocks(input);
+  return blocks.flatMap((block, index) => {
+    const language = block.language || null;
+    const content = block.code.trim();
+    if (!content) {
+      return [];
+    }
+    if (!looksLikeJsonEnvelope(content, acceptArrays)) {
+      return [];
+    }
+    const langBonus = languageBonus(language);
+    return [
+      {
+        id: `fenced:${index}`,
+        source: "fenced",
+        language,
+        content,
+        start: block.start,
+        end: block.end,
+        score: 260 + langBonus + lengthScore(content.length)
+      }
+    ];
+  });
+}
+function scanBalancedSegments(input, acceptArrays) {
+  const results = [];
+  const stack = [];
+  let inString = false;
+  let quote = null;
+  let escaped = false;
+  for (let i = 0;i < input.length; i += 1) {
+    const char = input[i];
+    if (!char) {
+      continue;
+    }
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        inString = false;
+        quote = null;
+      }
+      continue;
+    }
+    const allowSingleQuoted = stack.length > 0;
+    if (char === '"' || allowSingleQuoted && (char === "'" || char === "`")) {
+      inString = true;
+      quote = char;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      stack.push({ char, index: i });
+      continue;
+    }
+    if (char !== "}" && char !== "]") {
+      continue;
+    }
+    const expectedOpen = char === "}" ? "{" : "[";
+    while (stack.length > 0 && stack[stack.length - 1]?.char !== expectedOpen) {
+      stack.pop();
+    }
+    const opened = stack.pop();
+    if (!opened) {
+      continue;
+    }
+    if (stack.length > 0) {
+      continue;
+    }
+    if (!acceptArrays && opened.char === "[") {
+      continue;
+    }
+    const content = input.slice(opened.index, i + 1).trim();
+    if (!content) {
+      continue;
+    }
+    const rootBonus = opened.char === "{" ? 40 : 20;
+    const boundaryBonus = boundaryScore(input, opened.index, i + 1);
+    results.push({
+      id: `scan:${results.length}`,
+      source: "scan",
+      content,
+      start: opened.index,
+      end: i + 1,
+      score: 120 + rootBonus + boundaryBonus + lengthScore(content.length)
+    });
+  }
+  return results;
+}
 // src/schema.ts
 var RE_SIMPLE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var RE_WHITESPACE = /\s+/g;
@@ -700,36 +702,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 +747,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 +772,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 +823,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 +849,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;
@@ -1129,18 +1131,108 @@ function findSSEBoundary(buffer) {
   return Math.max(crlfIndex, lfIndex);
 }
 
-// src/providers/mcp-runtime.ts
-var DEFAULT_MAX_TOOL_ROUNDS = 8;
-async function resolveMCPToolset(clients) {
-  if (!Array.isArray(clients) || clients.length === 0) {
-    return {
-      tools: [],
-      byName: new Map
-    };
-  }
-  const listed = [];
-  for (const client of clients) {
-    let cursor;
+// src/providers/mcp-runtime-debug.ts
+function formatToolExecutionDebugLine(execution) {
+  const status = execution.error ? "error" : "ok";
+  const scope = [execution.provider, execution.model].filter(Boolean).join("/") || "unknown";
+  const toolRef = execution.clientId ? `${execution.clientId}:${execution.name ?? "unknown"}` : execution.name ?? "unknown";
+  const duration = typeof execution.durationMs === "number" ? ` ${execution.durationMs}ms` : "";
+  const base = `[tool:mcp:${status}] ${scope} ${toolRef}#${execution.callId}${duration}`;
+  if (execution.error) {
+    return `${base} -> ${execution.error}`;
+  }
+  return base;
+}
+function emitToolExecution(request, execution) {
+  request.onToolExecution?.(execution);
+  const debug = resolveToolDebugOptions(request.toolDebug);
+  if (!debug.enabled) {
+    return;
+  }
+  debug.logger(formatToolExecutionDebugLine(execution));
+  if (debug.includeRequest) {
+    debug.logger(formatToolExecutionRequestDebugLine(execution, debug));
+  }
+  if (debug.includeResult && (!execution.error || debug.includeResultOnError)) {
+    debug.logger(formatToolExecutionResultDebugLine(execution, debug));
+  }
+}
+function resolveToolDebugOptions(value) {
+  if (value === true) {
+    return {
+      enabled: true,
+      logger: defaultToolDebugLogger,
+      includeRequest: true,
+      includeResult: true,
+      includeResultOnError: true,
+      pretty: false
+    };
+  }
+  if (value === undefined || value === false) {
+    return {
+      enabled: false,
+      logger: () => {
+        return;
+      },
+      includeRequest: false,
+      includeResult: false,
+      includeResultOnError: false,
+      pretty: false
+    };
+  }
+  return {
+    enabled: value.enabled ?? true,
+    logger: value.logger ?? defaultToolDebugLogger,
+    includeRequest: value.includeRequest ?? true,
+    includeResult: value.includeResult ?? true,
+    includeResultOnError: value.includeResultOnError ?? true,
+    pretty: value.pretty ?? false
+  };
+}
+function defaultToolDebugLogger(line) {
+  const { log } = globalThis.console;
+  log(line);
+}
+function formatToolExecutionRequestDebugLine(execution, debug) {
+  const scope = [execution.provider, execution.model].filter(Boolean).join("/") || "unknown";
+  const toolRef = execution.clientId ? `${execution.clientId}:${execution.name ?? "unknown"}` : execution.name ?? "unknown";
+  const payload = formatDebugPayload(execution.arguments, debug.pretty);
+  return `[tool:mcp:request] ${scope} ${toolRef}#${execution.callId} arguments=${payload}`;
+}
+function formatToolExecutionResultDebugLine(execution, debug) {
+  const scope = [execution.provider, execution.model].filter(Boolean).join("/") || "unknown";
+  const toolRef = execution.clientId ? `${execution.clientId}:${execution.name ?? "unknown"}` : execution.name ?? "unknown";
+  if (execution.error) {
+    const payload2 = formatDebugPayload({ error: execution.error }, debug.pretty);
+    return `[tool:mcp:result:error] ${scope} ${toolRef}#${execution.callId} output=${payload2}`;
+  }
+  const payload = formatDebugPayload(execution.output, debug.pretty);
+  return `[tool:mcp:result:ok] ${scope} ${toolRef}#${execution.callId} output=${payload}`;
+}
+function formatDebugPayload(value, pretty) {
+  if (value === undefined) {
+    return "undefined";
+  }
+  try {
+    const serialized = JSON.stringify(value, null, pretty ? 2 : 0);
+    return serialized ?? "undefined";
+  } catch {
+    return String(value);
+  }
+}
+
+// src/providers/mcp-runtime.ts
+var DEFAULT_MAX_TOOL_ROUNDS = 100;
+async function resolveMCPToolset(clients) {
+  if (!Array.isArray(clients) || clients.length === 0) {
+    return {
+      tools: [],
+      byName: new Map
+    };
+  }
+  const listed = [];
+  for (const client of clients) {
+    let cursor;
     do {
       const page = await client.listTools(cursor ? { cursor } : undefined);
       for (const tool of page.tools ?? []) {
@@ -1321,90 +1413,6 @@ function stringifyToolOutput(value) {
   }
   return JSON.stringify(value ?? null);
 }
-function formatToolExecutionDebugLine(execution) {
-  const status = execution.error ? "error" : "ok";
-  const scope = [execution.provider, execution.model].filter(Boolean).join("/") || "unknown";
-  const toolRef = execution.clientId ? `${execution.clientId}:${execution.name ?? "unknown"}` : execution.name ?? "unknown";
-  const duration = typeof execution.durationMs === "number" ? ` ${execution.durationMs}ms` : "";
-  const base = `[tool:mcp:${status}] ${scope} ${toolRef}#${execution.callId}${duration}`;
-  if (execution.error) {
-    return `${base} -> ${execution.error}`;
-  }
-  return base;
-}
-function emitToolExecution(request, execution) {
-  request.onToolExecution?.(execution);
-  const debug = resolveToolDebugOptions(request.toolDebug);
-  if (!debug.enabled) {
-    return;
-  }
-  debug.logger(formatToolExecutionDebugLine(execution));
-  if (debug.includeRequest) {
-    debug.logger(formatToolExecutionRequestDebugLine(execution, debug));
-  }
-  if (debug.includeResult && (!execution.error || debug.includeResultOnError)) {
-    debug.logger(formatToolExecutionResultDebugLine(execution, debug));
-  }
-}
-function resolveToolDebugOptions(value) {
-  if (value === true) {
-    return {
-      enabled: true,
-      logger: (line) => console.log(line),
-      includeRequest: true,
-      includeResult: true,
-      includeResultOnError: true,
-      pretty: false
-    };
-  }
-  if (value === undefined || value === false) {
-    return {
-      enabled: false,
-      logger: () => {
-        return;
-      },
-      includeRequest: false,
-      includeResult: false,
-      includeResultOnError: false,
-      pretty: false
-    };
-  }
-  return {
-    enabled: value.enabled ?? true,
-    logger: value.logger ?? ((line) => console.log(line)),
-    includeRequest: value.includeRequest ?? true,
-    includeResult: value.includeResult ?? true,
-    includeResultOnError: value.includeResultOnError ?? true,
-    pretty: value.pretty ?? false
-  };
-}
-function formatToolExecutionRequestDebugLine(execution, debug) {
-  const scope = [execution.provider, execution.model].filter(Boolean).join("/") || "unknown";
-  const toolRef = execution.clientId ? `${execution.clientId}:${execution.name ?? "unknown"}` : execution.name ?? "unknown";
-  const payload = formatDebugPayload(execution.arguments, debug.pretty);
-  return `[tool:mcp:request] ${scope} ${toolRef}#${execution.callId} arguments=${payload}`;
-}
-function formatToolExecutionResultDebugLine(execution, debug) {
-  const scope = [execution.provider, execution.model].filter(Boolean).join("/") || "unknown";
-  const toolRef = execution.clientId ? `${execution.clientId}:${execution.name ?? "unknown"}` : execution.name ?? "unknown";
-  if (execution.error) {
-    const payload2 = formatDebugPayload({ error: execution.error }, debug.pretty);
-    return `[tool:mcp:result:error] ${scope} ${toolRef}#${execution.callId} output=${payload2}`;
-  }
-  const payload = formatDebugPayload(execution.output, debug.pretty);
-  return `[tool:mcp:result:ok] ${scope} ${toolRef}#${execution.callId} output=${payload}`;
-}
-function formatDebugPayload(value, pretty) {
-  if (value === undefined) {
-    return "undefined";
-  }
-  try {
-    const serialized = JSON.stringify(value, null, pretty ? 2 : 0);
-    return serialized ?? "undefined";
-  } catch {
-    return String(value);
-  }
-}
 function countNameCollisions(names) {
   const out = new Map;
   for (const name of names) {
@@ -1601,103 +1609,89 @@ function createOpenAICompatibleAdapter(options) {
       if (usesMCP) {
         return streamWithChatCompletionsWithMCP(options, fetcher, path, request, callbacks);
       }
-      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: buildMessages(request),
-          temperature: request.temperature,
-          reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-          max_tokens: request.maxTokens,
-          stream: true
-        })),
-        signal: request.signal
-      });
-      if (!response.ok) {
-        const message = await response.text();
-        throw new Error(`HTTP ${response.status}: ${message}`);
-      }
-      callbacks.onStart?.();
-      let text = "";
-      let reasoning = "";
-      let usage;
-      let finishReason;
-      await consumeSSE(response, (data) => {
-        if (data === "[DONE]") {
-          return;
-        }
-        const json = safeJSONParse(data);
-        if (!isRecord2(json)) {
-          return;
-        }
-        const delta = pickAssistantDelta(json);
-        const reasoningDelta = pickAssistantReasoningDelta(json);
-        const chunkUsage = pickUsage(json);
-        const chunkFinishReason = pickFinishReason(json);
-        usage = preferLatestUsage(usage, chunkUsage);
-        if (chunkFinishReason) {
-          finishReason = chunkFinishReason;
-        }
-        if (delta) {
-          text += delta;
-          callbacks.onToken?.(delta);
-        }
-        if (reasoningDelta) {
-          reasoning += reasoningDelta;
-        }
-        if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
-          const chunk = {
-            textDelta: delta,
-            reasoningDelta: reasoningDelta || undefined,
-            raw: json,
-            usage: chunkUsage,
-            finishReason: chunkFinishReason
-          };
-          callbacks.onChunk?.(chunk);
-        }
-      });
-      const out = {
-        text,
-        reasoning: reasoning.length > 0 ? reasoning : undefined,
-        usage,
-        finishReason
-      };
-      callbacks.onComplete?.(out);
-      return out;
+      return streamWithChatCompletionsPassThrough(options, fetcher, path, request, callbacks);
     },
     async embed(request) {
-      const body = cleanUndefined({
-        ...options.defaultBody,
-        ...request.body,
-        model: request.model ?? options.model,
-        input: request.input,
-        dimensions: request.dimensions,
-        encoding_format: "float"
-      });
-      const response = await fetcher(buildURL(options.baseURL, embeddingPath), {
-        method: "POST",
-        headers: buildHeaders(options),
-        body: JSON.stringify(body)
-      });
-      if (!response.ok) {
-        const message = await response.text();
-        throw new Error(`HTTP ${response.status}: ${message}`);
-      }
-      const json = await response.json();
-      const data = json.data;
-      if (!Array.isArray(data)) {
-        throw new Error("Unexpected embedding response: missing data array");
-      }
-      return {
-        embeddings: data.map((d) => isRecord2(d) && Array.isArray(d.embedding) ? d.embedding : []),
-        model: pickString(json.model) ?? body.model,
-        usage: pickUsage(json),
-        raw: json
-      };
+      return embedOpenAI(options, fetcher, embeddingPath, request);
+    }
+  };
+}
+async function streamWithChatCompletionsPassThrough(options, fetcher, path, request, callbacks) {
+  const response = await sendOpenAIRequest(options, fetcher, path, request, buildChatCompletionsBody(options, request, {
+    messages: buildMessages(request),
+    stream: true
+  }));
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  callbacks.onStart?.();
+  let text = "";
+  let reasoning = "";
+  let usage;
+  let finishReason;
+  await consumeSSE(response, (data) => {
+    if (data === "[DONE]") {
+      return;
+    }
+    const json = safeJSONParse(data);
+    if (!isRecord2(json)) {
+      return;
+    }
+    const delta = pickAssistantDelta(json);
+    const reasoningDelta = pickAssistantReasoningDelta(json);
+    const chunkUsage = pickUsage(json);
+    const chunkFinishReason = pickFinishReason(json);
+    usage = preferLatestUsage(usage, chunkUsage);
+    if (chunkFinishReason) {
+      finishReason = chunkFinishReason;
+    }
+    if (delta) {
+      text += delta;
+      callbacks.onToken?.(delta);
     }
+    if (reasoningDelta) {
+      reasoning += reasoningDelta;
+    }
+    emitOpenAIStreamChunk(callbacks, undefined, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
+  });
+  const out = {
+    text,
+    reasoning: reasoning.length > 0 ? reasoning : undefined,
+    usage,
+    finishReason
+  };
+  callbacks.onComplete?.(out);
+  return out;
+}
+async function embedOpenAI(options, fetcher, path, request) {
+  const body = cleanUndefined({
+    ...options.defaultBody,
+    ...request.body,
+    model: request.model ?? options.model,
+    input: request.input,
+    dimensions: request.dimensions,
+    encoding_format: "float"
+  });
+  const response = await fetcher(buildURL(options.baseURL, path), {
+    method: "POST",
+    headers: buildHeaders(options),
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  const json = await response.json();
+  const data = json.data;
+  if (!Array.isArray(data)) {
+    throw new Error("Unexpected embedding response: missing data array");
+  }
+  return {
+    embeddings: data.map((d) => isRecord2(d) && Array.isArray(d.embedding) ? d.embedding : []),
+    model: pickString(json.model) ?? body.model,
+    usage: pickUsage(json),
+    raw: json
   };
 }
 async function completeOpenAIRequest(options, fetcher, chatPath, responsesPath, request) {
@@ -1714,22 +1708,80 @@ async function completeOpenAIRequest(options, fetcher, chatPath, responsesPath,
   }
   return completeWithChatCompletionsPassThrough(options, fetcher, chatPath, request);
 }
-async function completeWithChatCompletionsPassThrough(options, fetcher, path, request) {
-  const response = await fetcher(buildURL(options.baseURL, path), {
+function buildChatCompletionsBody(options, request, overrides) {
+  return buildOpenAIRequestBody(options, request, "max_tokens", overrides);
+}
+function buildResponsesBody(options, request, overrides) {
+  return buildOpenAIRequestBody(options, request, "max_output_tokens", overrides);
+}
+function buildOpenAIRequestBody(options, request, maxTokenKey, overrides) {
+  return cleanUndefined({
+    ...options.defaultBody,
+    ...request.body,
+    model: options.model,
+    temperature: request.temperature,
+    reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
+    [maxTokenKey]: request.maxTokens,
+    ...overrides
+  });
+}
+function sendOpenAIRequest(options, fetcher, path, request, body) {
+  return fetcher(buildURL(options.baseURL, path), {
     method: "POST",
     headers: buildHeaders(options),
-    body: JSON.stringify(cleanUndefined({
-      ...options.defaultBody,
-      ...request.body,
-      model: options.model,
-      messages: buildMessages(request),
-      temperature: request.temperature,
-      reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-      max_tokens: request.maxTokens,
-      stream: false
-    })),
+    body: JSON.stringify(body),
     signal: request.signal
   });
+}
+async function sendOpenAIJsonRequest(options, fetcher, path, request, body) {
+  const response = await sendOpenAIRequest(options, fetcher, path, request, body);
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  return await response.json();
+}
+function createResponsesMCPState(request) {
+  return {
+    input: buildResponsesInput(request),
+    previousResponseId: pickString(isRecord2(request.body) ? request.body.previous_response_id : undefined),
+    aggregatedUsage: undefined,
+    finishReason: undefined,
+    lastPayload: undefined,
+    executedToolCalls: [],
+    toolExecutions: [],
+    reasoningBlocks: []
+  };
+}
+function buildResponsesMCPResult(state, text, raw) {
+  return {
+    text,
+    reasoning: joinReasoningBlocks(state.reasoningBlocks) || undefined,
+    reasoningBlocks: state.reasoningBlocks.length > 0 ? state.reasoningBlocks : undefined,
+    raw,
+    usage: state.aggregatedUsage,
+    finishReason: state.finishReason,
+    toolCalls: state.executedToolCalls.length > 0 ? state.executedToolCalls : undefined,
+    toolExecutions: state.toolExecutions.length > 0 ? state.toolExecutions : undefined
+  };
+}
+function emitOpenAIStreamChunk(callbacks, round, raw, delta, reasoningDelta, usage, finishReason) {
+  if (delta || reasoningDelta || usage || finishReason) {
+    callbacks.onChunk?.({
+      textDelta: delta,
+      reasoningDelta: reasoningDelta || undefined,
+      ...round !== undefined ? { turnIndex: round } : {},
+      raw,
+      usage,
+      finishReason
+    });
+  }
+}
+async function completeWithChatCompletionsPassThrough(options, fetcher, path, request) {
+  const response = await sendOpenAIRequest(options, fetcher, path, request, buildChatCompletionsBody(options, request, {
+    messages: buildMessages(request),
+    stream: false
+  }));
   if (!response.ok) {
     const message = await response.text();
     throw new Error(`HTTP ${response.status}: ${message}`);
@@ -1777,44 +1829,32 @@ 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);
-    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,
-        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-        max_tokens: request.maxTokens,
-        tools: transportTools,
-        tool_choice: request.toolChoice,
-        parallel_tool_calls: request.parallelToolCalls
-      })),
-      signal: request.signal
-    });
-    if (!response.ok) {
-      const message = await response.text();
-      throw new Error(`HTTP ${response.status}: ${message}`);
-    }
-    const payload = await response.json();
+    const payload = await sendOpenAIJsonRequest(options, fetcher, path, request, buildChatCompletionsBody(options, request, {
+      messages,
+      tools: transportTools,
+      tool_choice: request.toolChoice,
+      parallel_tool_calls: request.parallelToolCalls
+    }));
     lastPayload = payload;
     aggregatedUsage = mergeUsage(aggregatedUsage, pickUsage(payload));
     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,
@@ -1842,10 +1882,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,
@@ -1855,26 +1893,10 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
 }
 async function completeWithResponsesAPIPassThrough(options, fetcher, path, request) {
   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,
-      reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-      max_output_tokens: request.maxTokens
-    })),
-    signal: request.signal
-  });
-  if (!response.ok) {
-    const message = await response.text();
-    throw new Error(`HTTP ${response.status}: ${message}`);
-  }
-  const payload = await response.json();
+  const payload = await sendOpenAIJsonRequest(options, fetcher, path, request, buildResponsesBody(options, request, {
+    input: buildResponsesInput(request),
+    previous_response_id: pickString(body?.previous_response_id)
+  }));
   const toolCalls = pickResponsesToolCalls(payload);
   return {
     text: pickResponsesText(payload) || pickAssistantText(payload),
@@ -1886,54 +1908,26 @@ async function completeWithResponsesAPIPassThrough(options, fetcher, path, reque
 }
 async function completeWithResponsesAPIWithMCP(options, fetcher, path, request) {
   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 = [];
+  const state = createResponsesMCPState(request);
   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,
-        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-        max_output_tokens: request.maxTokens,
-        tools: transportTools,
-        tool_choice: request.toolChoice,
-        parallel_tool_calls: request.parallelToolCalls
-      })),
-      signal: request.signal
-    });
-    if (!response.ok) {
-      const message = await response.text();
-      throw new Error(`HTTP ${response.status}: ${message}`);
-    }
-    const payload = await response.json();
-    lastPayload = payload;
-    aggregatedUsage = mergeUsage(aggregatedUsage, pickUsage(payload));
-    finishReason = pickResponsesFinishReason(payload) ?? finishReason;
+    const payload = await sendOpenAIJsonRequest(options, fetcher, path, request, buildResponsesBody(options, request, {
+      input: state.input,
+      previous_response_id: state.previousResponseId,
+      tools: transportTools,
+      tool_choice: request.toolChoice,
+      parallel_tool_calls: request.parallelToolCalls
+    }));
+    state.lastPayload = payload;
+    state.aggregatedUsage = mergeUsage(state.aggregatedUsage, pickUsage(payload));
+    state.finishReason = pickResponsesFinishReason(payload) ?? state.finishReason;
+    pushReasoningBlock(state.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,
-        raw: payload,
-        usage: aggregatedUsage,
-        finishReason,
-        toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
-        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
-      };
+      return buildResponsesMCPResult(state, text, payload);
     }
     if (round > maxToolRounds) {
       throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
@@ -1944,23 +1938,16 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, 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) => ({
+    state.executedToolCalls.push(...outputs.map((entry) => entry.call));
+    state.toolExecutions.push(...outputs.map((entry) => entry.execution));
+    state.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(payload.id);
+    state.previousResponseId = pickString(payload.id);
   }
-  return {
-    text: pickResponsesText(lastPayload ?? {}) || pickAssistantText(lastPayload ?? {}),
-    raw: lastPayload,
-    usage: aggregatedUsage,
-    finishReason,
-    toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
-    toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
-  };
+  return buildResponsesMCPResult(state, pickResponsesText(state.lastPayload ?? {}) || pickAssistantText(state.lastPayload ?? {}), state.lastPayload);
 }
 async function streamWithChatCompletionsWithMCP(options, fetcher, path, request, callbacks) {
   const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
@@ -1970,30 +1957,19 @@ 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);
-    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,
-        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-        max_tokens: request.maxTokens,
-        tools: transportTools,
-        tool_choice: request.toolChoice,
-        parallel_tool_calls: request.parallelToolCalls,
-        stream: true
-      })),
-      signal: request.signal
-    });
+    const response = await sendOpenAIRequest(options, fetcher, path, request, buildChatCompletionsBody(options, request, {
+      messages,
+      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}`);
@@ -2030,38 +2006,48 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         roundReasoning += reasoningDelta;
         reasoningFieldName ??= pickAssistantReasoningDeltaFieldName(json);
       }
-      if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
-        const chunk = {
-          textDelta: delta,
-          reasoningDelta: reasoningDelta || undefined,
-          raw: json,
-          usage: chunkUsage,
-          finishReason: chunkFinishReason
-        };
-        callbacks.onChunk?.(chunk);
-      }
+      emitOpenAIStreamChunk(callbacks, round, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
     });
     aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
     if (roundFinishReason) {
       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,
@@ -2070,8 +2056,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
@@ -2085,34 +2071,25 @@ 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;
 }
 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,
-      reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-      max_output_tokens: request.maxTokens,
-      stream: true
-    })),
-    signal: request.signal
-  });
+  const response = await sendOpenAIRequest(options, fetcher, path, request, buildResponsesBody(options, request, {
+    input: buildResponsesInput(request),
+    previous_response_id: pickString(body?.previous_response_id),
+    stream: true
+  }));
   if (!response.ok) {
     const message = await response.text();
     throw new Error(`HTTP ${response.status}: ${message}`);
@@ -2145,15 +2122,7 @@ async function streamWithResponsesAPIPassThrough(options, fetcher, path, request
       text += delta;
       callbacks.onToken?.(delta);
     }
-    if (delta || chunkUsage || chunkFinishReason) {
-      const chunk = {
-        textDelta: delta,
-        raw: json,
-        usage: chunkUsage,
-        finishReason: chunkFinishReason
-      };
-      callbacks.onChunk?.(chunk);
-    }
+    emitOpenAIStreamChunk(callbacks, undefined, json, delta, "", chunkUsage, chunkFinishReason);
   });
   const finalPayload = lastPayload ?? {};
   const out = {
@@ -2167,41 +2136,25 @@ async function streamWithResponsesAPIPassThrough(options, fetcher, path, request
 }
 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 = [];
+  const state = createResponsesMCPState(request);
   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,
-        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
-        max_output_tokens: request.maxTokens,
-        tools: transportTools,
-        tool_choice: request.toolChoice,
-        parallel_tool_calls: request.parallelToolCalls,
-        stream: true
-      })),
-      signal: request.signal
-    });
+    const response = await sendOpenAIRequest(options, fetcher, path, request, buildResponsesBody(options, request, {
+      input: state.input,
+      previous_response_id: state.previousResponseId,
+      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 roundReasoning = "";
     let roundUsage;
     let roundFinishReason;
     let roundPayload;
@@ -2217,9 +2170,10 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
       const payload = pickResponsesStreamPayload(json);
       if (payload) {
         roundPayload = payload;
-        lastPayload = payload;
+        state.lastPayload = payload;
       }
       const delta = pickResponsesStreamTextDelta(json);
+      const reasoningDelta = pickResponsesStreamReasoningDelta(json);
       const chunkUsage = pickResponsesStreamUsage(json);
       const chunkFinishReason = pickResponsesStreamFinishReason(json);
       collectResponsesStreamToolCalls(json, streamedToolCalls);
@@ -2231,66 +2185,70 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
         roundText += delta;
         callbacks.onToken?.(delta);
       }
-      if (delta || chunkUsage || chunkFinishReason) {
-        const chunk = {
-          textDelta: delta,
-          raw: json,
-          usage: chunkUsage,
-          finishReason: chunkFinishReason
-        };
-        callbacks.onChunk?.(chunk);
+      if (reasoningDelta) {
+        roundReasoning += reasoningDelta;
       }
+      emitOpenAIStreamChunk(callbacks, round, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
     });
     const resolvedRoundUsage = preferLatestUsage(roundUsage, roundPayload ? pickUsage(roundPayload) : undefined);
-    aggregatedUsage = mergeUsage(aggregatedUsage, resolvedRoundUsage);
+    state.aggregatedUsage = mergeUsage(state.aggregatedUsage, resolvedRoundUsage);
     if (roundFinishReason) {
-      finishReason = roundFinishReason;
+      state.finishReason = roundFinishReason;
     } else if (roundPayload) {
-      finishReason = pickResponsesFinishReason(roundPayload) ?? finishReason;
+      state.finishReason = pickResponsesFinishReason(roundPayload) ?? state.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(state.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,
-        raw: roundPayload ?? lastPayload,
-        usage: aggregatedUsage,
-        finishReason,
-        toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
-        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
-      };
+      const out2 = buildResponsesMCPResult(state, finalText, roundPayload ?? state.lastPayload);
+      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,
       provider: "openai-compatible",
       model: options.model
     });
-    executedToolCalls.push(...outputs.map((entry) => entry.call));
-    toolExecutions.push(...outputs.map((entry) => entry.execution));
-    input = outputs.map((entry) => ({
+    state.executedToolCalls.push(...outputs.map((entry) => entry.call));
+    state.toolExecutions.push(...outputs.map((entry) => entry.execution));
+    request.onTurnTransition?.({ turnIndex: round, kind: "toolResultsReceived" });
+    state.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);
+    state.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
-  };
+  const out = buildResponsesMCPResult(state, pickResponsesText(state.lastPayload ?? {}) || pickAssistantText(state.lastPayload ?? {}), state.lastPayload);
+  request.onTurnTransition?.({ turnIndex: maxToolRounds + 1, kind: "streamEnd" });
   callbacks.onComplete?.(out);
   return out;
 }
@@ -2442,7 +2400,7 @@ function pickAssistantDelta(payload) {
   if (!isRecord2(delta)) {
     return "";
   }
-  return pickTextFromOpenAIContent(delta.content);
+  return pickTextLike(delta.content);
 }
 function pickAssistantReasoning(payload) {
   const message = pickAssistantMessage(payload);
@@ -2575,6 +2533,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) {
@@ -2709,10 +2681,34 @@ 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) {
-    const text = pickTextFromOpenAIContent(message.content);
+    const text = pickTextLike(message.content);
     if (text.length > 0) {
       return text;
     }
@@ -2729,8 +2725,17 @@ function pickAssistantText(payload) {
 function pickReasoningText(value) {
   return pickTextLike(value.reasoning) || pickTextLike(value.reasoning_content);
 }
-function pickTextFromOpenAIContent(value) {
-  return pickTextLike(value);
+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 pickTextLike(value) {
   if (typeof value === "string") {
@@ -2805,83 +2810,81 @@ function createAnthropicCompatibleAdapter(options) {
       if (hasMCPClients(request.mcpClients)) {
         return streamWithMCPToolLoop(options, fetcher, path, request, callbacks);
       }
-      const input = resolveAnthropicInput(request);
-      const response = await fetcher(buildURL(options.baseURL, path), {
-        method: "POST",
-        headers: buildHeaders2(options),
-        body: JSON.stringify(buildAnthropicRequestBody(options, request, {
-          ...options.defaultBody,
-          ...request.body,
-          model: options.model,
-          system: input.systemPrompt,
-          messages: input.messages,
-          temperature: request.temperature,
-          stream: true
-        })),
-        signal: request.signal
-      });
-      if (!response.ok) {
-        const message = await response.text();
-        throw new Error(`HTTP ${response.status}: ${message}`);
-      }
-      callbacks.onStart?.();
-      let text = "";
-      let usage;
-      let finishReason;
-      await consumeSSE(response, (data) => {
-        if (data === "[DONE]") {
-          return;
-        }
-        const json = safeJSONParse(data);
-        if (!isRecord2(json)) {
-          return;
-        }
-        const delta = pickAnthropicDelta(json);
-        const chunkUsage = pickUsage2(json);
-        const chunkFinishReason = pickFinishReason2(json);
-        usage = preferLatestUsage(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 out = { text, usage, finishReason };
-      callbacks.onComplete?.(out);
-      return out;
+      return streamPassThrough(options, fetcher, path, request, callbacks);
     },
     async embed() {
       throw new Error("Anthropic does not provide a native embedding API. " + "Use the openai-compatible provider with Voyage AI (https://api.voyageai.com) — " + "Anthropic's recommended embedding solution, which uses the same request format.");
     }
   };
 }
-async function completePassThrough(options, fetcher, path, request) {
+async function streamPassThrough(options, fetcher, path, request, callbacks) {
   const input = resolveAnthropicInput(request);
-  const response = await fetcher(buildURL(options.baseURL, path), {
+  const response = await sendAnthropicMessage(options, fetcher, path, request, {
+    system: input.systemPrompt,
+    messages: input.messages,
+    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;
+  await consumeSSE(response, (data) => {
+    if (data === "[DONE]") {
+      return;
+    }
+    const json = safeJSONParse(data);
+    if (!isRecord2(json)) {
+      return;
+    }
+    const delta = pickAnthropicDelta(json);
+    const chunkUsage = pickUsage2(json);
+    const chunkFinishReason = pickFinishReason2(json);
+    usage = preferLatestUsage(usage, chunkUsage);
+    if (chunkFinishReason) {
+      finishReason = chunkFinishReason;
+    }
+    if (delta) {
+      text += delta;
+      callbacks.onToken?.(delta);
+    }
+    if (delta || chunkUsage || chunkFinishReason) {
+      callbacks.onChunk?.({
+        textDelta: delta,
+        raw: json,
+        usage: chunkUsage,
+        finishReason: chunkFinishReason
+      });
+    }
+  });
+  const out = { text, usage, finishReason };
+  callbacks.onComplete?.(out);
+  return out;
+}
+function sendAnthropicMessage(options, fetcher, path, request, body) {
+  return fetcher(buildURL(options.baseURL, path), {
     method: "POST",
     headers: buildHeaders2(options),
     body: JSON.stringify(buildAnthropicRequestBody(options, request, {
       ...options.defaultBody,
       ...request.body,
       model: options.model,
-      system: input.systemPrompt,
-      messages: input.messages,
       temperature: request.temperature,
-      stream: false
+      ...body
     })),
     signal: request.signal
   });
+}
+async function completePassThrough(options, fetcher, path, request) {
+  const input = resolveAnthropicInput(request);
+  const response = await sendAnthropicMessage(options, fetcher, path, request, {
+    system: input.systemPrompt,
+    messages: input.messages,
+    stream: false
+  });
   if (!response.ok) {
     const message = await response.text();
     throw new Error(`HTTP ${response.status}: ${message}`);
@@ -2909,24 +2912,16 @@ 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));
-    const response = await fetcher(buildURL(options.baseURL, path), {
-      method: "POST",
-      headers: buildHeaders2(options),
-      body: JSON.stringify(buildAnthropicRequestBody(options, request, {
-        ...options.defaultBody,
-        ...request.body,
-        model: options.model,
-        system: input.systemPrompt,
-        messages,
-        temperature: request.temperature,
-        tools,
-        tool_choice: toAnthropicToolChoice(request.toolChoice),
-        stream: false
-      })),
-      signal: request.signal
+    const response = await sendAnthropicMessage(options, fetcher, path, request, {
+      system: input.systemPrompt,
+      messages,
+      tools,
+      tool_choice: toAnthropicToolChoice(request.toolChoice),
+      stream: false
     });
     if (!response.ok) {
       const message = await response.text();
@@ -2938,9 +2933,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,
@@ -2976,6 +2974,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,
@@ -2992,31 +2992,24 @@ 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);
     const tools = toAnthropicTools(toProviderFunctionTools(mcpToolset));
-    const response = await fetcher(buildURL(options.baseURL, path), {
-      method: "POST",
-      headers: buildHeaders2(options),
-      body: JSON.stringify(buildAnthropicRequestBody(options, request, {
-        ...options.defaultBody,
-        ...request.body,
-        model: options.model,
-        system: input.systemPrompt,
-        messages,
-        temperature: request.temperature,
-        tools,
-        tool_choice: toAnthropicToolChoice(request.toolChoice),
-        stream: true
-      })),
-      signal: request.signal
+    const response = await sendAnthropicMessage(options, fetcher, path, request, {
+      system: input.systemPrompt,
+      messages,
+      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 roundReasoning = "";
     let roundUsage;
     let roundFinishReason;
     const streamedToolCalls = new Map;
@@ -3030,6 +3023,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);
@@ -3041,9 +3035,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
@@ -3056,21 +3055,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,
@@ -3080,6 +3099,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",
@@ -3096,12 +3116,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;
 }
@@ -3222,10 +3245,26 @@ function extractAnthropicText(payload) {
     return typeof text === "string" ? text : "";
   }).join("");
 }
-function pickAnthropicToolCalls(payload) {
+function extractAnthropicReasoning(payload) {
   const content = payload.content;
   if (!Array.isArray(content)) {
-    return [];
+    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)) {
+    return [];
   }
   const calls = [];
   for (const part of content) {
@@ -3252,6 +3291,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) {
@@ -3478,39 +3546,10 @@ function buildProviderOptions(config) {
   return {
     model: config.model,
     ...transport,
-    ...config.options ?? {}
+    ...config.options
   };
 }
 
-// src/utils/debug-colors.ts
-var ANSI = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  cyan: "\x1B[36m",
-  yellow: "\x1B[33m",
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  dim: "\x1B[2m"
-};
-function color(config, text, tone) {
-  if (!config.colors) {
-    return text;
-  }
-  return `${ANSI[tone]}${text}${ANSI.reset}`;
-}
-function dim(config, text) {
-  if (!config.colors) {
-    return text;
-  }
-  return `${ANSI.dim}${text}${ANSI.reset}`;
-}
-function title(config, text) {
-  if (!config.colors) {
-    return text;
-  }
-  return `${ANSI.bold}${text}${ANSI.reset}`;
-}
-
 // src/outdent.ts
 var DEFAULT_OPTIONS = {
   trimLeadingNewline: true,
@@ -3648,131 +3687,213 @@ function createOutdent(options = {}) {
   return outdent;
 }
 
-// src/generate-shared.ts
-var sharedOutdent = createOutdent({
-  trimLeadingNewline: true,
-  trimTrailingNewline: true,
-  newline: `
-`
-});
+// src/generate-tool-timeout.ts
+function withToolTimeout(client, toolTimeoutMs) {
+  return {
+    id: client.id,
+    listTools: client.listTools.bind(client),
+    close: client.close?.bind(client),
+    async callTool(params) {
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(`Tool call timed out after ${toolTimeoutMs}ms`)), toolTimeoutMs);
+      });
+      try {
+        return await Promise.race([client.callTool(params), timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
+}
+function applyToolTimeout(clients, toolTimeoutMs) {
+  return clients.map((client) => withToolTimeout(client, toolTimeoutMs));
+}
+// src/generate-output.ts
 var RE_THINK_TAGS = /<\/?think\s*>/gi;
-function resolvePrompt(prompt, context) {
-  const resolved = typeof prompt === "function" ? prompt(context) : prompt;
-  return normalizePromptValue(resolved, context);
+function normalizeModelOutput(text, dedicatedReasoning, reasoningBlocks) {
+  const sanitized = sanitizeThink(text);
+  const visibleText = stripThinkBlocks(text, sanitized.thinkBlocks);
+  const reasoning = joinReasoningSegments([
+    dedicatedReasoning,
+    ...sanitized.thinkBlocks.map((block) => block.content)
+  ]);
+  return {
+    text: visibleText,
+    reasoning,
+    reasoningBlocks: normalizeReasoningBlocks(reasoningBlocks),
+    thinkBlocks: sanitized.thinkBlocks,
+    parseSource: composeParseSource(visibleText, reasoning)
+  };
 }
-function normalizePromptValue(value, _context) {
-  if (typeof value === "string") {
-    return {
-      prompt: value
-    };
-  }
-  if (isPromptResolver(value)) {
-    return normalizePromptPayload(value.resolvePrompt(_context));
+function normalizeReasoningBlocks(blocks) {
+  if (!Array.isArray(blocks)) {
+    return;
   }
-  return normalizePromptPayload(value);
+  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 normalizePromptPayload(value) {
-  const prompt = typeof value.prompt === "string" ? value.prompt : undefined;
-  const messages = Array.isArray(value.messages) ? value.messages.filter(isLLMMessage) : undefined;
-  if ((!prompt || prompt.trim().length === 0) && (!messages || messages.length === 0)) {
-    throw new Error("Structured prompt payload must include a non-empty prompt or messages.");
+function appendReasoningBlock(blocks, transition) {
+  const text = transition.reasoningText?.replace(RE_THINK_TAGS, "").trim();
+  if (!text) {
+    return blocks;
   }
-  return {
-    prompt,
-    systemPrompt: typeof value.systemPrompt === "string" ? value.systemPrompt : undefined,
-    messages: messages && messages.length > 0 ? messages.map((message) => ({ ...message })) : undefined
-  };
+  const next = [...blocks ?? [], { turnIndex: transition.turnIndex, text }];
+  return normalizeReasoningBlocks(next);
 }
-function applyPromptOutdent(payload, enabled) {
-  if (!enabled) {
-    return payload;
+function composeParseSource(text, reasoning) {
+  if (typeof reasoning !== "string" || reasoning.length === 0) {
+    return text;
   }
-  return {
-    prompt: typeof payload.prompt === "string" ? sharedOutdent.string(payload.prompt) : undefined,
-    systemPrompt: applyOutdentToOptionalPrompt(payload.systemPrompt, enabled),
-    messages: payload.messages?.map((message) => ({
-      ...message,
-      content: typeof message.content === "string" ? sharedOutdent.string(message.content) : message.content
-    }))
-  };
+  const sanitized = reasoning.replace(RE_THINK_TAGS, "");
+  if (sanitized.length === 0) {
+    return text;
+  }
+  return `<think>${sanitized}</think>${text}`;
 }
-function applyOutdentToOptionalPrompt(value, enabled) {
-  if (!enabled || typeof value !== "string") {
-    return value;
+function aggregateUsage(attempts) {
+  let usage;
+  for (const attempt of attempts) {
+    usage = mergeUsage2(usage, attempt.usage);
   }
-  return sharedOutdent.string(value);
+  return usage;
 }
-function mergeSystemPrompts(primary, secondary) {
-  const prompts = [primary, secondary].map((value) => value?.trim()).filter((value) => Boolean(value));
-  if (prompts.length === 0) {
+function mergeUsage2(base, next) {
+  if (!base && !next) {
     return;
   }
-  return prompts.join(`
+  return {
+    inputTokens: (base?.inputTokens ?? 0) + (next?.inputTokens ?? 0),
+    outputTokens: (base?.outputTokens ?? 0) + (next?.outputTokens ?? 0),
+    totalTokens: (base?.totalTokens ?? 0) + (next?.totalTokens ?? 0),
+    cost: (base?.cost ?? 0) + (next?.cost ?? 0)
+  };
+}
+function joinReasoningSegments(parts) {
+  return parts.map((value) => value?.trim()).filter((value) => Boolean(value)).join(`
 
 `);
 }
-function normalizeStreamConfig(option) {
-  if (typeof option === "boolean") {
-    return {
-      enabled: option
-    };
+function stripThinkBlocks(text, thinkBlocks) {
+  if (thinkBlocks.length === 0) {
+    return text;
   }
-  if (!option) {
-    return {
-      enabled: false
-    };
+  let output = "";
+  let cursor = 0;
+  for (const block of thinkBlocks) {
+    output += text.slice(cursor, block.start);
+    cursor = block.end;
   }
-  return {
-    enabled: option.enabled ?? true,
-    onData: option.onData,
-    to: option.to
-  };
+  output += text.slice(cursor);
+  return output;
 }
-function normalizeDebugConfig(option) {
-  if (typeof option === "boolean") {
-    return {
-      enabled: option,
-      colors: true,
-      verbose: false,
-      logger: (line) => console.log(line)
-    };
+function toStreamDataFingerprint(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "__unserializable__";
   }
-  if (!option) {
-    return {
-      enabled: false,
-      colors: true,
-      verbose: false,
-      logger: (line) => console.log(line)
-    };
+}
+
+// src/utils/debug-colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m"
+};
+function color(config, text, tone) {
+  if (!config.colors) {
+    return text;
   }
-  return {
-    enabled: option.enabled ?? true,
-    colors: option.colors ?? true,
-    verbose: option.verbose ?? false,
-    logger: option.logger ?? ((line) => console.log(line))
-  };
+  return `${ANSI[tone]}${text}${ANSI.reset}`;
 }
-function withToolTimeout(client, toolTimeoutMs) {
-  return {
-    id: client.id,
-    listTools: client.listTools.bind(client),
-    close: client.close?.bind(client),
-    async callTool(params) {
-      let timeoutId;
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => reject(new Error(`Tool call timed out after ${toolTimeoutMs}ms`)), toolTimeoutMs);
-      });
-      try {
-        return await Promise.race([client.callTool(params), timeoutPromise]);
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    }
-  };
+function dim(config, text) {
+  if (!config.colors) {
+    return text;
+  }
+  return `${ANSI.dim}${text}${ANSI.reset}`;
 }
-function applyToolTimeout(clients, toolTimeoutMs) {
-  return clients.map((client) => withToolTimeout(client, toolTimeoutMs));
+function title(config, text) {
+  if (!config.colors) {
+    return text;
+  }
+  return `${ANSI.bold}${text}${ANSI.reset}`;
+}
+
+// src/generate-debug.ts
+function emitDebugRequest(config, input) {
+  const requestBody = input.requestPayload.body !== undefined ? JSON.stringify(input.requestPayload.body, null, 2) : "(none)";
+  const requestMessages = input.requestPayload.messages !== undefined ? JSON.stringify(input.requestPayload.messages, null, 2) : "(none)";
+  const lines = [
+    color(config, title(config, [
+      `[${input.label}][request]`,
+      `attempt=${input.attempt}`,
+      `selfHealEnabled=${input.selfHealEnabled}`,
+      `selfHealAttempt=${input.selfHealAttempt}`
+    ].join(" ")), "cyan"),
+    dim(config, [
+      `provider=${input.provider ?? "unknown"}`,
+      `model=${input.model ?? "unknown"}`,
+      `stream=${input.stream}`
+    ].join(" ")),
+    color(config, "prompt:", "yellow"),
+    input.requestPayload.prompt ?? "(none)",
+    color(config, "messages:", "yellow"),
+    requestMessages,
+    color(config, "systemPrompt:", "yellow"),
+    input.requestPayload.systemPrompt ?? "(none)",
+    color(config, "request.body:", "yellow"),
+    requestBody
+  ];
+  emitDebug(config, lines.join(`
+`));
+}
+function emitDebugResponse(config, input) {
+  const text = input.text.length > 0 ? input.text : "(none)";
+  const reasoning = input.reasoning.length > 0 ? input.reasoning : "(none)";
+  const metadata = [
+    `via=${input.via}`,
+    `textChars=${input.text.length}`,
+    `reasoningChars=${input.reasoning.length}`
+  ];
+  if (config.verbose) {
+    metadata.push(`parseSourceChars=${input.parseSource.length}`);
+  }
+  metadata.push(`finishReason=${input.finishReason ?? "unknown"}`, `usage=${JSON.stringify(input.usage ?? {})}`);
+  const lines = [
+    color(config, title(config, [
+      `[${input.label}][response]`,
+      `attempt=${input.attempt}`,
+      `selfHealEnabled=${input.selfHealEnabled}`,
+      `selfHealAttempt=${input.selfHealAttempt}`
+    ].join(" ")), "green"),
+    dim(config, metadata.join(" ")),
+    color(config, "text:", "yellow"),
+    text,
+    color(config, "reasoning:", "yellow"),
+    reasoning
+  ];
+  if (config.verbose) {
+    lines.push(color(config, "parseSource:", "yellow"), input.parseSource);
+  }
+  emitDebug(config, lines.join(`
+`));
 }
+function emitDebug(config, message) {
+  if (!config.enabled) {
+    return;
+  }
+  config.logger(message);
+}
+
+// src/generate-model-call.ts
 async function callModel(adapter, options) {
   const requestSignal = options.request?.signal ?? (options.timeout?.request !== undefined ? AbortSignal.timeout(options.timeout.request) : undefined);
   const requestPayload = {
@@ -3792,6 +3913,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
   };
@@ -3819,13 +3941,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;
       }
@@ -3841,7 +3971,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);
@@ -3876,8 +4008,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);
         }
@@ -3890,11 +4035,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);
@@ -3926,11 +4075,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.",
@@ -3959,51 +4109,119 @@ 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) {
-  const sanitized = sanitizeThink(text);
-  const visibleText = stripThinkBlocks(text, sanitized.thinkBlocks);
-  const reasoning = joinReasoningSegments([
-    dedicatedReasoning,
-    ...sanitized.thinkBlocks.map((block) => block.content)
-  ]);
+
+// src/generate-shared.ts
+var sharedOutdent = createOutdent({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true,
+  newline: `
+`
+});
+function resolvePrompt(prompt, context) {
+  const resolved = typeof prompt === "function" ? prompt(context) : prompt;
+  return normalizePromptValue(resolved, context);
+}
+function normalizePromptValue(value, _context) {
+  if (typeof value === "string") {
+    return {
+      prompt: value
+    };
+  }
+  if (isPromptResolver(value)) {
+    return normalizePromptPayload(value.resolvePrompt(_context));
+  }
+  return normalizePromptPayload(value);
+}
+function normalizePromptPayload(value) {
+  const prompt = typeof value.prompt === "string" ? value.prompt : undefined;
+  const messages = Array.isArray(value.messages) ? value.messages.filter(isLLMMessage) : undefined;
+  if ((!prompt || prompt.trim().length === 0) && (!messages || messages.length === 0)) {
+    throw new Error("Structured prompt payload must include a non-empty prompt or messages.");
+  }
   return {
-    text: visibleText,
-    reasoning,
-    thinkBlocks: sanitized.thinkBlocks,
-    parseSource: composeParseSource(visibleText, reasoning)
+    prompt,
+    systemPrompt: typeof value.systemPrompt === "string" ? value.systemPrompt : undefined,
+    messages: messages && messages.length > 0 ? messages.map((message) => ({ ...message })) : undefined
   };
 }
-function composeParseSource(text, reasoning) {
-  if (typeof reasoning !== "string" || reasoning.length === 0) {
-    return text;
+function applyPromptOutdent(payload, enabled) {
+  if (!enabled) {
+    return payload;
   }
-  const sanitized = reasoning.replace(RE_THINK_TAGS, "");
-  if (sanitized.length === 0) {
-    return text;
+  return {
+    prompt: typeof payload.prompt === "string" ? sharedOutdent.string(payload.prompt) : undefined,
+    systemPrompt: applyOutdentToOptionalPrompt(payload.systemPrompt, enabled),
+    messages: payload.messages?.map((message) => ({
+      ...message,
+      content: typeof message.content === "string" ? sharedOutdent.string(message.content) : message.content
+    }))
+  };
+}
+function applyOutdentToOptionalPrompt(value, enabled) {
+  if (!enabled || typeof value !== "string") {
+    return value;
   }
-  return `<think>${sanitized}</think>${text}`;
+  return sharedOutdent.string(value);
 }
-function aggregateUsage(attempts) {
-  let usage;
-  for (const attempt of attempts) {
-    usage = mergeUsage2(usage, attempt.usage);
+function mergeSystemPrompts(primary, secondary) {
+  const prompts = [primary, secondary].map((value) => value?.trim()).filter((value) => Boolean(value));
+  if (prompts.length === 0) {
+    return;
+  }
+  return prompts.join(`
+
+`);
+}
+function normalizeStreamConfig(option) {
+  if (typeof option === "boolean") {
+    return {
+      enabled: option
+    };
+  }
+  if (!option) {
+    return {
+      enabled: false
+    };
   }
-  return usage;
+  return {
+    enabled: option.enabled ?? true,
+    onData: option.onData,
+    onTurnTransition: option.onTurnTransition,
+    to: option.to
+  };
 }
-function mergeUsage2(base, next) {
-  if (!base && !next) {
-    return;
+function normalizeDebugConfig(option) {
+  if (typeof option === "boolean") {
+    return {
+      enabled: option,
+      colors: true,
+      verbose: false,
+      logger: defaultDebugLogger
+    };
+  }
+  if (!option) {
+    return {
+      enabled: false,
+      colors: true,
+      verbose: false,
+      logger: defaultDebugLogger
+    };
   }
   return {
-    inputTokens: (base?.inputTokens ?? 0) + (next?.inputTokens ?? 0),
-    outputTokens: (base?.outputTokens ?? 0) + (next?.outputTokens ?? 0),
-    totalTokens: (base?.totalTokens ?? 0) + (next?.totalTokens ?? 0),
-    cost: (base?.cost ?? 0) + (next?.cost ?? 0)
+    enabled: option.enabled ?? true,
+    colors: option.colors ?? true,
+    verbose: option.verbose ?? false,
+    logger: option.logger ?? defaultDebugLogger
   };
 }
+function defaultDebugLogger(line) {
+  const { log } = globalThis.console;
+  log(line);
+}
 function isPromptResolver(value) {
   return typeof value === "object" && value !== null && "resolvePrompt" in value && typeof value.resolvePrompt === "function";
 }
@@ -4017,95 +4235,6 @@ function isLLMMessage(value) {
   }
   return "content" in candidate;
 }
-function joinReasoningSegments(parts) {
-  return parts.map((value) => value?.trim()).filter((value) => Boolean(value)).join(`
-
-`);
-}
-function stripThinkBlocks(text, thinkBlocks) {
-  if (thinkBlocks.length === 0) {
-    return text;
-  }
-  let output = "";
-  let cursor = 0;
-  for (const block of thinkBlocks) {
-    output += text.slice(cursor, block.start);
-    cursor = block.end;
-  }
-  output += text.slice(cursor);
-  return output;
-}
-function toStreamDataFingerprint(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "__unserializable__";
-  }
-}
-function emitDebugRequest(config, input) {
-  const requestBody = input.requestPayload.body !== undefined ? JSON.stringify(input.requestPayload.body, null, 2) : "(none)";
-  const requestMessages = input.requestPayload.messages !== undefined ? JSON.stringify(input.requestPayload.messages, null, 2) : "(none)";
-  const lines = [
-    color(config, title(config, [
-      `[${input.label}][request]`,
-      `attempt=${input.attempt}`,
-      `selfHealEnabled=${input.selfHealEnabled}`,
-      `selfHealAttempt=${input.selfHealAttempt}`
-    ].join(" ")), "cyan"),
-    dim(config, [
-      `provider=${input.provider ?? "unknown"}`,
-      `model=${input.model ?? "unknown"}`,
-      `stream=${input.stream}`
-    ].join(" ")),
-    color(config, "prompt:", "yellow"),
-    input.requestPayload.prompt ?? "(none)",
-    color(config, "messages:", "yellow"),
-    requestMessages,
-    color(config, "systemPrompt:", "yellow"),
-    input.requestPayload.systemPrompt ?? "(none)",
-    color(config, "request.body:", "yellow"),
-    requestBody
-  ];
-  emitDebug(config, lines.join(`
-`));
-}
-function emitDebugResponse(config, input) {
-  const text = input.text.length > 0 ? input.text : "(none)";
-  const reasoning = input.reasoning.length > 0 ? input.reasoning : "(none)";
-  const metadata = [
-    `via=${input.via}`,
-    `textChars=${input.text.length}`,
-    `reasoningChars=${input.reasoning.length}`
-  ];
-  if (config.verbose) {
-    metadata.push(`parseSourceChars=${input.parseSource.length}`);
-  }
-  metadata.push(`finishReason=${input.finishReason ?? "unknown"}`, `usage=${JSON.stringify(input.usage ?? {})}`);
-  const lines = [
-    color(config, title(config, [
-      `[${input.label}][response]`,
-      `attempt=${input.attempt}`,
-      `selfHealEnabled=${input.selfHealEnabled}`,
-      `selfHealAttempt=${input.selfHealAttempt}`
-    ].join(" ")), "green"),
-    dim(config, metadata.join(" ")),
-    color(config, "text:", "yellow"),
-    text,
-    color(config, "reasoning:", "yellow"),
-    reasoning
-  ];
-  if (config.verbose) {
-    lines.push(color(config, "parseSource:", "yellow"), input.parseSource);
-  }
-  emitDebug(config, lines.join(`
-`));
-}
-function emitDebug(config, message) {
-  if (!config.enabled) {
-    return;
-  }
-  config.logger(message);
-}
 
 // src/generate.ts
 async function generate(adapter, promptOrOptions, callOptions) {
@@ -4135,7 +4264,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",
@@ -4150,7 +4280,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?.({
@@ -4167,7 +4298,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) {
@@ -4178,7 +4310,7 @@ function normalizeGenerateInput(promptOrOptions, callOptions) {
     throw new Error("Missing prompt in generate(adapter, prompt, options?) call.");
   }
   return {
-    ...callOptions ?? {},
+    ...callOptions,
     prompt: promptOrOptions
   };
 }
@@ -4204,9 +4336,6 @@ function prepareGeneratePromptPayload(payload, systemPrompt) {
   };
 }
 
-// src/structured.ts
-import { jsonrepair as jsonrepair3 } from "jsonrepair";
-
 // src/parse.ts
 import { jsonrepair as jsonrepair2 } from "jsonrepair";
 function parseLLMOutput(output, schema, options = {}) {
@@ -4506,6 +4635,80 @@ function formatZodIssues(issues) {
 `);
 }
 
+// src/structured-streaming.ts
+import { jsonrepair as jsonrepair3 } from "jsonrepair";
+function parseStreamingStructuredData(parseSource) {
+  const sanitized = sanitizeThink(parseSource);
+  const start = findFirstJsonRootStart(sanitized.visibleText);
+  if (start < 0) {
+    return null;
+  }
+  const candidate = sanitized.visibleText.slice(start).trim();
+  if (!candidate) {
+    return null;
+  }
+  try {
+    const repaired = jsonrepair3(candidate);
+    const parsed = JSON.parse(repaired);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function findFirstJsonRootStart(input) {
+  const unquotedRootStart = findFirstUnquotedJsonRootStart(input);
+  if (unquotedRootStart >= 0) {
+    return unquotedRootStart;
+  }
+  return findFirstRawJsonRootStart(input);
+}
+function findFirstUnquotedJsonRootStart(input) {
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < input.length; index += 1) {
+    const char = input[index];
+    if (!char) {
+      continue;
+    }
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      return index;
+    }
+  }
+  return -1;
+}
+function findFirstRawJsonRootStart(input) {
+  const objectStart = input.indexOf("{");
+  const arrayStart = input.indexOf("[");
+  if (objectStart < 0) {
+    return arrayStart;
+  }
+  if (arrayStart < 0) {
+    return objectStart;
+  }
+  return Math.min(objectStart, arrayStart);
+}
+
 // src/structured.ts
 class StructuredParseError extends Error {
   name = "StructuredParseError";
@@ -4743,7 +4946,7 @@ function normalizeStructuredInput(schemaOrOptions, promptInput, callOptions) {
     throw new Error("Missing prompt in structured(adapter, schema, prompt, options?) call.");
   }
   return {
-    ...callOptions ?? {},
+    ...callOptions,
     schema: schemaOrOptions,
     prompt: promptInput
   };
@@ -4987,6 +5190,7 @@ async function executeAttempt(adapter, input) {
     success: parsed.success,
     usage: response.usage,
     finishReason: response.finishReason,
+    ...response.reasoningBlocks ? { reasoningBlocks: response.reasoningBlocks } : {},
     parsed
   };
   return {
@@ -5007,72 +5211,12 @@ 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"
   });
 }
-function parseStreamingStructuredData(parseSource) {
-  const sanitized = sanitizeThink(parseSource);
-  const start = findFirstJsonRootStart(sanitized.visibleText);
-  if (start < 0) {
-    return null;
-  }
-  const candidate = sanitized.visibleText.slice(start).trim();
-  if (!candidate) {
-    return null;
-  }
-  try {
-    const repaired = jsonrepair3(candidate);
-    const parsed = JSON.parse(repaired);
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function findFirstJsonRootStart(input) {
-  let inString = false;
-  let escaped = false;
-  for (let index = 0;index < input.length; index += 1) {
-    const char = input[index];
-    if (!char) {
-      continue;
-    }
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (char === "\\") {
-        escaped = true;
-        continue;
-      }
-      if (char === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      continue;
-    }
-    if (char === "{" || char === "[") {
-      return index;
-    }
-  }
-  const objectStart = input.indexOf("{");
-  const arrayStart = input.indexOf("[");
-  if (objectStart < 0) {
-    return arrayStart;
-  }
-  if (arrayStart < 0) {
-    return objectStart;
-  }
-  return Math.min(objectStart, arrayStart);
-}
 function parseWithObserve(output, schema, parseOptions, context) {
   const userParseTrace = parseOptions.onTrace;
   return parseLLMOutput(output, schema, {
@@ -5107,7 +5251,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) {
@@ -5174,12 +5319,12 @@ function mergeStructuredOptions(defaults, overrides) {
     ...defaults,
     ...overrides,
     parse: {
-      ...defaults?.parse ?? {},
-      ...overrides?.parse ?? {}
+      ...defaults?.parse,
+      ...overrides?.parse
     },
     request: {
-      ...defaults?.request ?? {},
-      ...overrides?.request ?? {}
+      ...defaults?.request,
+      ...overrides?.request
     },
     stream: mergeObjectLike(defaults?.stream, overrides?.stream),
     selfHeal: mergeObjectLike(defaults?.selfHeal, overrides?.selfHeal),
@@ -5195,8 +5340,8 @@ function mergeGenerateOptions(defaults, overrides) {
     outdent: overrides?.outdent ?? defaults?.outdent,
     systemPrompt: overrides?.systemPrompt ?? defaults?.systemPrompt,
     request: {
-      ...defaults?.request ?? {},
-      ...overrides?.request ?? {}
+      ...defaults?.request,
+      ...overrides?.request
     },
     stream: mergeObjectLike(defaults?.stream, overrides?.stream),
     debug: mergeObjectLike(defaults?.debug, overrides?.debug),
@@ -5574,11 +5719,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();
   }
@@ -5586,11 +5731,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();
         }
@@ -5600,11 +5745,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;
@@ -5613,22 +5758,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;
@@ -5638,19 +5783,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;