extrait 0.7.0 → 0.7.1

package/dist/index.cjs

@@ -91,9 +91,6 @@ __export(exports_src, {
 });
 module.exports = __toCommonJS(exports_src);
 
-// src/extract.ts
-var import_jsonrepair = require("jsonrepair");
-
 // src/utils/common.ts
 function toErrorMessage(error) {
   if (error instanceof Error) {
@@ -311,184 +308,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
+var import_jsonrepair = require("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 = import_jsonrepair.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("{")) {
@@ -597,95 +487,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 = import_jsonrepair.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;
@@ -771,6 +572,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;
@@ -1219,17 +1221,107 @@ function findSSEBoundary(buffer) {
   return Math.max(crlfIndex, lfIndex);
 }
 
-// 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) {
+// 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);
@@ -1411,90 +1503,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) {
@@ -1691,103 +1699,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) {
@@ -1804,22 +1798,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}`);
@@ -1871,28 +1923,12 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
   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);
@@ -1947,26 +1983,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),
@@ -1978,58 +1998,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 reasoningBlocks = [];
+  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;
-    pushReasoningBlock(reasoningBlocks, round, pickResponsesReasoning(payload));
+    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,
-        reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
-        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
-        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}).`);
@@ -2040,25 +2028,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 ?? {}),
-    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
-  };
+  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);
@@ -2074,24 +2053,13 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
   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}`);
@@ -2128,17 +2096,7 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         roundReasoning += reasoningDelta;
         reasoningFieldName ??= pickAssistantReasoningDeltaFieldName(json);
       }
-      if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
-        const chunk = {
-          textDelta: delta,
-          reasoningDelta: reasoningDelta || undefined,
-          turnIndex: round,
-          raw: json,
-          usage: chunkUsage,
-          finishReason: chunkFinishReason
-        };
-        callbacks.onChunk?.(chunk);
-      }
+      emitOpenAIStreamChunk(callbacks, round, json, delta, reasoningDelta, chunkUsage, chunkFinishReason);
     });
     aggregatedUsage = mergeUsage(aggregatedUsage, roundUsage);
     if (roundFinishReason) {
@@ -2217,22 +2175,11 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
 }
 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}`);
@@ -2265,15 +2212,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 = {
@@ -2287,37 +2226,19 @@ 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 reasoningBlocks = [];
+  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}`);
@@ -2339,7 +2260,7 @@ 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);
@@ -2357,24 +2278,14 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
       if (reasoningDelta) {
         roundReasoning += reasoningDelta;
       }
-      if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
-        const chunk = {
-          textDelta: delta,
-          reasoningDelta: reasoningDelta || undefined,
-          turnIndex: round,
-          raw: json,
-          usage: chunkUsage,
-          finishReason: chunkFinishReason
-        };
-        callbacks.onChunk?.(chunk);
-      }
+      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) {
@@ -2383,7 +2294,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
     const streamedCalls = buildResponsesStreamToolCalls(streamedToolCalls);
     const providerToolCalls = payloadToolCalls.length > 0 ? payloadToolCalls : streamedCalls;
     const functionCalls = providerToolCalls.filter((toolCall) => toolCall.type === "function" && typeof toolCall.id === "string" && typeof toolCall.name === "string");
-    pushReasoningBlock(reasoningBlocks, round, roundReasoning);
+    pushReasoningBlock(state.reasoningBlocks, round, roundReasoning);
     request.onTurnTransition?.({
       turnIndex: round,
       kind: "reasoningComplete",
@@ -2391,16 +2302,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
     });
     if (functionCalls.length === 0) {
       const finalText = roundText.length > 0 ? roundText : roundPayload ? pickResponsesText(roundPayload) || pickAssistantText(roundPayload) : "";
-      const out2 = {
-        text: finalText,
-        reasoning: joinReasoningBlocks(reasoningBlocks) || undefined,
-        reasoningBlocks: reasoningBlocks.length > 0 ? reasoningBlocks : undefined,
-        raw: roundPayload ?? lastPayload,
-        usage: aggregatedUsage,
-        finishReason,
-        toolCalls: executedToolCalls.length > 0 ? executedToolCalls : undefined,
-        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
-      };
+      const out2 = buildResponsesMCPResult(state, finalText, roundPayload ?? state.lastPayload);
       request.onTurnTransition?.({ turnIndex: round, kind: "streamEnd" });
       callbacks.onComplete?.(out2);
       return out2;
@@ -2425,26 +2327,17 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
       provider: "openai-compatible",
       model: options.model
     });
-    executedToolCalls.push(...outputs.map((entry) => entry.call));
-    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    state.executedToolCalls.push(...outputs.map((entry) => entry.call));
+    state.toolExecutions.push(...outputs.map((entry) => entry.execution));
     request.onTurnTransition?.({ turnIndex: round, kind: "toolResultsReceived" });
-    input = outputs.map((entry) => ({
+    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 ?? {}),
-    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
-  };
+  const out = buildResponsesMCPResult(state, pickResponsesText(state.lastPayload ?? {}) || pickAssistantText(state.lastPayload ?? {}), state.lastPayload);
   request.onTurnTransition?.({ turnIndex: maxToolRounds + 1, kind: "streamEnd" });
   callbacks.onComplete?.(out);
   return out;
@@ -2597,7 +2490,7 @@ function pickAssistantDelta(payload) {
   if (!isRecord2(delta)) {
     return "";
   }
-  return pickTextFromOpenAIContent(delta.content);
+  return pickTextLike(delta.content);
 }
 function pickAssistantReasoning(payload) {
   const message = pickAssistantMessage(payload);
@@ -2905,7 +2798,7 @@ function pickResponsesReasoning(payload) {
 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;
     }
@@ -2934,9 +2827,6 @@ function joinReasoningBlocks(blocks) {
 
 `);
 }
