extrait 0.1.0

package/dist/index.js

@@ -0,0 +1,4290 @@
+// src/extract.ts
+import { jsonrepair } from "jsonrepair";
+
+// src/utils/common.ts
+function toErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isWhitespace(char) {
+  return char === " " || char === "\t" || char === `
+` || char === "\r";
+}
+
+// src/markdown.ts
+function extractMarkdownCodeBlocks(input, options = {}) {
+  const wantedLanguage = normalizeLanguage(options.language);
+  const blocks = [];
+  let cursor = 0;
+  while (cursor < input.length) {
+    const lineStart = cursor;
+    const [lineEnd, nextLineStart] = nextLineBounds(input, lineStart);
+    const line = input.slice(lineStart, lineEnd);
+    const opening = parseOpeningFence(line);
+    if (!opening) {
+      cursor = nextLineStart;
+      continue;
+    }
+    const rawLanguage = normalizeLanguage(extractInfoLanguage(opening.info));
+    const contentStart = nextLineStart;
+    let scanCursor = contentStart;
+    let closed = false;
+    while (scanCursor <= input.length) {
+      const closingLineStart = scanCursor;
+      const [closingLineEnd, afterClosingLine] = nextLineBounds(input, closingLineStart);
+      const closingLine = input.slice(closingLineStart, closingLineEnd);
+      const closing = parseClosingFence(closingLine, opening.marker, opening.length);
+      const inlineClosing = parseInlineClosingFence(closingLine, opening.marker, opening.length);
+      if (closing !== null) {
+        if (!wantedLanguage || rawLanguage === wantedLanguage) {
+          blocks.push({
+            language: rawLanguage,
+            code: input.slice(contentStart, closingLineStart).trim(),
+            start: lineStart,
+            end: closingLineStart + closing
+          });
+          if (options.firstOnly) {
+            return blocks;
+          }
+        }
+        cursor = afterClosingLine;
+        closed = true;
+        break;
+      }
+      if (inlineClosing) {
+        if (!wantedLanguage || rawLanguage === wantedLanguage) {
+          blocks.push({
+            language: rawLanguage,
+            code: input.slice(contentStart, closingLineStart + inlineClosing.start).trim(),
+            start: lineStart,
+            end: closingLineStart + inlineClosing.end
+          });
+          if (options.firstOnly) {
+            return blocks;
+          }
+        }
+        cursor = afterClosingLine;
+        closed = true;
+        break;
+      }
+      if (afterClosingLine <= scanCursor) {
+        break;
+      }
+      scanCursor = afterClosingLine;
+    }
+    if (!closed) {
+      cursor = nextLineStart;
+    }
+  }
+  return blocks;
+}
+function extractFirstMarkdownCode(input, options = {}) {
+  return extractMarkdownCodeBlocks(input, { ...options, firstOnly: true })[0] || null;
+}
+function nextLineBounds(input, start) {
+  const newline = input.indexOf(`
+`, start);
+  if (newline === -1) {
+    return [input.length, input.length];
+  }
+  return [newline, newline + 1];
+}
+function parseOpeningFence(line) {
+  const end = stripTrailingCarriageReturn(line);
+  const indent = leadingSpaces(end);
+  if (indent > 3 || indent >= end.length) {
+    return null;
+  }
+  const marker = end[indent];
+  if (marker !== "`" && marker !== "~") {
+    return null;
+  }
+  let fenceEnd = indent;
+  while (fenceEnd < end.length && end[fenceEnd] === marker) {
+    fenceEnd += 1;
+  }
+  const length = fenceEnd - indent;
+  if (length < 3) {
+    return null;
+  }
+  const info = end.slice(fenceEnd).trim();
+  if (marker === "`" && info.includes("`")) {
+    return null;
+  }
+  return { marker, length, info };
+}
+function parseClosingFence(line, marker, openingLength) {
+  const end = stripTrailingCarriageReturn(line);
+  const indent = leadingSpaces(end);
+  if (indent > 3 || indent >= end.length) {
+    return null;
+  }
+  if (end[indent] !== marker) {
+    return null;
+  }
+  let fenceEnd = indent;
+  while (fenceEnd < end.length && end[fenceEnd] === marker) {
+    fenceEnd += 1;
+  }
+  if (fenceEnd - indent < openingLength) {
+    return null;
+  }
+  for (let i = fenceEnd;i < end.length; i += 1) {
+    const char = end[i];
+    if (char !== " " && char !== "\t") {
+      return null;
+    }
+  }
+  return fenceEnd;
+}
+function parseInlineClosingFence(line, marker, openingLength) {
+  const end = stripTrailingCarriageReturn(line);
+  const trimmedEnd = trimRightWhitespaceIndex(end);
+  if (trimmedEnd <= 0) {
+    return null;
+  }
+  let fenceStart = trimmedEnd;
+  while (fenceStart > 0 && end[fenceStart - 1] === marker) {
+    fenceStart -= 1;
+  }
+  const fenceLength = trimmedEnd - fenceStart;
+  if (fenceLength < openingLength) {
+    return null;
+  }
+  if (fenceStart === 0 || isOnlyWhitespace(end.slice(0, fenceStart))) {
+    return null;
+  }
+  return {
+    start: fenceStart,
+    end: trimmedEnd
+  };
+}
+function extractInfoLanguage(info) {
+  if (!info) {
+    return null;
+  }
+  let start = 0;
+  while (start < info.length && isWhitespace(info[start])) {
+    start += 1;
+  }
+  if (start >= info.length) {
+    return null;
+  }
+  let end = start;
+  while (end < info.length && !isWhitespace(info[end])) {
+    end += 1;
+  }
+  let language = info.slice(start, end);
+  if (language.startsWith(".")) {
+    language = language.slice(1);
+  }
+  return language || null;
+}
+function normalizeLanguage(value) {
+  if (!value) {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized || null;
+}
+function leadingSpaces(value) {
+  let count = 0;
+  while (count < value.length && value[count] === " ") {
+    count += 1;
+  }
+  return count;
+}
+function stripTrailingCarriageReturn(value) {
+  if (value.endsWith("\r")) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function trimRightWhitespaceIndex(value) {
+  let end = value.length;
+  while (end > 0 && isWhitespace(value[end - 1])) {
+    end -= 1;
+  }
+  return end;
+}
+function isOnlyWhitespace(value) {
+  for (let i = 0;i < value.length; i += 1) {
+    if (!isWhitespace(value[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// 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);
+  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;
+}
+function looksLikeJsonEnvelope(content, acceptArrays) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("{")) {
+    return true;
+  }
+  if (acceptArrays && trimmed.startsWith("[")) {
+    return true;
+  }
+  return false;
+}
+function languageBonus(language) {
+  if (!language) {
+    return 40;
+  }
+  if (language === "json") {
+    return 140;
+  }
+  if (language === "jsonc" || language === "json5") {
+    return 100;
+  }
+  if (language === "javascript" || language === "typescript" || language === "js" || language === "ts") {
+    return 40;
+  }
+  return 0;
+}
+function jsonShapeScore(content, acceptArrays) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return -100;
+  }
+  const root = trimmed[0];
+  const end = trimmed[trimmed.length - 1];
+  if (root !== "{" && root !== "[") {
+    return -100;
+  }
+  if (root === "[" && !acceptArrays) {
+    return -100;
+  }
+  const expectedEnd = root === "{" ? "}" : "]";
+  let score = 20;
+  if (end === expectedEnd) {
+    score += 20;
+  } else {
+    score -= 30;
+  }
+  score += hasBalancedJsonDelimiters(trimmed) ? 25 : -25;
+  const colonCount = countChar(trimmed, ":");
+  const commaCount = countChar(trimmed, ",");
+  const quoteCount = countChar(trimmed, '"');
+  if (root === "{") {
+    if (/^\{\s*\}$/.test(trimmed)) {
+      score += 12;
+    } else if (colonCount > 0) {
+      score += 22;
+    } else {
+      score -= 30;
+    }
+    if (quoteCount > 0) {
+      score += quoteCount % 2 === 0 ? 8 : -8;
+    }
+  } else {
+    score += /^\[\s*\]$/.test(trimmed) ? 8 : 4;
+    if (colonCount > 0) {
+      score += 4;
+    }
+  }
+  if (commaCount > 0) {
+    score += 4;
+  }
+  const structural = countStructuralChars(trimmed);
+  const ratio = structural / Math.max(trimmed.length, 1);
+  if (ratio >= 0.04 && ratio <= 0.9) {
+    score += 8;
+  } else {
+    score -= 5;
+  }
+  return score;
+}
+function boundaryScore(input, start, end) {
+  const before = start > 0 ? input[start - 1] : "";
+  const after = end < input.length ? input[end] : "";
+  let score = 0;
+  if (isBoundary(before)) {
+    score += 10;
+  }
+  if (isBoundary(after)) {
+    score += 10;
+  }
+  return score;
+}
+function isBoundary(char) {
+  if (!char) {
+    return true;
+  }
+  return /[\s,.;:!?`"'()[\]{}<>]/.test(char);
+}
+function lengthScore(length) {
+  return Math.min(120, Math.floor(Math.sqrt(length) * 6));
+}
+function passesShapeFilter(candidate) {
+  if (candidate.source === "raw") {
+    return true;
+  }
+  if (candidate.source === "fenced") {
+    return candidate.shapeScore >= 0;
+  }
+  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;
+  let quote = null;
+  let escaped = false;
+  for (let i = 0;i < input.length; i += 1) {
+    const char = input[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        inString = false;
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = true;
+      quote = char;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      stack.push(char);
+      continue;
+    }
+    if (char === "}" || char === "]") {
+      const expected = char === "}" ? "{" : "[";
+      const top = stack.pop();
+      if (top !== expected) {
+        return false;
+      }
+    }
+  }
+  return !inString && stack.length === 0;
+}
+function countChar(input, expected) {
+  let count = 0;
+  for (let i = 0;i < input.length; i += 1) {
+    if (input[i] === expected) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function countStructuralChars(input) {
+  let count = 0;
+  for (let i = 0;i < input.length; i += 1) {
+    const char = input[i];
+    if (char === "{" || char === "}" || char === "[" || char === "]" || char === ":" || char === "," || char === '"') {
+      count += 1;
+    }
+  }
+  return count;
+}
+function sortCandidates(candidates) {
+  return [...candidates].sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    if (a.start !== b.start) {
+      return a.start - b.start;
+    }
+    return a.end - b.end;
+  });
+}
+function dedupeCandidates(candidates) {
+  const seen = new Set;
+  return candidates.filter((candidate) => {
+    const key = candidate.content.trim();
+    if (!key || seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+// src/schema.ts
+function formatZodSchemaLikeTypeScript(schema) {
+  return formatType(schema, 0, new WeakSet);
+}
+function formatType(schema, depth, seen) {
+  const unwrapped = unwrap(schema);
+  let result = formatCore(unwrapped.schema, depth, seen);
+  if (unwrapped.nullable) {
+    result = `${result} | null`;
+  }
+  return result;
+}
+function unwrap(schema) {
+  let current = schema;
+  let optional = false;
+  let nullable = false;
+  while (true) {
+    const typeName = current?._def?.typeName;
+    if (!typeName) {
+      break;
+    }
+    if (typeName === "ZodOptional") {
+      optional = true;
+      current = current._def?.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodDefault") {
+      optional = true;
+      current = current._def?.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodNullable") {
+      nullable = true;
+      current = current._def?.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodEffects") {
+      current = current._def?.schema ?? current;
+      continue;
+    }
+    if (typeName === "ZodBranded") {
+      current = current._def?.type ?? current;
+      continue;
+    }
+    if (typeName === "ZodCatch") {
+      current = current._def?.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodReadonly") {
+      current = current._def?.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodPipeline") {
+      current = current._def?.out ?? current;
+      continue;
+    }
+    break;
+  }
+  return {
+    schema: current,
+    optional,
+    nullable
+  };
+}
+function formatCore(schema, depth, seen) {
+  if (seen.has(schema)) {
+    return "unknown";
+  }
+  seen.add(schema);
+  const typeName = schema?._def?.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return isIntegerNumber(schema) ? "int" : "number";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodBigInt":
+      return "bigint";
+    case "ZodDate":
+      return "Date";
+    case "ZodUndefined":
+      return "undefined";
+    case "ZodNull":
+      return "null";
+    case "ZodAny":
+      return "any";
+    case "ZodUnknown":
+      return "unknown";
+    case "ZodNever":
+      return "never";
+    case "ZodVoid":
+      return "void";
+    case "ZodLiteral": {
+      const value = schema._def?.value;
+      return JSON.stringify(value);
+    }
+    case "ZodEnum": {
+      const values = schema._def?.values ?? [];
+      return values.map((value) => JSON.stringify(value)).join(" | ") || "string";
+    }
+    case "ZodNativeEnum": {
+      const values = Object.values(schema._def?.values ?? {});
+      const unique = [...new Set(values.filter((value) => typeof value !== "string" || Number.isNaN(Number(value))))];
+      return unique.map((value) => JSON.stringify(value)).join(" | ") || "string";
+    }
+    case "ZodArray": {
+      const inner = formatType(schema._def?.type ?? schema, depth, seen);
+      return requiresParentheses(inner) ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "ZodTuple": {
+      const items = (schema._def?.items ?? []).map((item) => formatType(item, depth, seen));
+      return `[${items.join(", ")}]`;
+    }
+    case "ZodUnion": {
+      const options = (schema._def?.options ?? []).map((option) => formatType(option, depth, seen));
+      return options.join(" | ") || "unknown";
+    }
+    case "ZodDiscriminatedUnion": {
+      const options = Array.from((schema._def?.options ?? new Map).values()).map((option) => formatType(option, depth, seen));
+      return options.join(" | ") || "unknown";
+    }
+    case "ZodIntersection": {
+      const left = formatType(schema._def?.left ?? schema, depth, seen);
+      const right = formatType(schema._def?.right ?? schema, depth, seen);
+      return `${left} & ${right}`;
+    }
+    case "ZodRecord": {
+      const keyType = formatType(schema._def?.keyType ?? schema, depth, seen);
+      const valueType = formatType(schema._def?.valueType ?? schema, depth, seen);
+      return `Record<${keyType}, ${valueType}>`;
+    }
+    case "ZodMap": {
+      const keyType = formatType(schema._def?.keyType ?? schema, depth, seen);
+      const valueType = formatType(schema._def?.valueType ?? schema, depth, seen);
+      return `Map<${keyType}, ${valueType}>`;
+    }
+    case "ZodSet": {
+      const valueType = formatType(schema._def?.valueType ?? schema, depth, seen);
+      return `Set<${valueType}>`;
+    }
+    case "ZodObject":
+      return formatObject(schema, depth, seen);
+    case "ZodLazy":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function formatObject(schema, depth, seen) {
+  const indent = "  ".repeat(depth);
+  const innerIndent = "  ".repeat(depth + 1);
+  const rawShape = schema._def?.shape;
+  const shape = typeof rawShape === "function" ? rawShape() : rawShape ?? {};
+  const entries = Object.entries(shape);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const lines = entries.map(([key, value]) => {
+    const unwrapped = unwrap(value);
+    const type = formatType(unwrapped.schema, depth + 1, seen);
+    const typeWithNull = unwrapped.nullable ? `${type} | null` : type;
+    const description = readSchemaDescription(value);
+    const descriptionComment = description ? `  // ${description}` : "";
+    return `${innerIndent}${formatKey(key)}: ${typeWithNull},${descriptionComment}`;
+  });
+  return `{
+${lines.join(`
+`)}
+${indent}}`;
+}
+function formatKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function requiresParentheses(typeText) {
+  return typeText.includes(" | ") || typeText.includes(" & ");
+}
+function isIntegerNumber(schema) {
+  const checks = schema._def?.checks ?? [];
+  return checks.some((check) => check.kind === "int");
+}
+function readSchemaDescription(schema) {
+  let current = schema;
+  while (current?._def?.typeName) {
+    const direct = current._def.description;
+    if (typeof direct === "string" && direct.trim().length > 0) {
+      return sanitizeDescription(direct);
+    }
+    const fallback = current.description;
+    if (typeof fallback === "string" && fallback.trim().length > 0) {
+      return sanitizeDescription(fallback);
+    }
+    const typeName = current._def.typeName;
+    if (typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "ZodNullable") {
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodEffects") {
+      current = current._def.schema ?? current;
+      continue;
+    }
+    if (typeName === "ZodBranded") {
+      current = current._def.type ?? current;
+      continue;
+    }
+    if (typeName === "ZodCatch" || typeName === "ZodReadonly") {
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodPipeline") {
+      current = current._def.out ?? current;
+      continue;
+    }
+    break;
+  }
+  return;
+}
+function sanitizeDescription(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+// src/format.ts
+var DEFAULT_SCHEMA_INSTRUCTION = "Strictly follow this schema:";
+function withFormat(schema, options = {}) {
+  const schemaType = formatZodSchemaLikeTypeScript(schema);
+  const instruction = resolveSchemaInstruction(options.schemaInstruction);
+  return [instruction, schemaType].join(`
+`);
+}
+function formatPrompt(schema, task, options = {}) {
+  const trimmedTask = task.trim();
+  if (trimmedTask.length === 0) {
+    return withFormat(schema, options);
+  }
+  return [withFormat(schema, options), "", trimmedTask].join(`
+`);
+}
+function resolveSchemaInstruction(instruction) {
+  const trimmed = instruction?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : DEFAULT_SCHEMA_INSTRUCTION;
+}
+// src/think.ts
+var THINK_TAG_NAME = "think";
+function sanitizeThink(input) {
+  const thinkBlocks = [];
+  const diagnostics = {
+    unterminatedCount: 0,
+    nestedCount: 0,
+    hiddenChars: 0
+  };
+  const visibleParts = [];
+  let cursor = 0;
+  let searchFrom = 0;
+  let depth = 0;
+  let blockStart = -1;
+  let blockContentStart = -1;
+  while (searchFrom < input.length) {
+    const token = findNextThinkTag(input, searchFrom);
+    if (!token) {
+      break;
+    }
+    searchFrom = token.end;
+    if (token.type === "open") {
+      if (depth === 0) {
+        visibleParts.push(input.slice(cursor, token.start));
+        blockStart = token.start;
+        blockContentStart = token.end;
+      } else {
+        diagnostics.nestedCount += 1;
+      }
+      depth += 1;
+      continue;
+    }
+    if (depth === 0) {
+      continue;
+    }
+    depth -= 1;
+    if (depth > 0) {
+      continue;
+    }
+    const raw = input.slice(blockStart, token.end);
+    visibleParts.push(maskKeepingLineBreaks(raw));
+    thinkBlocks.push({
+      id: `think:${thinkBlocks.length}`,
+      content: input.slice(blockContentStart, token.start).trim(),
+      raw,
+      start: blockStart,
+      end: token.end
+    });
+    diagnostics.hiddenChars += countHiddenChars(raw);
+    cursor = token.end;
+    blockStart = -1;
+    blockContentStart = -1;
+  }
+  if (depth > 0 && blockStart >= 0) {
+    const raw = input.slice(blockStart);
+    visibleParts.push(maskKeepingLineBreaks(raw));
+    thinkBlocks.push({
+      id: `think:${thinkBlocks.length}`,
+      content: input.slice(blockContentStart).trim(),
+      raw,
+      start: blockStart,
+      end: input.length
+    });
+    diagnostics.hiddenChars += countHiddenChars(raw);
+    diagnostics.unterminatedCount += 1;
+    cursor = input.length;
+  }
+  if (cursor < input.length) {
+    visibleParts.push(input.slice(cursor));
+  }
+  return {
+    visibleText: visibleParts.join(""),
+    thinkBlocks,
+    diagnostics
+  };
+}
+function findNextThinkTag(input, from) {
+  let cursor = from;
+  while (cursor < input.length) {
+    const lt = input.indexOf("<", cursor);
+    if (lt < 0) {
+      return null;
+    }
+    const token = parseThinkTagAt(input, lt);
+    if (token) {
+      return token;
+    }
+    cursor = lt + 1;
+  }
+  return null;
+}
+function parseThinkTagAt(input, index) {
+  if (input[index] !== "<") {
+    return null;
+  }
+  let cursor = index + 1;
+  let closing = false;
+  if (input[cursor] === "/") {
+    closing = true;
+    cursor += 1;
+  }
+  if (!matchesIgnoreCase(input, cursor, THINK_TAG_NAME)) {
+    return null;
+  }
+  cursor += THINK_TAG_NAME.length;
+  const next = input[cursor];
+  if (next && isIdentifierChar(next)) {
+    return null;
+  }
+  if (closing) {
+    while (cursor < input.length && isWhitespace(input[cursor])) {
+      cursor += 1;
+    }
+    if (input[cursor] !== ">") {
+      return null;
+    }
+    return {
+      type: "close",
+      start: index,
+      end: cursor + 1
+    };
+  }
+  const tagEnd = findTagEnd(input, cursor);
+  return {
+    type: "open",
+    start: index,
+    end: tagEnd >= 0 ? tagEnd : input.length
+  };
+}
+function findTagEnd(input, from) {
+  let quote = null;
+  for (let i = from;i < input.length; i += 1) {
+    const char = input[i];
+    if (quote) {
+      if (char === quote && input[i - 1] !== "\\") {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === ">") {
+      return i + 1;
+    }
+  }
+  return -1;
+}
+function matchesIgnoreCase(input, index, expected) {
+  if (index + expected.length > input.length) {
+    return false;
+  }
+  return input.slice(index, index + expected.length).toLowerCase() === expected;
+}
+function isIdentifierChar(char) {
+  return /[a-zA-Z0-9:_-]/.test(char);
+}
+function countHiddenChars(value) {
+  let count = 0;
+  for (let i = 0;i < value.length; i += 1) {
+    const char = value[i];
+    if (char !== `
+` && char !== "\r") {
+      count += 1;
+    }
+  }
+  return count;
+}
+function maskKeepingLineBreaks(value) {
+  return value.replace(/[^\r\n]/g, " ");
+}
+// src/providers/stream-utils.ts
+async function consumeSSE(response, onEvent) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    while (true) {
+      const boundary = findSSEBoundary(buffer);
+      if (boundary < 0) {
+        break;
+      }
+      const rawEvent = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + (buffer.startsWith(`\r
+\r
+`, boundary) ? 4 : 2));
+      const dataLines = rawEvent.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+      if (dataLines.length === 0) {
+        continue;
+      }
+      onEvent(dataLines.join(`
+`));
+    }
+  }
+  const remainder = buffer.trim();
+  if (remainder.length > 0) {
+    const dataLines = remainder.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+    if (dataLines.length > 0) {
+      onEvent(dataLines.join(`
+`));
+    }
+  }
+}
+function findSSEBoundary(buffer) {
+  const crlfIndex = buffer.indexOf(`\r
+\r
+`);
+  const lfIndex = buffer.indexOf(`
+
+`);
+  if (crlfIndex >= 0 && lfIndex >= 0) {
+    return Math.min(crlfIndex, lfIndex);
+  }
+  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;
+    do {
+      const page = await client.listTools(cursor ? { cursor } : undefined);
+      for (const tool of page.tools ?? []) {
+        listed.push({ client, tool });
+      }
+      cursor = page.nextCursor;
+    } while (cursor);
+  }
+  const collisions = countNameCollisions(listed.map((entry) => entry.tool.name));
+  const tools = [];
+  const byName = new Map;
+  for (const entry of listed) {
+    const name = collisions.get(entry.tool.name) > 1 ? `${sanitizeToolName(entry.client.id)}__${sanitizeToolName(entry.tool.name)}` : sanitizeToolName(entry.tool.name);
+    const resolved = {
+      name,
+      remoteName: entry.tool.name,
+      description: describeTool(entry.client.id, entry.tool, collisions.get(entry.tool.name) > 1),
+      inputSchema: normalizeInputSchema(entry.tool.inputSchema),
+      clientId: entry.client.id,
+      client: entry.client
+    };
+    tools.push(resolved);
+    byName.set(name, resolved);
+  }
+  return {
+    tools,
+    byName
+  };
+}
+function toProviderFunctionTools(toolset) {
+  if (toolset.tools.length === 0) {
+    return;
+  }
+  return toolset.tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+}
+async function executeMCPToolCalls(calls, toolset, context) {
+  const out = [];
+  for (const call of calls) {
+    const callId = call.id;
+    const toolName = call.name;
+    if (!callId || !toolName) {
+      throw new Error("Received a function tool call without id or name.");
+    }
+    const tool = toolset.byName.get(toolName);
+    if (!tool) {
+      throw new Error(`No MCP tool registered for "${toolName}".`);
+    }
+    const parsedArguments = parseToolArguments(call.arguments);
+    const args = isRecord(parsedArguments) ? parsedArguments : {};
+    const metadata = {
+      id: callId,
+      type: call.type ?? "function",
+      name: toolName,
+      arguments: parsedArguments
+    };
+    const startedAt = new Date().toISOString();
+    const startedAtMs = Date.now();
+    try {
+      const output = await tool.client.callTool({
+        name: tool.remoteName,
+        arguments: args
+      });
+      metadata.output = output;
+      const execution = {
+        callId,
+        type: metadata.type,
+        name: toolName,
+        clientId: tool.clientId,
+        remoteName: tool.remoteName,
+        arguments: parsedArguments,
+        output,
+        round: context.round,
+        provider: context.provider,
+        model: context.model,
+        handledLocally: true,
+        startedAt,
+        durationMs: Date.now() - startedAtMs
+      };
+      emitToolExecution(context.request, execution);
+      out.push({ call: metadata, execution });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      metadata.error = message;
+      const execution = {
+        callId,
+        type: metadata.type,
+        name: toolName,
+        clientId: tool.clientId,
+        remoteName: tool.remoteName,
+        arguments: parsedArguments,
+        error: message,
+        round: context.round,
+        provider: context.provider,
+        model: context.model,
+        handledLocally: true,
+        startedAt,
+        durationMs: Date.now() - startedAtMs
+      };
+      emitToolExecution(context.request, execution);
+      out.push({ call: metadata, execution });
+    }
+  }
+  return out;
+}
+function hasMCPClients(clients) {
+  return Array.isArray(clients) && clients.length > 0;
+}
+function normalizeMaxToolRounds(value) {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_MAX_TOOL_ROUNDS;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function parseToolArguments(value) {
+  if (typeof value !== "string") {
+    return value ?? {};
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+function stringifyToolOutput(value) {
+  if (typeof value === "string") {
+    return 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) {
+    out.set(name, (out.get(name) ?? 0) + 1);
+  }
+  return out;
+}
+function normalizeInputSchema(schema) {
+  if (!isRecord(schema)) {
+    return {
+      type: "object",
+      properties: {}
+    };
+  }
+  const out = { ...schema };
+  if (out.type === undefined) {
+    out.type = "object";
+  }
+  if (!isRecord(out.properties)) {
+    out.properties = {};
+  }
+  return out;
+}
+function describeTool(clientId, tool, hasCollision) {
+  const prefix = hasCollision ? `[${clientId}] ` : "";
+  if (tool.description && tool.description.length > 0) {
+    return `${prefix}${tool.description}`;
+  }
+  if (prefix.length > 0) {
+    return `${prefix}${tool.name}`;
+  }
+  return;
+}
+function sanitizeToolName(input) {
+  const sanitized = input.replace(/[^A-Za-z0-9_]/g, "_").replace(/_+/g, "_");
+  const trimmed = sanitized.replace(/^_+/, "").replace(/_+$/, "");
+  if (!trimmed) {
+    return "tool";
+  }
+  if (/^[0-9]/.test(trimmed)) {
+    return `tool_${trimmed}`;
+  }
+  return trimmed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/providers/utils.ts
+function normalizeBaseURL(baseURL) {
+  return baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+}
+function buildURL(baseURL, path) {
+  return new URL(path, normalizeBaseURL(baseURL)).toString();
+}
+function safeJSONParse(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+function cleanUndefined(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== undefined) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function toFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function mergeUsage(base, next) {
+  if (!base && !next) {
+    return;
+  }
+  const inputTokens = addOptional(base?.inputTokens, next?.inputTokens);
+  const outputTokens = addOptional(base?.outputTokens, next?.outputTokens);
+  const totalTokens = addOptional(base?.totalTokens, next?.totalTokens);
+  const cost = addOptional(base?.cost, next?.cost);
+  const merged = {};
+  if (inputTokens !== undefined) {
+    merged.inputTokens = inputTokens;
+  }
+  if (outputTokens !== undefined) {
+    merged.outputTokens = outputTokens;
+  }
+  if (totalTokens !== undefined) {
+    merged.totalTokens = totalTokens;
+  }
+  if (cost !== undefined) {
+    merged.cost = cost;
+  }
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function addOptional(a, b) {
+  if (a === undefined && b === undefined) {
+    return;
+  }
+  return (a ?? 0) + (b ?? 0);
+}
+
+// src/providers/openai-compatible.ts
+function createOpenAICompatibleAdapter(options) {
+  const fetcher = options.fetcher ?? fetch;
+  const path = options.path ?? "/v1/chat/completions";
+  const responsesPath = options.responsesPath ?? "/v1/responses";
+  return {
+    provider: "openai-compatible",
+    model: options.model,
+    async complete(request) {
+      return completeOpenAIRequest(options, fetcher, path, responsesPath, request);
+    },
+    async stream(request, callbacks = {}) {
+      const usesResponses = shouldUseResponsesAPI(options, request);
+      const usesMCP = hasMCPClients(request.mcpClients);
+      if (usesResponses || usesMCP) {
+        return streamViaComplete(callbacks, () => completeOpenAIRequest(options, fetcher, path, responsesPath, request));
+      }
+      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,
+          max_tokens: request.maxTokens,
+          stream: true
+        }))
+      });
+      if (!response.ok) {
+        const message = await response.text();
+        throw new Error(`HTTP ${response.status}: ${message}`);
+      }
+      callbacks.onStart?.();
+      let text = "";
+      let usage;
+      let finishReason;
+      await consumeSSE(response, (data) => {
+        if (data === "[DONE]") {
+          return;
+        }
+        const json = safeJSONParse(data);
+        if (!isRecord2(json)) {
+          return;
+        }
+        const delta = pickAssistantDelta(json);
+        const chunkUsage = pickUsage(json);
+        const chunkFinishReason = pickFinishReason(json);
+        usage = mergeUsage(usage, chunkUsage);
+        if (chunkFinishReason) {
+          finishReason = chunkFinishReason;
+        }
+        if (delta) {
+          text += delta;
+          callbacks.onToken?.(delta);
+        }
+        if (delta || chunkUsage || chunkFinishReason) {
+          const chunk = {
+            textDelta: delta,
+            raw: json,
+            usage: chunkUsage,
+            finishReason: chunkFinishReason
+          };
+          callbacks.onChunk?.(chunk);
+        }
+      });
+      const out = { text, usage, finishReason };
+      callbacks.onComplete?.(out);
+      return out;
+    }
+  };
+}
+async function completeOpenAIRequest(options, fetcher, chatPath, responsesPath, request) {
+  const usesResponses = shouldUseResponsesAPI(options, request);
+  const usesMCP = hasMCPClients(request.mcpClients);
+  if (usesResponses) {
+    if (usesMCP) {
+      return completeWithResponsesAPIWithMCP(options, fetcher, responsesPath, request);
+    }
+    return completeWithResponsesAPIPassThrough(options, fetcher, responsesPath, request);
+  }
+  if (usesMCP) {
+    return completeWithChatCompletionsWithMCP(options, fetcher, chatPath, request);
+  }
+  return completeWithChatCompletionsPassThrough(options, fetcher, chatPath, request);
+}
+async function completeWithChatCompletionsPassThrough(options, fetcher, path, request) {
+  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,
+      max_tokens: request.maxTokens,
+      stream: false
+    }))
+  });
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  const payload = await response.json();
+  const assistantMessage = pickAssistantMessage(payload);
+  if (!assistantMessage) {
+    throw new Error("No assistant message in OpenAI-compatible response.");
+  }
+  const toolCalls = pickChatToolCalls(payload);
+  return {
+    text: pickAssistantText(payload),
+    raw: payload,
+    usage: pickUsage(payload),
+    finishReason: pickFinishReason(payload),
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+  };
+}
+async function completeWithChatCompletionsWithMCP(options, fetcher, path, request) {
+  const mcpToolset = await resolveMCPToolset(request.mcpClients);
+  const transportTools = toProviderFunctionTools(mcpToolset);
+  const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
+  let messages = buildMessages(request);
+  let aggregatedUsage;
+  let finishReason;
+  let lastPayload;
+  const toolCalls = [];
+  const toolExecutions = [];
+  for (let round = 1;round <= maxToolRounds + 1; round += 1) {
+    const response = await fetcher(buildURL(options.baseURL, path), {
+      method: "POST",
+      headers: buildHeaders(options),
+      body: JSON.stringify(cleanUndefined({
+        ...options.defaultBody,
+        ...request.body,
+        model: options.model,
+        messages,
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        tools: transportTools,
+        tool_choice: request.toolChoice,
+        parallel_tool_calls: request.parallelToolCalls
+      }))
+    });
+    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 = pickFinishReason(payload);
+    const assistantMessage = pickAssistantMessage(payload);
+    const calledTools = pickChatToolCalls(payload);
+    if (!assistantMessage) {
+      throw new Error("No assistant message in OpenAI-compatible response.");
+    }
+    if (calledTools.length === 0) {
+      return {
+        text: pickAssistantText(payload),
+        raw: payload,
+        usage: aggregatedUsage,
+        finishReason,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+      };
+    }
+    if (round > maxToolRounds) {
+      throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
+    }
+    const outputs = await executeMCPToolCalls(calledTools, mcpToolset, {
+      round,
+      request,
+      provider: "openai-compatible",
+      model: options.model
+    });
+    toolCalls.push(...outputs.map((entry) => entry.call));
+    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    const toolMessages = outputs.map((entry) => ({
+      role: "tool",
+      tool_call_id: entry.call.id,
+      content: stringifyToolOutput(entry.call.error ? { error: entry.call.error } : entry.call.output)
+    }));
+    messages = [...messages, assistantMessage, ...toolMessages];
+  }
+  return {
+    text: pickAssistantText(lastPayload ?? {}),
+    raw: lastPayload,
+    usage: aggregatedUsage,
+    finishReason,
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+  };
+}
+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,
+      max_output_tokens: request.maxTokens
+    }))
+  });
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  const payload = await response.json();
+  const toolCalls = pickResponsesToolCalls(payload);
+  return {
+    text: pickResponsesText(payload) || pickAssistantText(payload),
+    raw: payload,
+    usage: pickUsage(payload),
+    finishReason: pickResponsesFinishReason(payload) ?? pickFinishReason(payload),
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+  };
+}
+async function completeWithResponsesAPIWithMCP(options, fetcher, path, request) {
+  const mcpToolset = await resolveMCPToolset(request.mcpClients);
+  const transportTools = toResponsesTools(toProviderFunctionTools(mcpToolset));
+  const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
+  let input = buildResponsesInput(request);
+  let previousResponseId = pickString(isRecord2(request.body) ? request.body.previous_response_id : undefined);
+  let aggregatedUsage;
+  let finishReason;
+  let lastPayload;
+  const executedToolCalls = [];
+  const toolExecutions = [];
+  for (let round = 1;round <= maxToolRounds + 1; round += 1) {
+    const response = await fetcher(buildURL(options.baseURL, path), {
+      method: "POST",
+      headers: buildHeaders(options),
+      body: JSON.stringify(cleanUndefined({
+        ...options.defaultBody,
+        ...request.body,
+        model: options.model,
+        input,
+        previous_response_id: previousResponseId,
+        temperature: request.temperature,
+        max_output_tokens: request.maxTokens,
+        tools: transportTools,
+        tool_choice: request.toolChoice,
+        parallel_tool_calls: request.parallelToolCalls
+      }))
+    });
+    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 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
+      };
+    }
+    if (round > maxToolRounds) {
+      throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
+    }
+    const outputs = await executeMCPToolCalls(functionCalls, mcpToolset, {
+      round,
+      request,
+      provider: "openai-compatible",
+      model: options.model
+    });
+    executedToolCalls.push(...outputs.map((entry) => entry.call));
+    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    input = outputs.map((entry) => ({
+      type: "function_call_output",
+      call_id: entry.call.id,
+      output: stringifyToolOutput(entry.call.error ? { error: entry.call.error } : entry.call.output)
+    }));
+    previousResponseId = pickString(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
+  };
+}
+function shouldUseResponsesAPI(options, request) {
+  if (options.path?.includes("/responses")) {
+    return true;
+  }
+  const body = request.body;
+  if (!isRecord2(body)) {
+    return false;
+  }
+  return "input" in body || "previous_response_id" in body;
+}
+function buildHeaders(options) {
+  return {
+    "content-type": "application/json",
+    ...options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {},
+    ...options.headers
+  };
+}
+function buildMessages(request) {
+  const messages = [];
+  if (request.systemPrompt) {
+    messages.push({ role: "system", content: request.systemPrompt });
+  }
+  messages.push({ role: "user", content: request.prompt });
+  return messages;
+}
+function buildResponsesInput(request) {
+  if (isRecord2(request.body) && "input" in request.body) {
+    return request.body.input;
+  }
+  const input = [];
+  if (request.systemPrompt) {
+    input.push({
+      role: "system",
+      content: request.systemPrompt
+    });
+  }
+  input.push({
+    role: "user",
+    content: request.prompt
+  });
+  return input;
+}
+function toResponsesTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return;
+  }
+  return tools.map((tool) => {
+    if (tool.type === "function" && isRecord2(tool.function)) {
+      const functionTool = tool.function;
+      return {
+        type: "function",
+        name: functionTool.name,
+        description: functionTool.description,
+        parameters: functionTool.parameters,
+        strict: functionTool.strict
+      };
+    }
+    return { ...tool };
+  });
+}
+function pickChatToolCalls(payload) {
+  const message = pickAssistantMessage(payload);
+  if (!message) {
+    return [];
+  }
+  const toolCalls = message.tool_calls;
+  if (!Array.isArray(toolCalls)) {
+    return [];
+  }
+  return toolCalls.map((entry) => {
+    if (!isRecord2(entry)) {
+      return { id: "", type: "function" };
+    }
+    const fn = isRecord2(entry.function) ? entry.function : undefined;
+    return {
+      id: pickString(entry.id) ?? "",
+      type: pickString(entry.type) ?? "function",
+      name: pickString(fn?.name),
+      arguments: fn?.arguments
+    };
+  });
+}
+function pickResponsesToolCalls(payload) {
+  const output = payload.output;
+  if (!Array.isArray(output)) {
+    return [];
+  }
+  const calls = [];
+  for (const item of output) {
+    if (!isRecord2(item)) {
+      continue;
+    }
+    const type = pickString(item.type);
+    if (type === "function_call") {
+      calls.push({
+        id: pickString(item.call_id) ?? pickString(item.id) ?? "",
+        type: "function",
+        name: pickString(item.name),
+        arguments: item.arguments
+      });
+      continue;
+    }
+    if (type?.includes("mcp") || type?.includes("tool")) {
+      calls.push({
+        id: pickString(item.id) ?? pickString(item.call_id) ?? "",
+        type,
+        name: pickString(item.name),
+        arguments: item.arguments
+      });
+    }
+  }
+  return calls;
+}
+function pickAssistantMessage(payload) {
+  const choices = payload.choices;
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return;
+  }
+  const first = choices[0];
+  if (!isRecord2(first)) {
+    return;
+  }
+  const message = first.message;
+  if (!isRecord2(message)) {
+    return;
+  }
+  return message;
+}
+function pickAssistantDelta(payload) {
+  const choices = payload.choices;
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return "";
+  }
+  const first = choices[0];
+  if (!isRecord2(first)) {
+    return "";
+  }
+  const delta = first.delta;
+  if (!isRecord2(delta)) {
+    return "";
+  }
+  const content = delta.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (!isRecord2(part)) {
+        return "";
+      }
+      const text = part.text;
+      return typeof text === "string" ? text : "";
+    }).join("");
+  }
+  return "";
+}
+function pickResponsesText(payload) {
+  const outputText = payload.output_text;
+  if (typeof outputText === "string") {
+    return outputText;
+  }
+  const output = payload.output;
+  if (!Array.isArray(output)) {
+    return "";
+  }
+  return output.map((item) => {
+    if (!isRecord2(item)) {
+      return "";
+    }
+    if (typeof item.text === "string") {
+      return item.text;
+    }
+    const content = item.content;
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    return content.map((part) => {
+      if (!isRecord2(part)) {
+        return "";
+      }
+      if (typeof part.text === "string") {
+        return part.text;
+      }
+      if (typeof part.output_text === "string") {
+        return part.output_text;
+      }
+      return "";
+    }).join("");
+  }).join("");
+}
+function pickAssistantText(payload) {
+  const message = pickAssistantMessage(payload);
+  if (message) {
+    const content = message.content;
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.map((part) => {
+        if (typeof part === "string") {
+          return part;
+        }
+        if (!isRecord2(part)) {
+          return "";
+        }
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+      }).join("");
+    }
+  }
+  const choices = payload.choices;
+  if (Array.isArray(choices) && choices.length > 0 && isRecord2(choices[0])) {
+    const legacyText = choices[0].text;
+    if (typeof legacyText === "string") {
+      return legacyText;
+    }
+  }
+  return "";
+}
+function pickUsage(payload) {
+  const usage = payload.usage;
+  if (!isRecord2(usage)) {
+    return;
+  }
+  const promptTokens = toFiniteNumber(usage.prompt_tokens ?? usage.input_tokens);
+  const completionTokens = toFiniteNumber(usage.completion_tokens ?? usage.output_tokens);
+  const totalTokens = toFiniteNumber(usage.total_tokens);
+  return {
+    inputTokens: promptTokens,
+    outputTokens: completionTokens,
+    totalTokens
+  };
+}
+function pickFinishReason(payload) {
+  const choices = payload.choices;
+  if (!Array.isArray(choices) || choices.length === 0 || !isRecord2(choices[0])) {
+    return;
+  }
+  const reason = choices[0].finish_reason;
+  return typeof reason === "string" && reason.length > 0 ? reason : undefined;
+}
+function pickResponsesFinishReason(payload) {
+  const reason = payload.status;
+  if (typeof reason === "string" && reason.length > 0) {
+    return reason;
+  }
+  return;
+}
+async function streamViaComplete(callbacks, complete) {
+  callbacks.onStart?.();
+  const response = await complete();
+  if (response.text.length > 0) {
+    callbacks.onToken?.(response.text);
+  }
+  callbacks.onChunk?.({
+    textDelta: response.text,
+    raw: response.raw,
+    done: true,
+    usage: response.usage,
+    finishReason: response.finishReason
+  });
+  callbacks.onComplete?.(response);
+  return response;
+}
+
+// src/providers/anthropic-compatible.ts
+var DEFAULT_ANTHROPIC_MAX_TOKENS = 1024;
+var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+function createAnthropicCompatibleAdapter(options) {
+  const fetcher = options.fetcher ?? fetch;
+  const path = options.path ?? "/v1/messages";
+  return {
+    provider: "anthropic-compatible",
+    model: options.model,
+    async complete(request) {
+      if (hasMCPClients(request.mcpClients)) {
+        return completeWithMCPToolLoop(options, fetcher, path, request);
+      }
+      return completePassThrough(options, fetcher, path, request);
+    },
+    async stream(request, callbacks = {}) {
+      if (hasMCPClients(request.mcpClients)) {
+        return streamViaComplete2(callbacks, () => this.complete(request));
+      }
+      const response = await fetcher(buildURL(options.baseURL, path), {
+        method: "POST",
+        headers: buildHeaders2(options),
+        body: JSON.stringify(cleanUndefined({
+          ...options.defaultBody,
+          ...request.body,
+          model: options.model,
+          system: request.systemPrompt,
+          messages: [{ role: "user", content: request.prompt }],
+          temperature: request.temperature,
+          max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
+          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 = mergeUsage(usage, chunkUsage);
+        if (chunkFinishReason) {
+          finishReason = chunkFinishReason;
+        }
+        if (delta) {
+          text += delta;
+          callbacks.onToken?.(delta);
+        }
+        if (delta || chunkUsage || chunkFinishReason) {
+          const chunk = {
+            textDelta: delta,
+            raw: json,
+            usage: chunkUsage,
+            finishReason: chunkFinishReason
+          };
+          callbacks.onChunk?.(chunk);
+        }
+      });
+      const out = { text, usage, finishReason };
+      callbacks.onComplete?.(out);
+      return out;
+    }
+  };
+}
+async function completePassThrough(options, fetcher, path, request) {
+  const response = await fetcher(buildURL(options.baseURL, path), {
+    method: "POST",
+    headers: buildHeaders2(options),
+    body: JSON.stringify(cleanUndefined({
+      ...options.defaultBody,
+      ...request.body,
+      model: options.model,
+      system: request.systemPrompt,
+      messages: [{ role: "user", content: request.prompt }],
+      temperature: request.temperature,
+      max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
+      stream: false
+    }))
+  });
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`HTTP ${response.status}: ${message}`);
+  }
+  const data = await response.json();
+  const text = extractAnthropicText(data);
+  const toolCalls = pickAnthropicToolCalls(data);
+  if (!text && toolCalls.length === 0) {
+    throw new Error("No assistant text in Anthropic-compatible response.");
+  }
+  return {
+    text,
+    raw: data,
+    usage: pickUsage2(data),
+    finishReason: pickFinishReason2(data),
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+  };
+}
+async function completeWithMCPToolLoop(options, fetcher, path, request) {
+  const mcpToolset = await resolveMCPToolset(request.mcpClients);
+  const tools = toAnthropicTools(toProviderFunctionTools(mcpToolset));
+  const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
+  let messages = [{ role: "user", content: request.prompt }];
+  let aggregatedUsage;
+  let finishReason;
+  let lastPayload;
+  const toolCalls = [];
+  const toolExecutions = [];
+  for (let round = 1;round <= maxToolRounds + 1; round += 1) {
+    const response = await fetcher(buildURL(options.baseURL, path), {
+      method: "POST",
+      headers: buildHeaders2(options),
+      body: JSON.stringify(cleanUndefined({
+        ...options.defaultBody,
+        ...request.body,
+        model: options.model,
+        system: request.systemPrompt,
+        messages,
+        temperature: request.temperature,
+        max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
+        tools,
+        tool_choice: toAnthropicToolChoice(request.toolChoice),
+        stream: false
+      }))
+    });
+    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, pickUsage2(payload));
+    finishReason = pickFinishReason2(payload);
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    const calledTools = pickAnthropicToolCalls(payload).filter((call) => call.type === "function");
+    if (calledTools.length === 0) {
+      return {
+        text: extractAnthropicText(payload),
+        raw: payload,
+        usage: aggregatedUsage,
+        finishReason,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+      };
+    }
+    if (round > maxToolRounds) {
+      throw new Error(`Tool call loop exceeded maxToolRounds (${maxToolRounds}).`);
+    }
+    const toolResultContent = [];
+    const outputs = await executeMCPToolCalls(calledTools, mcpToolset, {
+      round,
+      request,
+      provider: "anthropic-compatible",
+      model: options.model
+    });
+    toolCalls.push(...outputs.map((entry) => entry.call));
+    toolExecutions.push(...outputs.map((entry) => entry.execution));
+    for (const entry of outputs) {
+      toolResultContent.push({
+        type: "tool_result",
+        tool_use_id: entry.call.id,
+        ...entry.call.error ? { is_error: true } : {},
+        content: stringifyToolOutput(entry.call.error ? { error: entry.call.error } : entry.call.output)
+      });
+    }
+    messages = [
+      ...messages,
+      { role: "assistant", content },
+      { role: "user", content: toolResultContent }
+    ];
+  }
+  return {
+    text: extractAnthropicText(lastPayload ?? {}),
+    raw: lastPayload,
+    usage: aggregatedUsage,
+    finishReason,
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    toolExecutions: toolExecutions.length > 0 ? toolExecutions : undefined
+  };
+}
+function buildHeaders2(options) {
+  return {
+    "content-type": "application/json",
+    ...options.apiKey ? { "x-api-key": options.apiKey } : {},
+    "anthropic-version": options.version ?? DEFAULT_ANTHROPIC_VERSION,
+    ...options.headers
+  };
+}
+function resolveMaxTokens(value, fallback) {
+  const requested = toFiniteNumber(value);
+  if (requested !== undefined && requested > 0) {
+    return Math.floor(requested);
+  }
+  const configured = toFiniteNumber(fallback);
+  if (configured !== undefined && configured > 0) {
+    return Math.floor(configured);
+  }
+  return DEFAULT_ANTHROPIC_MAX_TOKENS;
+}
+function extractAnthropicText(payload) {
+  const content = payload.content;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => {
+    if (!isRecord2(part) || part.type !== "text") {
+      return "";
+    }
+    const text = part.text;
+    return typeof text === "string" ? text : "";
+  }).join("");
+}
+function pickAnthropicToolCalls(payload) {
+  const content = payload.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const calls = [];
+  for (const part of content) {
+    if (!isRecord2(part) || part.type !== "tool_use") {
+      continue;
+    }
+    calls.push({
+      id: pickString(part.id) ?? "",
+      type: "function",
+      name: pickString(part.name),
+      arguments: part.input
+    });
+  }
+  return calls;
+}
+function pickAnthropicDelta(payload) {
+  const deltaObject = payload.delta;
+  if (isRecord2(deltaObject) && typeof deltaObject.text === "string") {
+    return deltaObject.text;
+  }
+  const contentBlock = payload.content_block;
+  if (isRecord2(contentBlock) && typeof contentBlock.text === "string") {
+    return contentBlock.text;
+  }
+  return "";
+}
+function pickUsage2(payload) {
+  const fromUsage = extractUsageObject(payload.usage);
+  if (fromUsage) {
+    return fromUsage;
+  }
+  if (isRecord2(payload.message)) {
+    const nested = extractUsageObject(payload.message.usage);
+    if (nested) {
+      return nested;
+    }
+  }
+  if (isRecord2(payload.delta)) {
+    const nested = extractUsageObject(payload.delta.usage);
+    if (nested) {
+      return nested;
+    }
+  }
+  return;
+}
+function pickFinishReason2(payload) {
+  const direct = payload.stop_reason;
+  if (typeof direct === "string" && direct.length > 0) {
+    return direct;
+  }
+  if (isRecord2(payload.delta)) {
+    const reason = payload.delta.stop_reason;
+    if (typeof reason === "string" && reason.length > 0) {
+      return reason;
+    }
+  }
+  if (isRecord2(payload.message)) {
+    const reason = payload.message.stop_reason;
+    if (typeof reason === "string" && reason.length > 0) {
+      return reason;
+    }
+  }
+  return;
+}
+function extractUsageObject(value) {
+  if (!isRecord2(value)) {
+    return;
+  }
+  return {
+    inputTokens: toFiniteNumber(value.input_tokens ?? value.prompt_tokens),
+    outputTokens: toFiniteNumber(value.output_tokens ?? value.completion_tokens),
+    totalTokens: toFiniteNumber(value.total_tokens)
+  };
+}
+function toAnthropicTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return;
+  }
+  return tools.filter((tool) => tool.type === "function" && isRecord2(tool.function)).map((tool) => {
+    const functionTool = tool.function;
+    return {
+      name: functionTool.name,
+      description: functionTool.description,
+      input_schema: functionTool.parameters ?? { type: "object", properties: {} }
+    };
+  });
+}
+function toAnthropicToolChoice(value) {
+  if (value === undefined) {
+    return;
+  }
+  if (value === "required") {
+    return { type: "any" };
+  }
+  if (isRecord2(value) && value.type === "function") {
+    const maybeFn = value.function;
+    if (isRecord2(maybeFn)) {
+      const name = pickString(maybeFn.name);
+      if (name) {
+        return { type: "tool", name };
+      }
+    }
+  }
+  return value;
+}
+async function streamViaComplete2(callbacks, complete) {
+  callbacks.onStart?.();
+  const response = await complete();
+  if (response.text.length > 0) {
+    callbacks.onToken?.(response.text);
+  }
+  callbacks.onChunk?.({
+    textDelta: response.text,
+    raw: response.raw,
+    done: true,
+    usage: response.usage,
+    finishReason: response.finishReason
+  });
+  callbacks.onComplete?.(response);
+  return response;
+}
+
+// src/providers/registry.ts
+class InMemoryProviderRegistry {
+  factories = new Map;
+  register(kind, factory) {
+    this.factories.set(kind, factory);
+  }
+  create(kind, options) {
+    const factory = this.factories.get(kind);
+    if (!factory) {
+      throw new Error(`Unknown provider kind: ${kind}`);
+    }
+    return factory(options);
+  }
+  has(kind) {
+    return this.factories.has(kind);
+  }
+  list() {
+    return [...this.factories.keys()].sort();
+  }
+}
+function createProviderRegistry() {
+  return new InMemoryProviderRegistry;
+}
+function registerBuiltinProviders(registry) {
+  registry.register("openai-compatible", createOpenAICompatibleAdapter);
+  registry.register("anthropic-compatible", createAnthropicCompatibleAdapter);
+  return registry;
+}
+function createDefaultProviderRegistry() {
+  return registerBuiltinProviders(createProviderRegistry());
+}
+function createModelAdapter(config, registry = createDefaultProviderRegistry()) {
+  const providerOptions = buildProviderOptions(config);
+  return registry.create(config.provider, providerOptions);
+}
+function buildProviderOptions(config) {
+  const transport = {
+    ...config.transport,
+    baseURL: config.transport?.baseURL ?? config.baseURL,
+    apiKey: config.transport?.apiKey ?? config.apiKey
+  };
+  if (config.provider === "openai-compatible") {
+    const options = {
+      model: config.model,
+      baseURL: transport.baseURL ?? "https://api.openai.com",
+      apiKey: transport.apiKey,
+      path: transport.path,
+      headers: transport.headers,
+      defaultBody: transport.defaultBody,
+      fetcher: transport.fetcher
+    };
+    return options;
+  }
+  if (config.provider === "anthropic-compatible") {
+    const options = {
+      model: config.model,
+      baseURL: transport.baseURL ?? "https://api.anthropic.com",
+      apiKey: transport.apiKey,
+      path: transport.path,
+      headers: transport.headers,
+      version: transport.version,
+      defaultBody: transport.defaultBody,
+      fetcher: transport.fetcher
+    };
+    return options;
+  }
+  return {
+    model: config.model,
+    ...transport,
+    ...config.options ?? {}
+  };
+}
+
+// src/structured.ts
+import { jsonrepair as jsonrepair3 } from "jsonrepair";
+
+// src/outdent.ts
+var DEFAULT_OPTIONS = {
+  trimLeadingNewline: true,
+  trimTrailingNewline: true,
+  newline: null
+};
+function isIndentChar(char) {
+  return char === " " || char === "\t";
+}
+function normalizeNewlines(text, newline) {
+  let result = "";
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "\r") {
+      if (text[index + 1] === `
+`) {
+        index += 1;
+      }
+      result += newline;
+      continue;
+    }
+    if (char === `
+`) {
+      result += newline;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+function detectIndentationFromFirstSegment(segment) {
+  for (let index = 0;index < segment.length; index += 1) {
+    if (segment.charAt(index) !== `
+`) {
+      continue;
+    }
+    let cursor = index + 1;
+    let indentation = 0;
+    while (cursor < segment.length && isIndentChar(segment.charAt(cursor))) {
+      indentation += 1;
+      cursor += 1;
+    }
+    if (cursor === segment.length) {
+      return indentation;
+    }
+    if (segment.charAt(cursor) !== `
+`) {
+      return indentation;
+    }
+  }
+  return 0;
+}
+function removeIndentAfterNewlines(segment, indentation) {
+  if (indentation <= 0) {
+    return segment;
+  }
+  let result = "";
+  for (let index = 0;index < segment.length; index += 1) {
+    const char = segment.charAt(index);
+    result += char;
+    if (char !== `
+`) {
+      continue;
+    }
+    let removed = 0;
+    while (index + 1 < segment.length && removed < indentation && isIndentChar(segment.charAt(index + 1))) {
+      index += 1;
+      removed += 1;
+    }
+  }
+  return result;
+}
+function trimLeadingNewline(segment) {
+  let index = 0;
+  while (index < segment.length && isIndentChar(segment.charAt(index))) {
+    index += 1;
+  }
+  if (segment.charAt(index) === `
+`) {
+    return segment.slice(index + 1);
+  }
+  return segment;
+}
+function trimTrailingNewline(segment) {
+  let end = segment.length;
+  while (end > 0 && isIndentChar(segment.charAt(end - 1))) {
+    end -= 1;
+  }
+  if (end > 0 && segment.charAt(end - 1) === `
+`) {
+    return segment.slice(0, end - 1);
+  }
+  return segment;
+}
+function processSegments(inputSegments, options) {
+  const segments = inputSegments.map((segment) => {
+    if (typeof options.newline === "string") {
+      return normalizeNewlines(segment, options.newline);
+    }
+    return segment;
+  });
+  const indentation = detectIndentationFromFirstSegment(segments[0] ?? "");
+  const outdented = segments.map((segment) => removeIndentAfterNewlines(segment, indentation));
+  if (options.trimLeadingNewline && outdented.length > 0) {
+    outdented[0] = trimLeadingNewline(outdented[0] ?? "");
+  }
+  if (options.trimTrailingNewline && outdented.length > 0) {
+    const lastIndex = outdented.length - 1;
+    outdented[lastIndex] = trimTrailingNewline(outdented[lastIndex] ?? "");
+  }
+  return outdented;
+}
+function concatTemplate(strings, values) {
+  let output = "";
+  for (let index = 0;index < strings.length; index += 1) {
+    output += strings[index] ?? "";
+    if (index < values.length) {
+      output += String(values[index]);
+    }
+  }
+  return output;
+}
+function createOutdent(options = {}) {
+  const resolvedOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  const outdent = (strings, ...values) => {
+    const processed = processSegments(strings, resolvedOptions);
+    return concatTemplate(processed, values);
+  };
+  outdent.string = (input) => {
+    return processSegments([input], resolvedOptions)[0] ?? "";
+  };
+  return outdent;
+}
+
+// src/parse.ts
+import { jsonrepair as jsonrepair2 } from "jsonrepair";
+function parseLLMOutput(output, schema, options = {}) {
+  const sanitized = sanitizeThink(output);
+  const parseOptions = {
+    repair: options.repair ?? true,
+    maxCandidates: options.maxCandidates ?? 5,
+    acceptArrays: options.acceptArrays ?? true,
+    extraction: options.extraction,
+    onTrace: options.onTrace
+  };
+  const candidates = extractJsonCandidates(sanitized.visibleText, {
+    maxCandidates: parseOptions.maxCandidates,
+    acceptArrays: parseOptions.acceptArrays,
+    allowRepairHints: parseOptions.repair,
+    heuristics: parseOptions.extraction
+  });
+  emitTrace(parseOptions.onTrace, {
+    stage: "extract",
+    level: "info",
+    message: `Extracted ${candidates.length} candidate(s).`,
+    details: {
+      maxCandidates: parseOptions.maxCandidates,
+      thinkBlocks: sanitized.thinkBlocks.length,
+      thinkDiagnostics: sanitized.diagnostics
+    }
+  });
+  const errors = [];
+  const diagnostics = [];
+  let bestIssues = [];
+  let bestCandidate = candidates[0] ?? null;
+  let bestParsed = null;
+  let bestRepaired = null;
+  for (const candidate of candidates) {
+    const parseAttempt = parseAttemptFromHint(candidate.parseHint, parseOptions.repair) ?? tryParseJsonCandidate(candidate.content, parseOptions.repair);
+    if (!parseAttempt.success) {
+      const diagnostic = {
+        candidateId: candidate.id,
+        source: candidate.source,
+        usedRepair: parseAttempt.usedRepair,
+        parseSuccess: false,
+        validationSuccess: false,
+        selected: false,
+        stage: parseAttempt.stage,
+        message: parseAttempt.error
+      };
+      diagnostics.push(diagnostic);
+      errors.push({
+        stage: parseAttempt.stage,
+        message: parseAttempt.error,
+        candidateId: candidate.id
+      });
+      emitTrace(parseOptions.onTrace, {
+        stage: parseAttempt.stage,
+        level: "error",
+        message: parseAttempt.error,
+        candidateId: candidate.id
+      });
+      continue;
+    }
+    emitTrace(parseOptions.onTrace, {
+      stage: "parse",
+      level: "info",
+      message: parseAttempt.usedRepair ? "Candidate parsed after repair." : "Candidate parsed without repair.",
+      candidateId: candidate.id,
+      details: {
+        usedRepair: parseAttempt.usedRepair
+      }
+    });
+    const validated = schema.safeParse(parseAttempt.parsed);
+    if (validated.success) {
+      const selectedDiagnostic = {
+        candidateId: candidate.id,
+        source: candidate.source,
+        usedRepair: parseAttempt.usedRepair,
+        parseSuccess: true,
+        validationSuccess: true,
+        selected: true,
+        stage: "success"
+      };
+      diagnostics.push(selectedDiagnostic);
+      emitTrace(parseOptions.onTrace, {
+        stage: "result",
+        level: "info",
+        message: `Validation succeeded on candidate ${candidate.id}.`,
+        candidateId: candidate.id
+      });
+      return {
+        success: true,
+        data: validated.data,
+        raw: output,
+        sanitizedRaw: sanitized.visibleText,
+        thinkBlocks: sanitized.thinkBlocks,
+        thinkDiagnostics: sanitized.diagnostics,
+        parsed: parseAttempt.parsed,
+        candidate,
+        repaired: parseAttempt.repaired,
+        candidates,
+        diagnostics,
+        errors,
+        zodIssues: []
+      };
+    }
+    const issues = validated.error.issues;
+    const message = formatZodIssues(issues);
+    const validationDiagnostic = {
+      candidateId: candidate.id,
+      source: candidate.source,
+      usedRepair: parseAttempt.usedRepair,
+      parseSuccess: true,
+      validationSuccess: false,
+      selected: false,
+      stage: "validate",
+      message,
+      zodIssues: issues
+    };
+    diagnostics.push(validationDiagnostic);
+    if (bestIssues.length === 0 || issues.length < bestIssues.length) {
+      bestIssues = issues;
+      bestCandidate = candidate;
+      bestParsed = parseAttempt.parsed;
+      bestRepaired = parseAttempt.repaired;
+    }
+    errors.push({
+      stage: "validate",
+      message,
+      candidateId: candidate.id,
+      details: issues
+    });
+    emitTrace(parseOptions.onTrace, {
+      stage: "validate",
+      level: "error",
+      message: `Validation failed on candidate ${candidate.id}.`,
+      candidateId: candidate.id,
+      details: {
+        issuesCount: issues.length
+      }
+    });
+  }
+  if (candidates.length === 0) {
+    const message = "No JSON candidate was extracted.";
+    errors.push({
+      stage: "extract",
+      message
+    });
+    emitTrace(parseOptions.onTrace, {
+      stage: "extract",
+      level: "error",
+      message
+    });
+  }
+  markSelectedDiagnostic(diagnostics, bestCandidate?.id ?? null);
+  emitTrace(parseOptions.onTrace, {
+    stage: "result",
+    level: "error",
+    message: "No candidate could be validated.",
+    details: {
+      candidateCount: candidates.length,
+      errors: errors.length
+    }
+  });
+  return {
+    success: false,
+    data: null,
+    raw: output,
+    sanitizedRaw: sanitized.visibleText,
+    thinkBlocks: sanitized.thinkBlocks,
+    thinkDiagnostics: sanitized.diagnostics,
+    parsed: bestParsed,
+    candidate: bestCandidate,
+    repaired: bestRepaired,
+    candidates,
+    diagnostics,
+    errors,
+    zodIssues: bestIssues
+  };
+}
+function tryParseJsonCandidate(input, allowRepair) {
+  try {
+    return {
+      success: true,
+      parsed: JSON.parse(input),
+      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 = jsonrepair2(input);
+  } 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)
+    };
+  }
+}
+function parseAttemptFromHint(hint, allowRepair) {
+  if (!hint) {
+    return null;
+  }
+  if (hint.success) {
+    if (hint.usedRepair && !allowRepair) {
+      return null;
+    }
+    return {
+      success: true,
+      parsed: hint.parsed,
+      repaired: hint.repaired,
+      usedRepair: hint.usedRepair,
+      stage: "parse",
+      error: ""
+    };
+  }
+  if (hint.usedRepair) {
+    if (!allowRepair) {
+      return null;
+    }
+    return {
+      success: false,
+      parsed: null,
+      repaired: hint.repaired,
+      usedRepair: true,
+      stage: hint.stage,
+      error: hint.error
+    };
+  }
+  if (allowRepair) {
+    return null;
+  }
+  return {
+    success: false,
+    parsed: null,
+    repaired: null,
+    usedRepair: false,
+    stage: "parse",
+    error: hint.error
+  };
+}
+function markSelectedDiagnostic(diagnostics, selectedCandidateId) {
+  if (!selectedCandidateId) {
+    return;
+  }
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.candidateId === selectedCandidateId) {
+      diagnostic.selected = true;
+      return;
+    }
+  }
+}
+function emitTrace(onTrace, event) {
+  onTrace?.(event);
+}
+function formatZodIssues(issues) {
+  if (issues.length === 0) {
+    return "Validation failed without details.";
+  }
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  }).join(`
+`);
+}
+
+// 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/structured.ts
+class StructuredParseError extends Error {
+  name = "StructuredParseError";
+  raw;
+  thinkBlocks;
+  candidates;
+  zodIssues;
+  repairLog;
+  attempt;
+  constructor(input) {
+    super(input.message ?? `Structured parsing failed after ${input.attempt} attempt(s).`);
+    this.raw = input.raw;
+    this.thinkBlocks = input.thinkBlocks;
+    this.candidates = input.candidates;
+    this.zodIssues = input.zodIssues;
+    this.repairLog = input.repairLog;
+    this.attempt = input.attempt;
+  }
+}
+var DEFAULT_STRUCTURED_OBJECT_INSTRUCTION = "Return exactly one strict JSON object.";
+var DEFAULT_STRUCTURED_STYLE_INSTRUCTION = "No prose. No markdown.";
+var DEFAULT_SELF_HEAL_PROMPT_TEXT = {
+  fixInstruction: "Fix the following output so it validates against the schema.",
+  returnInstruction: "Return only the corrected JSON object.",
+  noIssuesMessage: "No detailed validation issues",
+  validationErrorsLabel: "Validation errors:",
+  rawOutputLabel: "Raw output to fix:",
+  contextLabel: "Self-heal context JSON:"
+};
+var DEFAULT_SELF_HEAL_FIX_INSTRUCTION = DEFAULT_SELF_HEAL_PROMPT_TEXT.fixInstruction;
+var DEFAULT_SELF_HEAL_RETURN_INSTRUCTION = DEFAULT_SELF_HEAL_PROMPT_TEXT.returnInstruction;
+var DEFAULT_SELF_HEAL_NO_ISSUES_MESSAGE = DEFAULT_SELF_HEAL_PROMPT_TEXT.noIssuesMessage;
+var DEFAULT_SELF_HEAL_VALIDATION_LABEL = DEFAULT_SELF_HEAL_PROMPT_TEXT.validationErrorsLabel;
+var DEFAULT_SELF_HEAL_RAW_OUTPUT_LABEL = DEFAULT_SELF_HEAL_PROMPT_TEXT.rawOutputLabel;
+var DEFAULT_SELF_HEAL_CONTEXT_LABEL = DEFAULT_SELF_HEAL_PROMPT_TEXT.contextLabel;
+var DEFAULT_SELF_HEAL_PROTOCOL = "extrait.self-heal.v2";
+var DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS = 12000;
+var DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS = true;
+var DEFAULT_SELF_HEAL_MAX_ERRORS = 8;
+var DEFAULT_SELF_HEAL_MAX_DIAGNOSTICS = 8;
+var structuredOutdent = createOutdent({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true,
+  newline: `
+`
+});
+var DEFAULT_STRICT_PARSE_OPTIONS = {
+  repair: false,
+  maxCandidates: 3,
+  acceptArrays: true
+};
+var DEFAULT_LOOSE_PARSE_OPTIONS = {
+  repair: true,
+  maxCandidates: 5,
+  acceptArrays: true
+};
+var DEFAULT_SELF_HEAL_BY_MODE = {
+  loose: { enabled: true, maxAttempts: 1 },
+  strict: { enabled: false, maxAttempts: 0 }
+};
+function buildDefaultStructuredPrompt(task, options = {}) {
+  const objectInstruction = resolvePromptLine(options.objectInstruction, DEFAULT_STRUCTURED_OBJECT_INSTRUCTION);
+  const styleInstruction = resolvePromptLine(options.styleInstruction, DEFAULT_STRUCTURED_STYLE_INSTRUCTION);
+  return [task.trim(), "", objectInstruction, styleInstruction].join(`
+`);
+}
+function buildSelfHealPrompt(input) {
+  const text = resolveSelfHealPromptText(input.text);
+  const issueText = input.issues.length > 0 ? formatZodIssues(input.issues) : text.noIssuesMessage;
+  const outputFormat = withFormat(input.schema, {
+    schemaInstruction: input.schemaInstruction
+  });
+  const maxContextChars = normalizePositiveInt(input.maxContextChars, DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS);
+  const selectedOutput = input.selectedOutput ?? input.rawOutput;
+  const contextPayload = {
+    protocol: DEFAULT_SELF_HEAL_PROTOCOL,
+    attempt: input.attempt,
+    previousAttempt: input.previousAttempt,
+    selectedInput: input.selectedInput ?? "raw",
+    issueSummary: issueText,
+    validationIssues: input.issues.map((issue) => ({
+      path: formatIssuePath(issue.path),
+      code: issue.code,
+      message: issue.message,
+      expected: "expected" in issue ? issue.expected : undefined,
+      received: "received" in issue ? issue.received : undefined
+    })),
+    parserErrors: (input.parserErrors ?? []).map((error) => ({
+      stage: error.stage,
+      message: error.message,
+      candidateId: error.candidateId
+    })),
+    diagnostics: (input.diagnostics ?? []).map((diagnostic) => ({
+      candidateId: diagnostic.candidateId,
+      stage: diagnostic.stage,
+      usedRepair: diagnostic.usedRepair,
+      message: diagnostic.message
+    })),
+    repairLog: input.repairLog ?? [],
+    selectedOutput: truncateForPrompt(selectedOutput, maxContextChars),
+    sanitizedOutput: input.sanitizedOutput ? truncateForPrompt(input.sanitizedOutput, maxContextChars) : undefined,
+    rawOutput: truncateForPrompt(input.rawOutput, maxContextChars)
+  };
+  return [
+    text.fixInstruction,
+    text.returnInstruction,
+    "",
+    outputFormat,
+    "",
+    text.validationErrorsLabel,
+    issueText,
+    "",
+    text.rawOutputLabel,
+    truncateForPrompt(input.rawOutput, maxContextChars),
+    "",
+    text.contextLabel,
+    JSON.stringify(contextPayload, null, 2)
+  ].join(`
+`);
+}
+async function structured(adapter, schemaOrOptions, promptInput, callOptions) {
+  const normalized = normalizeStructuredInput(schemaOrOptions, promptInput, callOptions);
+  const mode = normalized.mode ?? "loose";
+  const selfHealConfig = normalizeSelfHealConfig(normalized.selfHeal, mode);
+  const parseOptions = mergeParseOptions(mode, normalized.parse);
+  const streamConfig = normalizeStreamConfig(normalized.stream);
+  const debugConfig = normalizeDebugConfig(normalized.debug);
+  const attempts = [];
+  const useOutdent = normalized.outdent ?? true;
+  const resolvedPrompt = applyPromptOutdent(resolvePrompt(normalized.prompt, { mode }), useOutdent);
+  const resolvedSystemPrompt = applyOutdentToOptionalPrompt(normalized.systemPrompt, useOutdent);
+  const prompt = shouldInjectFormat(resolvedPrompt.prompt, normalized.schemaInstruction) ? formatPrompt(normalized.schema, resolvedPrompt.prompt, {
+    schemaInstruction: normalized.schemaInstruction
+  }) : resolvedPrompt.prompt.trim();
+  const systemPrompt = mergeSystemPrompts(resolvedPrompt.systemPrompt, resolvedSystemPrompt);
+  const first = await executeAttempt(adapter, {
+    prompt,
+    schema: normalized.schema,
+    parseOptions,
+    stream: streamConfig,
+    request: normalized.request,
+    systemPrompt,
+    observe: normalized.observe,
+    debug: debugConfig,
+    attemptNumber: 1,
+    selfHeal: false,
+    selfHealEnabled: selfHealConfig.enabled
+  });
+  attempts.push(first.trace);
+  if (first.trace.success) {
+    return buildSuccessResult(first.trace.parsed.data, attempts);
+  }
+  if (!selfHealConfig.enabled) {
+    throw toStructuredError(attempts.at(-1));
+  }
+  for (let index = 0;index < selfHealConfig.maxAttempts; index += 1) {
+    const previous = attempts.at(-1);
+    if (!previous) {
+      break;
+    }
+    const attemptNumber = index + 2;
+    emitObserve(normalized.observe, {
+      stage: "self-heal",
+      attempt: attemptNumber,
+      selfHeal: true,
+      message: "Starting self-heal attempt.",
+      details: {
+        previousIssues: previous.zodIssues.length
+      }
+    });
+    const selfHealSource = resolveSelfHealSource(previous);
+    const repairPrompt = buildSelfHealPrompt({
+      rawOutput: previous.raw,
+      issues: previous.zodIssues,
+      schema: normalized.schema,
+      schemaInstruction: normalized.schemaInstruction,
+      selectedOutput: selfHealSource.text,
+      selectedInput: selfHealSource.kind,
+      sanitizedOutput: previous.parsed.sanitizedRaw,
+      parserErrors: previous.parsed.errors.slice(0, DEFAULT_SELF_HEAL_MAX_ERRORS).map((error) => ({
+        stage: error.stage,
+        message: error.message,
+        candidateId: error.candidateId
+      })),
+      diagnostics: previous.parsed.diagnostics.slice(0, DEFAULT_SELF_HEAL_MAX_DIAGNOSTICS).map((diagnostic) => ({
+        candidateId: diagnostic.candidateId,
+        stage: diagnostic.stage,
+        usedRepair: diagnostic.usedRepair,
+        message: diagnostic.message
+      })),
+      repairLog: previous.repairLog,
+      attempt: attemptNumber,
+      previousAttempt: previous.attempt,
+      maxContextChars: selfHealConfig.maxContextChars
+    });
+    const healed = await executeAttempt(adapter, {
+      prompt: repairPrompt,
+      schema: normalized.schema,
+      parseOptions,
+      stream: streamConfig,
+      request: normalized.request,
+      systemPrompt,
+      observe: normalized.observe,
+      debug: debugConfig,
+      attemptNumber,
+      selfHeal: true,
+      selfHealEnabled: selfHealConfig.enabled
+    });
+    attempts.push(healed.trace);
+    if (healed.trace.success) {
+      return buildSuccessResult(healed.trace.parsed.data, attempts);
+    }
+    if (selfHealConfig.stopOnNoProgress && isSelfHealStalled(previous, healed.trace)) {
+      emitObserve(normalized.observe, {
+        stage: "self-heal",
+        attempt: attemptNumber,
+        selfHeal: true,
+        message: "Stopping self-heal: no progress detected.",
+        details: {
+          previousIssues: previous.zodIssues.length,
+          currentIssues: healed.trace.zodIssues.length
+        }
+      });
+      break;
+    }
+  }
+  throw toStructuredError(attempts.at(-1));
+}
+function normalizeStructuredInput(schemaOrOptions, promptInput, callOptions) {
+  if (isStructuredOptions(schemaOrOptions)) {
+    return schemaOrOptions;
+  }
+  if (!promptInput) {
+    throw new Error("Missing prompt in structured(adapter, schema, prompt, options?) call.");
+  }
+  return {
+    ...callOptions ?? {},
+    schema: schemaOrOptions,
+    prompt: promptInput
+  };
+}
+function isStructuredOptions(value) {
+  return typeof value === "object" && value !== null && "schema" in value && "prompt" in value;
+}
+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 isPromptResolver(value) {
+  return typeof value === "object" && value !== null && "resolvePrompt" in value && typeof value.resolvePrompt === "function";
+}
+function normalizePromptPayload(value) {
+  if (typeof value.prompt !== "string") {
+    throw new Error("Structured prompt payload must include a string prompt.");
+  }
+  return {
+    prompt: value.prompt,
+    systemPrompt: typeof value.systemPrompt === "string" ? value.systemPrompt : undefined
+  };
+}
+function applyPromptOutdent(payload, enabled) {
+  if (!enabled) {
+    return payload;
+  }
+  return {
+    prompt: structuredOutdent.string(payload.prompt),
+    systemPrompt: applyOutdentToOptionalPrompt(payload.systemPrompt, enabled)
+  };
+}
+function applyOutdentToOptionalPrompt(value, enabled) {
+  if (!enabled || typeof value !== "string") {
+    return value;
+  }
+  return structuredOutdent.string(value);
+}
+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 shouldInjectFormat(prompt, schemaInstruction) {
+  const instruction = resolveSchemaInstruction(schemaInstruction);
+  return !prompt.trimStart().startsWith(instruction);
+}
+function mergeParseOptions(mode, options) {
+  const defaults = mode === "strict" ? DEFAULT_STRICT_PARSE_OPTIONS : DEFAULT_LOOSE_PARSE_OPTIONS;
+  return {
+    ...defaults,
+    ...options
+  };
+}
+function normalizeSelfHealConfig(option, mode) {
+  if (typeof option === "number") {
+    const maxAttempts = Math.max(0, Math.floor(option));
+    return {
+      enabled: maxAttempts > 0,
+      maxAttempts,
+      stopOnNoProgress: DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS,
+      maxContextChars: DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS
+    };
+  }
+  if (typeof option === "boolean") {
+    return {
+      enabled: option,
+      maxAttempts: option ? 1 : 0,
+      stopOnNoProgress: DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS,
+      maxContextChars: DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS
+    };
+  }
+  if (!option) {
+    const modeDefaults = mode === "loose" ? DEFAULT_SELF_HEAL_BY_MODE.loose : DEFAULT_SELF_HEAL_BY_MODE.strict;
+    return {
+      enabled: modeDefaults.enabled,
+      maxAttempts: modeDefaults.maxAttempts,
+      stopOnNoProgress: DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS,
+      maxContextChars: DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS
+    };
+  }
+  const enabled = option.enabled ?? true;
+  const stopOnNoProgress = option.stopOnNoProgress ?? DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS;
+  const maxContextChars = normalizePositiveInt(option.maxContextChars, DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS);
+  return {
+    enabled,
+    maxAttempts: enabled ? Math.max(1, option.maxAttempts ?? 1) : 0,
+    stopOnNoProgress,
+    maxContextChars
+  };
+}
+function resolvePromptLine(value, fallback) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : fallback;
+}
+function resolveSelfHealPromptText(text) {
+  return {
+    fixInstruction: resolvePromptLine(text?.fixInstruction, DEFAULT_SELF_HEAL_PROMPT_TEXT.fixInstruction),
+    returnInstruction: resolvePromptLine(text?.returnInstruction, DEFAULT_SELF_HEAL_PROMPT_TEXT.returnInstruction),
+    noIssuesMessage: resolvePromptLine(text?.noIssuesMessage, DEFAULT_SELF_HEAL_PROMPT_TEXT.noIssuesMessage),
+    validationErrorsLabel: resolvePromptLine(text?.validationErrorsLabel, DEFAULT_SELF_HEAL_PROMPT_TEXT.validationErrorsLabel),
+    rawOutputLabel: resolvePromptLine(text?.rawOutputLabel, DEFAULT_SELF_HEAL_PROMPT_TEXT.rawOutputLabel),
+    contextLabel: resolvePromptLine(text?.contextLabel, DEFAULT_SELF_HEAL_PROMPT_TEXT.contextLabel)
+  };
+}
+function normalizePositiveInt(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const normalized = Math.floor(value);
+  return normalized > 0 ? normalized : fallback;
+}
+function truncateForPrompt(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  const marker = `
+...[truncated ${value.length - maxChars} chars]`;
+  const head = Math.max(1, maxChars - marker.length);
+  return `${value.slice(0, head)}${marker}`;
+}
+function formatIssuePath(path) {
+  if (path.length === 0) {
+    return "$";
+  }
+  let out = "$";
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      out += `[${segment}]`;
+      continue;
+    }
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
+      out += `.${segment}`;
+      continue;
+    }
+    out += `["${segment.replace(/"/g, "\\\"")}"]`;
+  }
+  return out;
+}
+function resolveSelfHealSource(attempt) {
+  const candidate = attempt.parsed.candidate?.content?.trim();
+  if (candidate) {
+    return {
+      kind: "candidate",
+      text: candidate
+    };
+  }
+  const sanitized = attempt.parsed.sanitizedRaw?.trim();
+  if (sanitized) {
+    return {
+      kind: "sanitized",
+      text: sanitized
+    };
+  }
+  return {
+    kind: "raw",
+    text: attempt.raw
+  };
+}
+function isSelfHealStalled(previous, current) {
+  if (current.success) {
+    return false;
+  }
+  if (current.zodIssues.length < previous.zodIssues.length) {
+    return false;
+  }
+  if (current.parsed.errors.length < previous.parsed.errors.length) {
+    return false;
+  }
+  return buildSelfHealFailureFingerprint(previous) === buildSelfHealFailureFingerprint(current);
+}
+function buildSelfHealFailureFingerprint(attempt) {
+  const issues = attempt.zodIssues.map((issue) => `${formatIssuePath(issue.path)}:${issue.code}:${normalizeWhitespace(issue.message)}`).sort().join("|");
+  const errors = attempt.parsed.errors.map((error) => `${error.stage}:${error.candidateId ?? "-"}:${normalizeWhitespace(error.message)}`).sort().join("|");
+  const source = normalizeWhitespace(resolveSelfHealSource(attempt).text).slice(0, 512);
+  return [issues, errors, source].join("::");
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function normalizeStreamConfig(option) {
+  if (typeof option === "boolean") {
+    return {
+      enabled: option
+    };
+  }
+  if (!option) {
+    return {
+      enabled: false
+    };
+  }
+  return {
+    enabled: option.enabled ?? true,
+    onData: option.onData,
+    to: option.to
+  };
+}
+function normalizeDebugConfig(option) {
+  if (typeof option === "boolean") {
+    return {
+      enabled: option,
+      colors: true,
+      logger: (line) => console.log(line)
+    };
+  }
+  if (!option) {
+    return {
+      enabled: false,
+      colors: true,
+      logger: (line) => console.log(line)
+    };
+  }
+  return {
+    enabled: option.enabled ?? true,
+    colors: option.colors ?? true,
+    logger: option.logger ?? ((line) => console.log(line))
+  };
+}
+async function executeAttempt(adapter, input) {
+  const response = await callModel(adapter, {
+    prompt: input.prompt,
+    systemPrompt: input.systemPrompt,
+    request: input.request,
+    stream: input.stream,
+    observe: input.observe,
+    debug: input.debug,
+    attempt: input.attemptNumber,
+    selfHeal: input.selfHeal,
+    selfHealEnabled: input.selfHealEnabled
+  });
+  const parsed = parseWithObserve(response.text, input.schema, input.parseOptions, {
+    observe: input.observe,
+    attempt: input.attemptNumber,
+    selfHeal: input.selfHeal
+  });
+  const trace = {
+    attempt: input.attemptNumber,
+    selfHeal: input.selfHeal,
+    via: response.via,
+    raw: response.text,
+    thinkBlocks: parsed.thinkBlocks,
+    json: parsed.parsed,
+    candidates: parsed.candidates.map((candidate) => candidate.content),
+    repairLog: collectRepairLog(parsed),
+    zodIssues: parsed.zodIssues,
+    success: parsed.success,
+    usage: response.usage,
+    finishReason: response.finishReason,
+    parsed
+  };
+  return {
+    response,
+    trace
+  };
+}
+async function callModel(adapter, options) {
+  const requestPayload = {
+    prompt: options.prompt,
+    systemPrompt: options.systemPrompt,
+    temperature: options.request?.temperature,
+    maxTokens: options.request?.maxTokens,
+    mcpClients: options.request?.mcpClients,
+    toolChoice: options.request?.toolChoice,
+    parallelToolCalls: options.request?.parallelToolCalls,
+    maxToolRounds: options.request?.maxToolRounds,
+    onToolExecution: options.request?.onToolExecution,
+    toolDebug: options.request?.toolDebug,
+    body: options.request?.body
+  };
+  emitDebugRequest(options.debug, {
+    provider: adapter.provider,
+    model: adapter.model,
+    attempt: options.attempt,
+    selfHealAttempt: options.selfHeal,
+    selfHealEnabled: options.selfHealEnabled,
+    stream: options.stream.enabled && !!adapter.stream,
+    requestPayload
+  });
+  emitObserve(options.observe, {
+    stage: "llm.request",
+    attempt: options.attempt,
+    selfHeal: options.selfHeal,
+    message: "Sending LLM request.",
+    details: {
+      provider: adapter.provider,
+      model: adapter.model,
+      stream: options.stream.enabled && !!adapter.stream
+    }
+  });
+  if (options.stream.enabled && adapter.stream) {
+    let latestUsage;
+    let latestFinishReason;
+    let streamedRaw = "";
+    let sawToken = false;
+    let lastDataFingerprint;
+    const emitStreamingData = (raw, done, usage2, finishReason2) => {
+      const data = parseStreamingStructuredData(raw);
+      if (data === null && !done) {
+        return;
+      }
+      const fingerprint = toStreamDataFingerprint(data ?? null);
+      if (!done && fingerprint === lastDataFingerprint) {
+        return;
+      }
+      lastDataFingerprint = fingerprint;
+      options.stream.onData?.({
+        data: data ?? null,
+        raw,
+        done,
+        usage: usage2,
+        finishReason: finishReason2
+      });
+      emitObserve(options.observe, {
+        stage: "llm.stream.data",
+        attempt: options.attempt,
+        selfHeal: options.selfHeal,
+        message: done ? "Streaming structured data completed." : "Streaming structured data updated.",
+        details: {
+          done,
+          finishReason: finishReason2
+        }
+      });
+    };
+    const handleTextDelta = (delta) => {
+      if (!delta) {
+        return;
+      }
+      streamedRaw += delta;
+      if (options.stream.to === "stdout") {
+        process.stdout.write(delta);
+      }
+      emitObserve(options.observe, {
+        stage: "llm.stream.delta",
+        attempt: options.attempt,
+        selfHeal: options.selfHeal,
+        message: "Received stream delta.",
+        details: {
+          chars: delta.length
+        }
+      });
+      emitStreamingData(streamedRaw, false);
+    };
+    const response2 = await adapter.stream(requestPayload, {
+      onToken: (token) => {
+        sawToken = true;
+        handleTextDelta(token);
+      },
+      onChunk: (chunk) => {
+        if (!sawToken && chunk.textDelta) {
+          handleTextDelta(chunk.textDelta);
+        }
+        if (chunk.usage) {
+          latestUsage = mergeUsage2(latestUsage, chunk.usage);
+        }
+        if (chunk.finishReason) {
+          latestFinishReason = chunk.finishReason;
+        }
+      }
+    });
+    const finalText = typeof response2.text === "string" && response2.text.length > 0 ? response2.text : streamedRaw;
+    const usage = mergeUsage2(latestUsage, response2.usage);
+    const finishReason = response2.finishReason ?? latestFinishReason;
+    emitStreamingData(finalText, true, usage, finishReason);
+    emitObserve(options.observe, {
+      stage: "llm.response",
+      attempt: options.attempt,
+      selfHeal: options.selfHeal,
+      message: "Streaming response completed.",
+      details: {
+        via: "stream",
+        chars: finalText.length,
+        finishReason
+      }
+    });
+    emitDebugResponse(options.debug, {
+      attempt: options.attempt,
+      selfHealAttempt: options.selfHeal,
+      selfHealEnabled: options.selfHealEnabled,
+      via: "stream",
+      responseText: finalText,
+      usage,
+      finishReason
+    });
+    return {
+      text: finalText,
+      via: "stream",
+      usage,
+      finishReason
+    };
+  }
+  const response = await adapter.complete(requestPayload);
+  emitObserve(options.observe, {
+    stage: "llm.response",
+    attempt: options.attempt,
+    selfHeal: options.selfHeal,
+    message: "Completion response received.",
+    details: {
+      via: "complete",
+      chars: response.text.length,
+      finishReason: response.finishReason
+    }
+  });
+  emitDebugResponse(options.debug, {
+    attempt: options.attempt,
+    selfHealAttempt: options.selfHeal,
+    selfHealEnabled: options.selfHealEnabled,
+    via: "complete",
+    responseText: response.text,
+    usage: response.usage,
+    finishReason: response.finishReason
+  });
+  return {
+    text: response.text,
+    via: "complete",
+    usage: response.usage,
+    finishReason: response.finishReason
+  };
+}
+function parseStreamingStructuredData(raw) {
+  const sanitized = sanitizeThink(raw);
+  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 toStreamDataFingerprint(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "__unserializable__";
+  }
+}
+function parseWithObserve(output, schema, parseOptions, context) {
+  const userParseTrace = parseOptions.onTrace;
+  return parseLLMOutput(output, schema, {
+    ...parseOptions,
+    onTrace: (event) => {
+      userParseTrace?.(event);
+      emitObserve(context.observe, {
+        stage: "parse",
+        attempt: context.attempt,
+        selfHeal: context.selfHeal,
+        message: event.message,
+        details: {
+          level: event.level,
+          stage: event.stage,
+          candidateId: event.candidateId,
+          details: event.details
+        }
+      });
+    }
+  });
+}
+function collectRepairLog(parsed) {
+  const logs = parsed.diagnostics.filter((diagnostic) => diagnostic.usedRepair).map((diagnostic) => diagnostic.message).filter((value) => typeof value === "string" && value.trim().length > 0);
+  return [...new Set(logs)];
+}
+function buildSuccessResult(data, attempts) {
+  const final = attempts.at(-1);
+  return {
+    data,
+    raw: final?.raw ?? "",
+    thinkBlocks: final?.thinkBlocks ?? [],
+    json: final?.json ?? null,
+    attempts,
+    usage: aggregateUsage(attempts),
+    finishReason: final?.finishReason
+  };
+}
+function aggregateUsage(attempts) {
+  let usage;
+  for (const attempt of attempts) {
+    usage = mergeUsage2(usage, attempt.usage);
+  }
+  return usage;
+}
+function mergeUsage2(base, next) {
+  if (!base && !next) {
+    return;
+  }
+  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 toStructuredError(attempt) {
+  if (!attempt) {
+    return new StructuredParseError({
+      message: "Structured parsing failed before any model response.",
+      raw: "",
+      thinkBlocks: [],
+      candidates: [],
+      zodIssues: [],
+      repairLog: [],
+      attempt: 0
+    });
+  }
+  return new StructuredParseError({
+    raw: attempt.raw,
+    thinkBlocks: attempt.thinkBlocks,
+    candidates: attempt.candidates,
+    zodIssues: attempt.zodIssues,
+    repairLog: attempt.repairLog,
+    attempt: attempt.attempt
+  });
+}
+function emitObserve(observe, event) {
+  observe?.(event);
+}
+function emitDebugRequest(config, input) {
+  const requestBody = input.requestPayload.body !== undefined ? JSON.stringify(input.requestPayload.body, null, 2) : "(none)";
+  const lines = [
+    color(config, title(config, [
+      "[structured][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,
+    color(config, "systemPrompt:", "yellow"),
+    input.requestPayload.systemPrompt ?? "(none)",
+    color(config, "request.body:", "yellow"),
+    requestBody
+  ];
+  emitDebug(config, lines.join(`
+`));
+}
+function emitDebugResponse(config, input) {
+  const lines = [
+    color(config, title(config, [
+      "[structured][response]",
+      `attempt=${input.attempt}`,
+      `selfHealEnabled=${input.selfHealEnabled}`,
+      `selfHealAttempt=${input.selfHealAttempt}`
+    ].join(" ")), "green"),
+    dim(config, [
+      `via=${input.via}`,
+      `chars=${input.responseText.length}`,
+      `finishReason=${input.finishReason ?? "unknown"}`,
+      `usage=${JSON.stringify(input.usage ?? {})}`
+    ].join(" ")),
+    color(config, "text:", "yellow"),
+    input.responseText
+  ];
+  emitDebug(config, lines.join(`
+`));
+}
+function emitDebug(config, message) {
+  if (!config.enabled) {
+    return;
+  }
+  config.logger(message);
+}
+
+// src/llm.ts
+function createLLM(config, registry = createDefaultProviderRegistry()) {
+  const adapter = createModelAdapter(config, registry);
+  const defaults = config.defaults;
+  return {
+    adapter,
+    provider: adapter.provider,
+    model: adapter.model,
+    async structured(schema, prompt, options) {
+      const merged = mergeStructuredOptions(defaults, options);
+      return structured(adapter, schema, prompt, merged);
+    }
+  };
+}
+function mergeStructuredOptions(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return {};
+  }
+  return {
+    ...defaults,
+    ...overrides,
+    parse: {
+      ...defaults?.parse ?? {},
+      ...overrides?.parse ?? {}
+    },
+    request: {
+      ...defaults?.request ?? {},
+      ...overrides?.request ?? {}
+    },
+    stream: mergeObjectLike(defaults?.stream, overrides?.stream),
+    selfHeal: mergeObjectLike(defaults?.selfHeal, overrides?.selfHeal),
+    debug: mergeObjectLike(defaults?.debug, overrides?.debug)
+  };
+}
+function mergeObjectLike(defaults, overrides) {
+  if (overrides === undefined) {
+    return defaults;
+  }
+  if (defaults === undefined) {
+    return overrides;
+  }
+  if (!isPlainObject(defaults) || !isPlainObject(overrides)) {
+    return overrides;
+  }
+  return {
+    ...defaults,
+    ...overrides
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/mcp.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  StdioClientTransport
+} from "@modelcontextprotocol/sdk/client/stdio.js";
+import {
+  StreamableHTTPClientTransport
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+async function createMCPClient(options) {
+  const client = new Client(toImplementation(options.clientInfo), {
+    capabilities: {}
+  });
+  const transport = createTransport(options.transport);
+  await client.connect(transport);
+  return wrapMCPClient({
+    id: options.id,
+    client,
+    transport
+  });
+}
+function wrapMCPClient(options) {
+  return {
+    id: options.id,
+    sdkClient: options.client,
+    transport: options.transport,
+    async listTools(params) {
+      const response = await options.client.listTools(params);
+      return {
+        tools: response.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        })),
+        nextCursor: response.nextCursor
+      };
+    },
+    async callTool(params) {
+      return options.client.callTool(params);
+    },
+    async close() {
+      await options.client.close();
+      if (options.transport) {
+        await options.transport.close();
+      }
+    }
+  };
+}
+function createTransport(config) {
+  if (config.type === "stdio") {
+    const stdio = {
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      stderr: config.stderr,
+      cwd: config.cwd
+    };
+    return new StdioClientTransport(stdio);
+  }
+  if (config.type === "streamable-http") {
+    const url = typeof config.url === "string" ? new URL(config.url) : config.url;
+    return new StreamableHTTPClientTransport(url, config.options);
+  }
+  return config.transport;
+}
+function toImplementation(clientInfo) {
+  return {
+    name: clientInfo?.name ?? "extrait-mcp-client",
+    version: clientInfo?.version ?? "0.1.0"
+  };
+}
+// src/prompt.ts
+function toPromptString(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value, null, 2) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+var dedent = createOutdent({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true,
+  newline: `
+`
+});
+function isBlankLine(line) {
+  for (let index = 0;index < line.length; index += 1) {
+    const char = line[index];
+    if (char !== " " && char !== "\t") {
+      return false;
+    }
+  }
+  return true;
+}
+function stripOuterBlankLines(text) {
+  const lines = text.split(`
+`);
+  let start = 0;
+  while (start < lines.length && isBlankLine(lines[start] ?? "")) {
+    start += 1;
+  }
+  let end = lines.length - 1;
+  while (end >= start && isBlankLine(lines[end] ?? "")) {
+    end -= 1;
+  }
+  if (start > end) {
+    return "";
+  }
+  return lines.slice(start, end + 1).join(`
+`);
+}
+function renderPromptTemplate(strings, values) {
+  return stripOuterBlankLines(dedent(strings, ...values.map(toPromptString)));
+}
+function isTemplateStringsArray(value) {
+  return Array.isArray(value) && "raw" in value;
+}
+function toPromptMessage(input, values) {
+  if (typeof input === "string") {
+    return input;
+  }
+  return renderPromptTemplate(input, values);
+}
+function joinMessages(messages) {
+  return messages.join(`
+
+`);
+}
+
+class PromptMessageBuilderImpl {
+  systemMessages = [];
+  userMessages = [];
+  system(input, ...values) {
+    const message = toPromptMessage(input, values);
+    if (message.length > 0) {
+      this.systemMessages.push(message);
+    }
+    return this;
+  }
+  user(input, ...values) {
+    const message = toPromptMessage(input, values);
+    if (message.length > 0) {
+      this.userMessages.push(message);
+    }
+    return this;
+  }
+  build() {
+    const prompt = joinMessages(this.userMessages);
+    const systemPrompt = joinMessages(this.systemMessages);
+    return {
+      prompt,
+      systemPrompt: systemPrompt.length > 0 ? systemPrompt : undefined
+    };
+  }
+  resolvePrompt(_context) {
+    return this.build();
+  }
+}
+function createPromptMessageBuilder() {
+  return new PromptMessageBuilderImpl;
+}
+function prompt(input, ...values) {
+  if (isTemplateStringsArray(input)) {
+    return renderPromptTemplate(input, values);
+  }
+  return createPromptMessageBuilder();
+}
+// src/schema-builder.ts
+import { z } from "zod";
+var NAME_SYMBOL = Symbol.for("extrait.schema.name");
+var didPatchZod = false;
+function ensurePatchedZod() {
+  if (didPatchZod) {
+    return;
+  }
+  const zodNumberPrototype = z.ZodNumber.prototype;
+  if (!zodNumberPrototype.coerce) {
+    zodNumberPrototype.coerce = function coerceNumber() {
+      const coerced = z.coerce.number();
+      return coerced;
+    };
+  }
+  didPatchZod = true;
+}
+ensurePatchedZod();
+var s = {
+  schema(name, schema) {
+    return setSchemaName(schema, name);
+  },
+  string() {
+    return z.string();
+  },
+  number() {
+    return z.number();
+  },
+  boolean() {
+    return z.boolean();
+  },
+  array(schema) {
+    return z.array(schema);
+  },
+  object(shape) {
+    return z.object(shape);
+  }
+};
+function setSchemaName(schema, name) {
+  schema[NAME_SYMBOL] = name;
+  return schema;
+}
+function getSchemaName(schema) {
+  return schema[NAME_SYMBOL];
+}
+function inspectSchemaMetadata(schema) {
+  const requiredFields = [];
+  const defaults = {};
+  const fieldDescriptions = {};
+  const objectShape = getObjectShape(schema);
+  if (objectShape) {
+    for (const [fieldName, fieldSchema] of Object.entries(objectShape)) {
+      const { optional } = unwrap2(fieldSchema);
+      if (!optional) {
+        requiredFields.push(fieldName);
+      }
+      const defaultValue = readDefaultValue(fieldSchema);
+      if (defaultValue !== undefined) {
+        defaults[fieldName] = defaultValue;
+      }
+      const description = readSchemaDescription2(fieldSchema);
+      if (description) {
+        fieldDescriptions[fieldName] = description;
+      }
+    }
+  }
+  return {
+    name: getSchemaName(schema),
+    description: readSchemaDescription2(schema),
+    requiredFields,
+    defaults,
+    fieldDescriptions
+  };
+}
+function inferSchemaExample(schema) {
+  const objectShape = getObjectShape(schema);
+  if (!objectShape) {
+    const fallback = readDefaultValue(schema);
+    if (fallback !== undefined) {
+      return fallback;
+    }
+    return null;
+  }
+  const out = {};
+  for (const [fieldName, fieldSchema] of Object.entries(objectShape)) {
+    const defaultValue = readDefaultValue(fieldSchema);
+    if (defaultValue !== undefined) {
+      out[fieldName] = defaultValue;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function getObjectShape(schema) {
+  const unwrapped = unwrap2(schema).schema;
+  const typeName = unwrapped._def?.typeName;
+  if (typeName !== "ZodObject") {
+    return null;
+  }
+  const rawShape = unwrapped._def?.shape;
+  if (typeof rawShape === "function") {
+    return rawShape();
+  }
+  return rawShape ?? null;
+}
+function readDefaultValue(schema) {
+  let current = schema;
+  while (current?._def?.typeName) {
+    const typeName = current._def.typeName;
+    if (typeName === "ZodDefault") {
+      const raw = current._def.defaultValue;
+      if (typeof raw === "function") {
+        try {
+          return raw();
+        } catch {
+          return;
+        }
+      }
+      return raw;
+    }
+    if (typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "ZodCatch" || typeName === "ZodReadonly") {
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodEffects") {
+      current = current._def.schema ?? current;
+      continue;
+    }
+    if (typeName === "ZodBranded") {
+      current = current._def.type ?? current;
+      continue;
+    }
+    if (typeName === "ZodPipeline") {
+      current = current._def.out ?? current;
+      continue;
+    }
+    return;
+  }
+  return;
+}
+function readSchemaDescription2(schema) {
+  let current = schema;
+  while (current?._def?.typeName) {
+    const raw = current._def.description;
+    if (typeof raw === "string" && raw.trim().length > 0) {
+      return raw.trim();
+    }
+    const fallback = current.description;
+    if (typeof fallback === "string" && fallback.trim().length > 0) {
+      return fallback.trim();
+    }
+    const typeName = current._def.typeName;
+    if (typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "ZodNullable") {
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodCatch" || typeName === "ZodReadonly") {
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodEffects") {
+      current = current._def.schema ?? current;
+      continue;
+    }
+    if (typeName === "ZodBranded") {
+      current = current._def.type ?? current;
+      continue;
+    }
+    if (typeName === "ZodPipeline") {
+      current = current._def.out ?? current;
+      continue;
+    }
+    break;
+  }
+  return;
+}
+function unwrap2(schema) {
+  let current = schema;
+  let optional = false;
+  while (current?._def?.typeName) {
+    const typeName = current._def.typeName;
+    if (typeName === "ZodOptional" || typeName === "ZodDefault") {
+      optional = true;
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodNullable" || typeName === "ZodCatch" || typeName === "ZodReadonly") {
+      current = current._def.innerType ?? current;
+      continue;
+    }
+    if (typeName === "ZodEffects") {
+      current = current._def.schema ?? current;
+      continue;
+    }
+    if (typeName === "ZodBranded") {
+      current = current._def.type ?? current;
+      continue;
+    }
+    if (typeName === "ZodPipeline") {
+      current = current._def.out ?? current;
+      continue;
+    }
+    break;
+  }
+  return {
+    schema: current,
+    optional
+  };
+}
+export {
+  wrapMCPClient,
+  withFormat,
+  structured,
+  sanitizeThink,
+  s,
+  resolveSchemaInstruction,
+  registerBuiltinProviders,
+  prompt,
+  parseLLMOutput,
+  inspectSchemaMetadata,
+  inferSchemaExample,
+  formatZodIssues,
+  formatPrompt,
+  extractMarkdownCodeBlocks,
+  extractJsonCandidates,
+  extractFirstMarkdownCode,
+  createProviderRegistry,
+  createOpenAICompatibleAdapter,
+  createModelAdapter,
+  createMCPClient,
+  createLLM,
+  createDefaultProviderRegistry,
+  createAnthropicCompatibleAdapter,
+  buildSelfHealPrompt,
+  buildDefaultStructuredPrompt,
+  StructuredParseError,
+  DEFAULT_STRUCTURED_STYLE_INSTRUCTION,
+  DEFAULT_STRUCTURED_OBJECT_INSTRUCTION,
+  DEFAULT_STRICT_PARSE_OPTIONS,
+  DEFAULT_SELF_HEAL_VALIDATION_LABEL,
+  DEFAULT_SELF_HEAL_STOP_ON_NO_PROGRESS,
+  DEFAULT_SELF_HEAL_RETURN_INSTRUCTION,
+  DEFAULT_SELF_HEAL_RAW_OUTPUT_LABEL,
+  DEFAULT_SELF_HEAL_PROTOCOL,
+  DEFAULT_SELF_HEAL_NO_ISSUES_MESSAGE,
+  DEFAULT_SELF_HEAL_MAX_CONTEXT_CHARS,
+  DEFAULT_SELF_HEAL_FIX_INSTRUCTION,
+  DEFAULT_SELF_HEAL_CONTEXT_LABEL,
+  DEFAULT_SELF_HEAL_BY_MODE,
+  DEFAULT_SCHEMA_INSTRUCTION,
+  DEFAULT_MAX_TOOL_ROUNDS,
+  DEFAULT_LOOSE_PARSE_OPTIONS,
+  DEFAULT_EXTRACTION_HEURISTICS,
+  DEFAULT_ANTHROPIC_VERSION,
+  DEFAULT_ANTHROPIC_MAX_TOKENS
+};