-function pickTextFromOpenAIContent(value) {
-  return pickTextLike(value);
-}
 function pickTextLike(value) {
   if (typeof value === "string") {
     return value;
@@ -3010,83 +2900,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}`);
@@ -3118,21 +3006,12 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
   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();
@@ -3208,21 +3087,12 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
   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();
@@ -3766,39 +3636,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,
@@ -3936,132 +3777,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,
-    onTurnTransition: option.onTurnTransition,
-    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 = {
@@ -4281,67 +4203,115 @@ async function callModel(adapter, options) {
     reasoningBlocks: normalized.reasoningBlocks
   };
 }
-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)
-  ]);
+
+// 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,
-    reasoningBlocks: normalizeReasoningBlocks(reasoningBlocks),
-    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 normalizeReasoningBlocks(blocks) {
-  if (!Array.isArray(blocks)) {
-    return;
+function applyPromptOutdent(payload, enabled) {
+  if (!enabled) {
+    return payload;
   }
-  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;
+  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 appendReasoningBlock(blocks, transition) {
-  const text = transition.reasoningText?.replace(RE_THINK_TAGS, "").trim();
-  if (!text) {
-    return blocks;
+function applyOutdentToOptionalPrompt(value, enabled) {
+  if (!enabled || typeof value !== "string") {
+    return value;
   }
-  const next = [...blocks ?? [], { turnIndex: transition.turnIndex, text }];
-  return normalizeReasoningBlocks(next);
+  return sharedOutdent.string(value);
 }
-function composeParseSource(text, reasoning) {
-  if (typeof reasoning !== "string" || reasoning.length === 0) {
-    return text;
-  }
-  const sanitized = reasoning.replace(RE_THINK_TAGS, "");
-  if (sanitized.length === 0) {
-    return text;
+function mergeSystemPrompts(primary, secondary) {
+  const prompts = [primary, secondary].map((value) => value?.trim()).filter((value) => Boolean(value));
+  if (prompts.length === 0) {
+    return;
   }
-  return `<think>${sanitized}</think>${text}`;
+  return prompts.join(`
+
+`);
 }
-function aggregateUsage(attempts) {
-  let usage;
-  for (const attempt of attempts) {
-    usage = mergeUsage2(usage, attempt.usage);
+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";
 }
@@ -4355,95 +4325,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) {
@@ -4519,7 +4400,7 @@ function normalizeGenerateInput(promptOrOptions, callOptions) {
     throw new Error("Missing prompt in generate(adapter, prompt, options?) call.");
   }
   return {
-    ...callOptions ?? {},
+    ...callOptions,
     prompt: promptOrOptions
   };
 }
@@ -4545,9 +4426,6 @@ function prepareGeneratePromptPayload(payload, systemPrompt) {
   };
 }
 
-// src/structured.ts
-var import_jsonrepair3 = require("jsonrepair");
-
 // src/parse.ts
 var import_jsonrepair2 = require("jsonrepair");
 function parseLLMOutput(output, schema, options = {}) {
@@ -4847,6 +4725,80 @@ function formatZodIssues(issues) {
 `);
 }
 
+// src/structured-streaming.ts
+var import_jsonrepair3 = require("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 = import_jsonrepair3.jsonrepair(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";
@@ -5084,7 +5036,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
   };
@@ -5355,67 +5307,6 @@ async function callModel2(adapter, options) {
     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 = import_jsonrepair3.jsonrepair(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, {
@@ -5518,12 +5409,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),
@@ -5539,8 +5430,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),