extrait 0.5.6 → 0.6.1

package/dist/index.cjs

@@ -52,6 +52,7 @@ __export(exports_src, {
   inspectSchemaMetadata: () => inspectSchemaMetadata,
   inferSchemaExample: () => inferSchemaExample,
   images: () => images,
+  generate: () => generate,
   formatZodIssues: () => formatZodIssues,
   formatPrompt: () => formatPrompt,
   extractMarkdownCodeBlocks: () => extractMarkdownCodeBlocks,
@@ -1552,7 +1553,15 @@ function normalizeBaseURL(baseURL) {
   return baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
 }
 function buildURL(baseURL, path) {
-  return new URL(path, normalizeBaseURL(baseURL)).toString();
+  try {
+    return new URL(path).toString();
+  } catch {}
+  const base = new URL(normalizeBaseURL(baseURL));
+  const resolvedPath = new URL(path, "http://provider-path.local");
+  base.pathname = mergePathnames(base.pathname, resolvedPath.pathname);
+  base.search = resolvedPath.search;
+  base.hash = resolvedPath.hash;
+  return base.toString();
 }
 function safeJSONParse(input) {
   try {
@@ -1627,6 +1636,36 @@ function addOptional(a, b) {
   }
   return (a ?? 0) + (b ?? 0);
 }
+function mergePathnames(basePathname, pathPathname) {
+  const baseSegments = splitPathSegments(basePathname);
+  const pathSegments = splitPathSegments(pathPathname);
+  const overlap = findPathOverlap(baseSegments, pathSegments);
+  const mergedSegments = [...baseSegments, ...pathSegments.slice(overlap)];
+  if (mergedSegments.length === 0) {
+    return "/";
+  }
+  const mergedPathname = `/${mergedSegments.join("/")}`;
+  return pathPathname.endsWith("/") && pathPathname !== "/" ? `${mergedPathname}/` : mergedPathname;
+}
+function splitPathSegments(pathname) {
+  return pathname.split("/").filter((segment) => segment.length > 0);
+}
+function findPathOverlap(baseSegments, pathSegments) {
+  const maxOverlap = Math.min(baseSegments.length, pathSegments.length);
+  for (let size = maxOverlap;size > 0; size -= 1) {
+    let matches = true;
+    for (let index = 0;index < size; index += 1) {
+      if (baseSegments[baseSegments.length - size + index] !== pathSegments[index]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      return size;
+    }
+  }
+  return 0;
+}
 
 // src/providers/openai-compatible.ts
 function createOpenAICompatibleAdapter(options) {
@@ -1661,6 +1700,7 @@ function createOpenAICompatibleAdapter(options) {
           model: options.model,
           messages: buildMessages(request),
           temperature: request.temperature,
+          reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
           max_tokens: request.maxTokens,
           stream: true
         })),
@@ -1672,6 +1712,7 @@ function createOpenAICompatibleAdapter(options) {
       }
       callbacks.onStart?.();
       let text = "";
+      let reasoning = "";
       let usage;
       let finishReason;
       await consumeSSE(response, (data) => {
@@ -1683,6 +1724,7 @@ function createOpenAICompatibleAdapter(options) {
           return;
         }
         const delta = pickAssistantDelta(json);
+        const reasoningDelta = pickAssistantReasoningDelta(json);
         const chunkUsage = pickUsage(json);
         const chunkFinishReason = pickFinishReason(json);
         usage = preferLatestUsage(usage, chunkUsage);
@@ -1693,9 +1735,13 @@ function createOpenAICompatibleAdapter(options) {
           text += delta;
           callbacks.onToken?.(delta);
         }
-        if (delta || chunkUsage || chunkFinishReason) {
+        if (reasoningDelta) {
+          reasoning += reasoningDelta;
+        }
+        if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
           const chunk = {
             textDelta: delta,
+            reasoningDelta: reasoningDelta || undefined,
             raw: json,
             usage: chunkUsage,
             finishReason: chunkFinishReason
@@ -1703,7 +1749,12 @@ function createOpenAICompatibleAdapter(options) {
           callbacks.onChunk?.(chunk);
         }
       });
-      const out = { text, usage, finishReason };
+      const out = {
+        text,
+        reasoning: reasoning.length > 0 ? reasoning : undefined,
+        usage,
+        finishReason
+      };
       callbacks.onComplete?.(out);
       return out;
     },
@@ -1763,6 +1814,7 @@ async function completeWithChatCompletionsPassThrough(options, fetcher, path, re
       model: options.model,
       messages: buildMessages(request),
       temperature: request.temperature,
+      reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
       max_tokens: request.maxTokens,
       stream: false
     })),
@@ -1772,20 +1824,41 @@ async function completeWithChatCompletionsPassThrough(options, fetcher, path, re
     const message = await response.text();
     throw new Error(`HTTP ${response.status}: ${message}`);
   }
-  const payload = await response.json();
+  const payload = await parseOpenAICompatibleJSONResponse(response, "Failed to parse OpenAI-compatible chat completion response");
   const assistantMessage = pickAssistantMessage(payload);
   if (!assistantMessage) {
     throw new Error("No assistant message in OpenAI-compatible response.");
   }
   const toolCalls = pickChatToolCalls(payload);
+  const reasoning = pickAssistantReasoning(payload);
   return {
     text: pickAssistantText(payload),
+    reasoning: reasoning.length > 0 ? reasoning : undefined,
     raw: payload,
     usage: pickUsage(payload),
     finishReason: pickFinishReason(payload),
     toolCalls: toolCalls.length > 0 ? toolCalls : undefined
   };
 }
+async function parseOpenAICompatibleJSONResponse(response, context) {
+  const rawBody = await response.text();
+  try {
+    return JSON.parse(rawBody);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${context} (HTTP ${response.status}): ${message}. Raw body: ${formatResponseBodyForError(rawBody)}`);
+  }
+}
+function formatResponseBodyForError(rawBody, maxLength = 2000) {
+  const normalized = rawBody.trim();
+  if (normalized.length === 0) {
+    return "[empty body]";
+  }
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength)}...[truncated ${normalized.length - maxLength} chars]`;
+}
 async function completeWithChatCompletionsWithMCP(options, fetcher, path, request) {
   const maxToolRounds = normalizeMaxToolRounds(request.maxToolRounds ?? options.defaultMaxToolRounds);
   let messages = buildMessages(request);
@@ -1806,6 +1879,7 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
         model: options.model,
         messages,
         temperature: request.temperature,
+        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
         max_tokens: request.maxTokens,
         tools: transportTools,
         tool_choice: request.toolChoice,
@@ -1827,8 +1901,10 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
       throw new Error("No assistant message in OpenAI-compatible response.");
     }
     if (calledTools.length === 0) {
+      const reasoning = pickAssistantReasoning(payload);
       return {
         text: pickAssistantText(payload),
+        reasoning: reasoning.length > 0 ? reasoning : undefined,
         raw: payload,
         usage: aggregatedUsage,
         finishReason,
@@ -1856,6 +1932,10 @@ async function completeWithChatCompletionsWithMCP(options, fetcher, path, reques
   }
   return {
     text: pickAssistantText(lastPayload ?? {}),
+    reasoning: (() => {
+      const value = pickAssistantReasoning(lastPayload ?? {});
+      return value.length > 0 ? value : undefined;
+    })(),
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
@@ -1875,6 +1955,7 @@ async function completeWithResponsesAPIPassThrough(options, fetcher, path, reque
       input: buildResponsesInput(request),
       previous_response_id: pickString(body?.previous_response_id),
       temperature: request.temperature,
+      reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
       max_output_tokens: request.maxTokens
     })),
     signal: request.signal
@@ -1915,6 +1996,7 @@ async function completeWithResponsesAPIWithMCP(options, fetcher, path, request)
         input,
         previous_response_id: previousResponseId,
         temperature: request.temperature,
+        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
         max_output_tokens: request.maxTokens,
         tools: transportTools,
         tool_choice: request.toolChoice,
@@ -1979,6 +2061,8 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
   const executedToolCalls = [];
   const toolExecutions = [];
   callbacks.onStart?.();
+  let lastRoundText = "";
+  let lastRoundReasoning = "";
   for (let round = 1;round <= maxToolRounds + 1; round += 1) {
     const mcpToolset = await resolveMCPToolset(request.mcpClients);
     const transportTools = toProviderFunctionTools(mcpToolset);
@@ -1991,6 +2075,7 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         model: options.model,
         messages,
         temperature: request.temperature,
+        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
         max_tokens: request.maxTokens,
         tools: transportTools,
         tool_choice: request.toolChoice,
@@ -2004,9 +2089,11 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
       throw new Error(`HTTP ${response.status}: ${message}`);
     }
     let roundText = "";
+    let roundReasoning = "";
     let roundUsage;
     let roundFinishReason;
     const streamedToolCalls = new Map;
+    let reasoningFieldName;
     await consumeSSE(response, (data) => {
       if (data === "[DONE]") {
         return;
@@ -2017,6 +2104,7 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
       }
       lastPayload = json;
       const delta = pickAssistantDelta(json);
+      const reasoningDelta = pickAssistantReasoningDelta(json);
       const chunkUsage = pickUsage(json);
       const chunkFinishReason = pickFinishReason(json);
       collectOpenAIStreamToolCalls(json, streamedToolCalls);
@@ -2028,9 +2116,14 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
         roundText += delta;
         callbacks.onToken?.(delta);
       }
-      if (delta || chunkUsage || chunkFinishReason) {
+      if (reasoningDelta) {
+        roundReasoning += reasoningDelta;
+        reasoningFieldName ??= pickAssistantReasoningDeltaFieldName(json);
+      }
+      if (delta || reasoningDelta || chunkUsage || chunkFinishReason) {
         const chunk = {
           textDelta: delta,
+          reasoningDelta: reasoningDelta || undefined,
           raw: json,
           usage: chunkUsage,
           finishReason: chunkFinishReason
@@ -2046,6 +2139,7 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
     if (calledTools.length === 0) {
       const out2 = {
         text: roundText,
+        reasoning: roundReasoning.length > 0 ? roundReasoning : undefined,
         raw: lastPayload,
         usage: aggregatedUsage,
         finishReason,
@@ -2066,7 +2160,12 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
     });
     executedToolCalls.push(...outputs.map((entry) => entry.call));
     toolExecutions.push(...outputs.map((entry) => entry.execution));
-    const assistantMessage = buildOpenAIAssistantToolMessage(roundText, calledTools);
+    lastRoundText = roundText;
+    lastRoundReasoning = roundReasoning;
+    const assistantMessage = buildOpenAIAssistantToolMessage(roundText, calledTools, {
+      reasoning: roundReasoning,
+      reasoningFieldName
+    });
     const toolMessages = outputs.map((entry) => ({
       role: "tool",
       tool_call_id: entry.call.id,
@@ -2075,7 +2174,8 @@ async function streamWithChatCompletionsWithMCP(options, fetcher, path, request,
     messages = [...messages, assistantMessage, ...toolMessages];
   }
   const out = {
-    text: "",
+    text: lastRoundText,
+    reasoning: lastRoundReasoning.length > 0 ? lastRoundReasoning : undefined,
     raw: lastPayload,
     usage: aggregatedUsage,
     finishReason,
@@ -2097,6 +2197,7 @@ async function streamWithResponsesAPIPassThrough(options, fetcher, path, request
       input: buildResponsesInput(request),
       previous_response_id: pickString(body?.previous_response_id),
       temperature: request.temperature,
+      reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
       max_output_tokens: request.maxTokens,
       stream: true
     })),
@@ -2177,6 +2278,7 @@ async function streamWithResponsesAPIWithMCP(options, fetcher, path, request, ca
         input,
         previous_response_id: previousResponseId,
         temperature: request.temperature,
+        reasoning_effort: toOpenAIReasoningEffort(request.reasoningEffort),
         max_output_tokens: request.maxTokens,
         tools: transportTools,
         tool_choice: request.toolChoice,
@@ -2343,6 +2445,12 @@ function toResponsesTools(tools) {
     return { ...tool };
   });
 }
+function toOpenAIReasoningEffort(value) {
+  if (!value) {
+    return;
+  }
+  return value === "max" ? "xhigh" : value;
+}
 function pickChatToolCalls(payload) {
   const message = pickAssistantMessage(payload);
   if (!message) {
@@ -2424,20 +2532,50 @@ function pickAssistantDelta(payload) {
   if (!isRecord2(delta)) {
     return "";
   }
-  const content = delta.content;
-  if (typeof content === "string") {
-    return content;
+  return pickTextFromOpenAIContent(delta.content);
+}
+function pickAssistantReasoning(payload) {
+  const message = pickAssistantMessage(payload);
+  if (!message) {
+    return "";
   }
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (!isRecord2(part)) {
-        return "";
-      }
-      const text = part.text;
-      return typeof text === "string" ? text : "";
-    }).join("");
+  return pickReasoningText(message);
+}
+function pickAssistantReasoningDelta(payload) {
+  const choices = payload.choices;
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return "";
   }
-  return "";
+  const first = choices[0];
+  if (!isRecord2(first)) {
+    return "";
+  }
+  const delta = first.delta;
+  if (!isRecord2(delta)) {
+    return "";
+  }
+  return pickReasoningText(delta);
+}
+function pickAssistantReasoningDeltaFieldName(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;
+  }
+  if (hasTextLikeValue(delta.reasoning)) {
+    return "reasoning";
+  }
+  if (hasTextLikeValue(delta.reasoning_content)) {
+    return "reasoning_content";
+  }
+  return;
 }
 function collectOpenAIStreamToolCalls(payload, state) {
   const choices = payload.choices;
@@ -2486,8 +2624,8 @@ function buildOpenAIStreamToolCalls(state) {
     arguments: entry.argumentsText.length > 0 ? entry.argumentsText : {}
   }));
 }
-function buildOpenAIAssistantToolMessage(text, toolCalls) {
-  return {
+function buildOpenAIAssistantToolMessage(text, toolCalls, reasoning) {
+  const message = {
     role: "assistant",
     content: text,
     tool_calls: toolCalls.map((call) => ({
@@ -2499,6 +2637,10 @@ function buildOpenAIAssistantToolMessage(text, toolCalls) {
       }
     }))
   };
+  if (reasoning?.reasoning && reasoning.reasoning.length > 0) {
+    message[reasoning.reasoningFieldName ?? "reasoning"] = reasoning.reasoning;
+  }
+  return message;
 }
 function pickResponsesStreamPayload(payload) {
   if (isRecord2(payload.response)) {
@@ -2660,21 +2802,9 @@ function pickResponsesText(payload) {
 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 text = pickTextFromOpenAIContent(message.content);
+    if (text.length > 0) {
+      return text;
     }
   }
   const choices = payload.choices;
@@ -2686,6 +2816,36 @@ function pickAssistantText(payload) {
   }
   return "";
 }
+function pickReasoningText(value) {
+  return pickTextLike(value.reasoning) || pickTextLike(value.reasoning_content);
+}
+function pickTextFromOpenAIContent(value) {
+  return pickTextLike(value);
+}
+function pickTextLike(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((part) => pickTextLikePart(part)).join("");
+  }
+  if (!isRecord2(value)) {
+    return "";
+  }
+  return pickTextLikePart(value);
+}
+function pickTextLikePart(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!isRecord2(value)) {
+    return "";
+  }
+  return pickString(value.text) ?? pickString(value.output_text) ?? pickString(value.reasoning) ?? pickString(value.reasoning_content) ?? (Array.isArray(value.content) ? value.content.map((part) => pickTextLikePart(part)).join("") : "");
+}
+function hasTextLikeValue(value) {
+  return pickTextLike(value).length > 0;
+}
 function pickUsage(payload) {
   const usage = payload.usage;
   if (!isRecord2(usage)) {
@@ -2739,14 +2899,13 @@ function createAnthropicCompatibleAdapter(options) {
       const response = await fetcher(buildURL(options.baseURL, path), {
         method: "POST",
         headers: buildHeaders2(options),
-        body: JSON.stringify(cleanUndefined({
+        body: JSON.stringify(buildAnthropicRequestBody(options, request, {
           ...options.defaultBody,
           ...request.body,
           model: options.model,
           system: input.systemPrompt,
           messages: input.messages,
           temperature: request.temperature,
-          max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
           stream: true
         })),
         signal: request.signal
@@ -2802,14 +2961,13 @@ async function completePassThrough(options, fetcher, path, request) {
   const response = await fetcher(buildURL(options.baseURL, path), {
     method: "POST",
     headers: buildHeaders2(options),
-    body: JSON.stringify(cleanUndefined({
+    body: JSON.stringify(buildAnthropicRequestBody(options, request, {
       ...options.defaultBody,
       ...request.body,
       model: options.model,
       system: input.systemPrompt,
       messages: input.messages,
       temperature: request.temperature,
-      max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
       stream: false
     })),
     signal: request.signal
@@ -2847,14 +3005,13 @@ async function completeWithMCPToolLoop(options, fetcher, path, request) {
     const response = await fetcher(buildURL(options.baseURL, path), {
       method: "POST",
       headers: buildHeaders2(options),
-      body: JSON.stringify(cleanUndefined({
+      body: JSON.stringify(buildAnthropicRequestBody(options, request, {
         ...options.defaultBody,
         ...request.body,
         model: options.model,
         system: input.systemPrompt,
         messages,
         temperature: request.temperature,
-        max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
         tools,
         tool_choice: toAnthropicToolChoice(request.toolChoice),
         stream: false
@@ -2932,14 +3089,13 @@ async function streamWithMCPToolLoop(options, fetcher, path, request, callbacks)
     const response = await fetcher(buildURL(options.baseURL, path), {
       method: "POST",
       headers: buildHeaders2(options),
-      body: JSON.stringify(cleanUndefined({
+      body: JSON.stringify(buildAnthropicRequestBody(options, request, {
         ...options.defaultBody,
         ...request.body,
         model: options.model,
         system: input.systemPrompt,
         messages,
         temperature: request.temperature,
-        max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
         tools,
         tool_choice: toAnthropicToolChoice(request.toolChoice),
         stream: true
@@ -3047,6 +3203,21 @@ function buildHeaders2(options) {
     ...options.headers
   };
 }
+function buildAnthropicRequestBody(options, request, body) {
+  const bodyOutputConfig = isRecord2(body.output_config) ? body.output_config : undefined;
+  const bodyThinking = body.thinking;
+  const hasExplicitThinking = Object.prototype.hasOwnProperty.call(body, "thinking");
+  const reasoningEffort = request.reasoningEffort;
+  return cleanUndefined({
+    ...body,
+    max_tokens: resolveMaxTokens(request.maxTokens, options.defaultMaxTokens),
+    output_config: reasoningEffort ? cleanUndefined({
+      ...bodyOutputConfig,
+      effort: reasoningEffort
+    }) : bodyOutputConfig,
+    thinking: reasoningEffort ? hasExplicitThinking ? bodyThinking : { type: "adaptive" } : bodyThinking
+  });
+}
 function resolveAnthropicInput(request) {
   if (Array.isArray(request.messages) && request.messages.length > 0) {
     return toAnthropicInput(request.messages);
@@ -3401,8 +3572,34 @@ function buildProviderOptions(config) {
   };
 }
 
-// src/structured.ts
-var import_jsonrepair3 = require("jsonrepair");
+// src/utils/debug-colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m"
+};
+function color(config, text, tone) {
+  if (!config.colors) {
+    return text;
+  }
+  return `${ANSI[tone]}${text}${ANSI.reset}`;
+}
+function dim(config, text) {
+  if (!config.colors) {
+    return text;
+  }
+  return `${ANSI.dim}${text}${ANSI.reset}`;
+}
+function title(config, text) {
+  if (!config.colors) {
+    return text;
+  }
+  return `${ANSI.bold}${text}${ANSI.reset}`;
+}
 
 // src/outdent.ts
 var DEFAULT_OPTIONS = {
@@ -3541,123 +3738,682 @@ function createOutdent(options = {}) {
   return outdent;
 }
 
-// src/parse.ts
-var import_jsonrepair2 = require("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
+// src/generate-shared.ts
+var sharedOutdent = createOutdent({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true,
+  newline: `
+`
+});
+var RE_THINK_TAGS = /<\/?think\s*>/gi;
+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
     };
-    diagnostics.push(validationDiagnostic);
+  }
+  if (isPromptResolver(value)) {
+    return normalizePromptPayload(value.resolvePrompt(_context));
+  }
+  return normalizePromptPayload(value);
+}
+function normalizePromptPayload(value) {
+  const prompt = typeof value.prompt === "string" ? value.prompt : undefined;
+  const messages = Array.isArray(value.messages) ? value.messages.filter(isLLMMessage) : undefined;
+  if ((!prompt || prompt.trim().length === 0) && (!messages || messages.length === 0)) {
+    throw new Error("Structured prompt payload must include a non-empty prompt or messages.");
+  }
+  return {
+    prompt,
+    systemPrompt: typeof value.systemPrompt === "string" ? value.systemPrompt : undefined,
+    messages: messages && messages.length > 0 ? messages.map((message) => ({ ...message })) : undefined
+  };
+}
+function applyPromptOutdent(payload, enabled) {
+  if (!enabled) {
+    return payload;
+  }
+  return {
+    prompt: typeof payload.prompt === "string" ? sharedOutdent.string(payload.prompt) : undefined,
+    systemPrompt: applyOutdentToOptionalPrompt(payload.systemPrompt, enabled),
+    messages: payload.messages?.map((message) => ({
+      ...message,
+      content: typeof message.content === "string" ? sharedOutdent.string(message.content) : message.content
+    }))
+  };
+}
+function applyOutdentToOptionalPrompt(value, enabled) {
+  if (!enabled || typeof value !== "string") {
+    return value;
+  }
+  return sharedOutdent.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 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,
+      verbose: false,
+      logger: (line) => console.log(line)
+    };
+  }
+  if (!option) {
+    return {
+      enabled: false,
+      colors: true,
+      verbose: false,
+      logger: (line) => console.log(line)
+    };
+  }
+  return {
+    enabled: option.enabled ?? true,
+    colors: option.colors ?? true,
+    verbose: option.verbose ?? false,
+    logger: option.logger ?? ((line) => console.log(line))
+  };
+}
+function withToolTimeout(client, toolTimeoutMs) {
+  return {
+    id: client.id,
+    listTools: client.listTools.bind(client),
+    close: client.close?.bind(client),
+    async callTool(params) {
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(`Tool call timed out after ${toolTimeoutMs}ms`)), toolTimeoutMs);
+      });
+      try {
+        return await Promise.race([client.callTool(params), timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
+}
+function applyToolTimeout(clients, toolTimeoutMs) {
+  return clients.map((client) => withToolTimeout(client, toolTimeoutMs));
+}
+async function callModel(adapter, options) {
+  const requestSignal = options.request?.signal ?? (options.timeout?.request !== undefined ? AbortSignal.timeout(options.timeout.request) : undefined);
+  const requestPayload = {
+    prompt: options.prompt,
+    messages: options.messages,
+    systemPrompt: options.systemPrompt,
+    temperature: options.request?.temperature,
+    reasoningEffort: options.request?.reasoningEffort,
+    maxTokens: options.request?.maxTokens,
+    mcpClients: options.request?.mcpClients,
+    toolChoice: options.request?.toolChoice,
+    parallelToolCalls: options.request?.parallelToolCalls,
+    maxToolRounds: options.request?.maxToolRounds,
+    onToolExecution: options.request?.onToolExecution,
+    transformToolOutput: options.request?.transformToolOutput,
+    transformToolArguments: options.request?.transformToolArguments,
+    transformToolCallParams: options.request?.transformToolCallParams,
+    unknownToolError: options.request?.unknownToolError,
+    toolDebug: options.request?.toolDebug,
+    body: options.request?.body,
+    signal: requestSignal
+  };
+  emitDebugRequest(options.debug, {
+    label: options.debugLabel,
+    provider: adapter.provider,
+    model: adapter.model,
+    attempt: options.attempt,
+    selfHealAttempt: options.selfHeal,
+    selfHealEnabled: options.selfHealEnabled,
+    stream: options.stream.enabled && !!adapter.stream,
+    requestPayload
+  });
+  options.observe?.(options.buildEvent({
+    stage: "llm.request",
+    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 streamedProviderText = "";
+    let streamedDedicatedReasoning = "";
+    let lastSnapshotFingerprint;
+    let previousSnapshotText = "";
+    let previousSnapshotReasoning = "";
+    const emitStreamingData = (done, usage2, finishReason2) => {
+      const normalized2 = normalizeModelOutput(streamedProviderText, streamedDedicatedReasoning);
+      const snapshot = options.buildSnapshot(normalized2);
+      const fingerprint = toStreamDataFingerprint(snapshot);
+      if (!done && fingerprint === lastSnapshotFingerprint) {
+        return;
+      }
+      const delta = {
+        text: normalized2.text.startsWith(previousSnapshotText) ? normalized2.text.slice(previousSnapshotText.length) : "",
+        reasoning: normalized2.reasoning.startsWith(previousSnapshotReasoning) ? normalized2.reasoning.slice(previousSnapshotReasoning.length) : ""
+      };
+      lastSnapshotFingerprint = fingerprint;
+      previousSnapshotText = normalized2.text;
+      previousSnapshotReasoning = normalized2.reasoning;
+      options.stream.onData?.({
+        delta,
+        snapshot,
+        done,
+        usage: usage2,
+        finishReason: finishReason2
+      });
+      if (options.stream.to === "stdout" && delta.text) {
+        process.stdout.write(delta.text);
+      }
+      options.observe?.(options.buildEvent({
+        stage: "llm.stream.data",
+        message: done ? "Streaming response completed." : "Streaming response updated.",
+        details: {
+          done,
+          finishReason: finishReason2
+        }
+      }));
+    };
+    const handleTextDelta = (delta) => {
+      if (!delta) {
+        return;
+      }
+      streamedProviderText += delta;
+      options.observe?.(options.buildEvent({
+        stage: "llm.stream.delta",
+        message: "Received stream delta.",
+        details: {
+          chars: delta.length
+        }
+      }));
+      emitStreamingData(false);
+    };
+    const handleReasoningDelta = (delta) => {
+      if (!delta) {
+        return;
+      }
+      streamedDedicatedReasoning += delta;
+      emitStreamingData(false);
+    };
+    const response2 = await adapter.stream(requestPayload, {
+      onChunk: (chunk) => {
+        if (chunk.textDelta) {
+          handleTextDelta(chunk.textDelta);
+        }
+        if (chunk.reasoningDelta) {
+          handleReasoningDelta(chunk.reasoningDelta);
+        }
+        if (chunk.usage) {
+          latestUsage = preferLatestUsage(latestUsage, chunk.usage);
+        }
+        if (chunk.finishReason) {
+          latestFinishReason = chunk.finishReason;
+        }
+      }
+    });
+    streamedProviderText = typeof response2.text === "string" ? response2.text : streamedProviderText;
+    streamedDedicatedReasoning = typeof response2.reasoning === "string" ? response2.reasoning : streamedDedicatedReasoning;
+    const finalNormalized = normalizeModelOutput(streamedProviderText, streamedDedicatedReasoning);
+    const usage = preferLatestUsage(latestUsage, response2.usage);
+    const finishReason = response2.finishReason ?? latestFinishReason;
+    emitStreamingData(true, usage, finishReason);
+    options.observe?.(options.buildEvent({
+      stage: "llm.response",
+      message: "Streaming response completed.",
+      details: {
+        via: "stream",
+        chars: finalNormalized.parseSource.length,
+        finishReason
+      }
+    }));
+    emitDebugResponse(options.debug, {
+      label: options.debugLabel,
+      attempt: options.attempt,
+      selfHealAttempt: options.selfHeal,
+      selfHealEnabled: options.selfHealEnabled,
+      via: "stream",
+      text: finalNormalized.text,
+      reasoning: finalNormalized.reasoning,
+      parseSource: finalNormalized.parseSource,
+      usage,
+      finishReason
+    });
+    return {
+      text: finalNormalized.text,
+      reasoning: finalNormalized.reasoning,
+      thinkBlocks: finalNormalized.thinkBlocks,
+      parseSource: finalNormalized.parseSource,
+      via: "stream",
+      usage,
+      finishReason
+    };
+  }
+  const response = await adapter.complete(requestPayload);
+  const normalized = normalizeModelOutput(response.text, response.reasoning);
+  options.observe?.(options.buildEvent({
+    stage: "llm.response",
+    message: "Completion response received.",
+    details: {
+      via: "complete",
+      chars: normalized.parseSource.length,
+      finishReason: response.finishReason
+    }
+  }));
+  emitDebugResponse(options.debug, {
+    label: options.debugLabel,
+    attempt: options.attempt,
+    selfHealAttempt: options.selfHeal,
+    selfHealEnabled: options.selfHealEnabled,
+    via: "complete",
+    text: normalized.text,
+    reasoning: normalized.reasoning,
+    parseSource: normalized.parseSource,
+    usage: response.usage,
+    finishReason: response.finishReason
+  });
+  return {
+    text: normalized.text,
+    reasoning: normalized.reasoning,
+    thinkBlocks: normalized.thinkBlocks,
+    parseSource: normalized.parseSource,
+    via: "complete",
+    usage: response.usage,
+    finishReason: response.finishReason
+  };
+}
+function normalizeModelOutput(text, dedicatedReasoning) {
+  const sanitized = sanitizeThink(text);
+  const visibleText = stripThinkBlocks(text, sanitized.thinkBlocks);
+  const reasoning = joinReasoningSegments([
+    dedicatedReasoning,
+    ...sanitized.thinkBlocks.map((block) => block.content)
+  ]);
+  return {
+    text: visibleText,
+    reasoning,
+    thinkBlocks: sanitized.thinkBlocks,
+    parseSource: composeParseSource(visibleText, reasoning)
+  };
+}
+function composeParseSource(text, reasoning) {
+  if (typeof reasoning !== "string" || reasoning.length === 0) {
+    return text;
+  }
+  const sanitized = reasoning.replace(RE_THINK_TAGS, "");
+  if (sanitized.length === 0) {
+    return text;
+  }
+  return `<think>${sanitized}</think>${text}`;
+}
+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 isPromptResolver(value) {
+  return typeof value === "object" && value !== null && "resolvePrompt" in value && typeof value.resolvePrompt === "function";
+}
+function isLLMMessage(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  if (candidate.role !== "system" && candidate.role !== "user" && candidate.role !== "assistant" && candidate.role !== "tool") {
+    return false;
+  }
+  return "content" in candidate;
+}
+function joinReasoningSegments(parts) {
+  return parts.map((value) => value?.trim()).filter((value) => Boolean(value)).join(`
+
+`);
+}
+function stripThinkBlocks(text, thinkBlocks) {
+  if (thinkBlocks.length === 0) {
+    return text;
+  }
+  let output = "";
+  let cursor = 0;
+  for (const block of thinkBlocks) {
+    output += text.slice(cursor, block.start);
+    cursor = block.end;
+  }
+  output += text.slice(cursor);
+  return output;
+}
+function toStreamDataFingerprint(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "__unserializable__";
+  }
+}
+function emitDebugRequest(config, input) {
+  const requestBody = input.requestPayload.body !== undefined ? JSON.stringify(input.requestPayload.body, null, 2) : "(none)";
+  const requestMessages = input.requestPayload.messages !== undefined ? JSON.stringify(input.requestPayload.messages, null, 2) : "(none)";
+  const lines = [
+    color(config, title(config, [
+      `[${input.label}][request]`,
+      `attempt=${input.attempt}`,
+      `selfHealEnabled=${input.selfHealEnabled}`,
+      `selfHealAttempt=${input.selfHealAttempt}`
+    ].join(" ")), "cyan"),
+    dim(config, [
+      `provider=${input.provider ?? "unknown"}`,
+      `model=${input.model ?? "unknown"}`,
+      `stream=${input.stream}`
+    ].join(" ")),
+    color(config, "prompt:", "yellow"),
+    input.requestPayload.prompt ?? "(none)",
+    color(config, "messages:", "yellow"),
+    requestMessages,
+    color(config, "systemPrompt:", "yellow"),
+    input.requestPayload.systemPrompt ?? "(none)",
+    color(config, "request.body:", "yellow"),
+    requestBody
+  ];
+  emitDebug(config, lines.join(`
+`));
+}
+function emitDebugResponse(config, input) {
+  const text = input.text.length > 0 ? input.text : "(none)";
+  const reasoning = input.reasoning.length > 0 ? input.reasoning : "(none)";
+  const metadata = [
+    `via=${input.via}`,
+    `textChars=${input.text.length}`,
+    `reasoningChars=${input.reasoning.length}`
+  ];
+  if (config.verbose) {
+    metadata.push(`parseSourceChars=${input.parseSource.length}`);
+  }
+  metadata.push(`finishReason=${input.finishReason ?? "unknown"}`, `usage=${JSON.stringify(input.usage ?? {})}`);
+  const lines = [
+    color(config, title(config, [
+      `[${input.label}][response]`,
+      `attempt=${input.attempt}`,
+      `selfHealEnabled=${input.selfHealEnabled}`,
+      `selfHealAttempt=${input.selfHealAttempt}`
+    ].join(" ")), "green"),
+    dim(config, metadata.join(" ")),
+    color(config, "text:", "yellow"),
+    text,
+    color(config, "reasoning:", "yellow"),
+    reasoning
+  ];
+  if (config.verbose) {
+    lines.push(color(config, "parseSource:", "yellow"), input.parseSource);
+  }
+  emitDebug(config, lines.join(`
+`));
+}
+function emitDebug(config, message) {
+  if (!config.enabled) {
+    return;
+  }
+  config.logger(message);
+}
+
+// src/generate.ts
+async function generate(adapter, promptOrOptions, callOptions) {
+  const normalized = normalizeGenerateInput(promptOrOptions, callOptions);
+  const useOutdent = normalized.outdent ?? true;
+  const streamConfig = normalizeStreamConfig(normalized.stream);
+  const debugConfig = normalizeDebugConfig(normalized.debug);
+  const resolvedPrompt = applyPromptOutdent(resolvePrompt(normalized.prompt, { mode: "loose" }), useOutdent);
+  const resolvedSystemPrompt = applyOutdentToOptionalPrompt(normalized.systemPrompt, useOutdent);
+  const preparedPrompt = prepareGeneratePromptPayload(resolvedPrompt, resolvedSystemPrompt);
+  const resolvedRequest = normalized.timeout?.tool !== undefined && normalized.request?.mcpClients !== undefined ? {
+    ...normalized.request,
+    mcpClients: applyToolTimeout(normalized.request.mcpClients, normalized.timeout.tool)
+  } : normalized.request;
+  const response = await callModel(adapter, {
+    prompt: preparedPrompt.prompt,
+    messages: preparedPrompt.messages,
+    systemPrompt: preparedPrompt.systemPrompt,
+    request: resolvedRequest,
+    stream: streamConfig,
+    observe: normalized.observe,
+    buildEvent: ({ stage, message, details }) => ({
+      stage,
+      attempt: 1,
+      message,
+      details
+    }),
+    buildSnapshot: (model) => ({
+      text: model.text,
+      reasoning: model.reasoning
+    }),
+    debug: debugConfig,
+    debugLabel: "generate",
+    attempt: 1,
+    selfHeal: false,
+    selfHealEnabled: false,
+    timeout: normalized.timeout
+  });
+  const attempt = {
+    attempt: 1,
+    via: response.via,
+    text: response.text,
+    reasoning: response.reasoning,
+    usage: response.usage,
+    finishReason: response.finishReason
+  };
+  const attempts = [attempt];
+  normalized.observe?.({
+    stage: "result",
+    attempt: 1,
+    message: "Text generation completed.",
+    details: {
+      via: response.via,
+      finishReason: response.finishReason
+    }
+  });
+  return {
+    text: attempt.text,
+    reasoning: attempt.reasoning,
+    attempts,
+    usage: aggregateUsage(attempts),
+    finishReason: attempt.finishReason
+  };
+}
+function normalizeGenerateInput(promptOrOptions, callOptions) {
+  if (isGenerateOptions(promptOrOptions)) {
+    return promptOrOptions;
+  }
+  if (!promptOrOptions) {
+    throw new Error("Missing prompt in generate(adapter, prompt, options?) call.");
+  }
+  return {
+    ...callOptions ?? {},
+    prompt: promptOrOptions
+  };
+}
+function isGenerateOptions(value) {
+  return typeof value === "object" && value !== null && "prompt" in value;
+}
+function prepareGeneratePromptPayload(payload, systemPrompt) {
+  if (Array.isArray(payload.messages) && payload.messages.length > 0) {
+    const messages = payload.messages.map((message) => ({ ...message }));
+    const mergedSystemPrompt = mergeSystemPrompts(payload.systemPrompt, systemPrompt);
+    const systemMessages = mergedSystemPrompt ? [{ role: "system", content: mergedSystemPrompt }] : [];
+    return {
+      messages: [...systemMessages, ...messages]
+    };
+  }
+  const resolvedPrompt = payload.prompt?.trim();
+  if (!resolvedPrompt) {
+    throw new Error("Structured prompt payload must include a non-empty prompt or messages.");
+  }
+  return {
+    prompt: resolvedPrompt,
+    systemPrompt: mergeSystemPrompts(payload.systemPrompt, systemPrompt)
+  };
+}
+
+// src/structured.ts
+var import_jsonrepair3 = require("jsonrepair");
+
+// src/parse.ts
+var import_jsonrepair2 = require("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;
@@ -3840,48 +4596,19 @@ function formatZodIssues(issues) {
 `);
 }
 
-// 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;
+  text;
+  reasoning;
   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.text = input.text;
+    this.reasoning = input.reasoning;
     this.candidates = input.candidates;
     this.zodIssues = input.zodIssues;
     this.repairLog = input.repairLog;
@@ -3912,12 +4639,6 @@ var RE_SIMPLE_IDENTIFIER2 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var RE_ESCAPE_QUOTE = /"/g;
 var RE_WHITESPACE2 = /\s+/g;
 var DEFAULT_SELF_HEAL_MAX_DIAGNOSTICS = 8;
-var structuredOutdent = createOutdent({
-  trimLeadingNewline: true,
-  trimTrailingNewline: true,
-  newline: `
-`
-});
 var DEFAULT_STRICT_PARSE_OPTIONS = {
   repair: false,
   maxCandidates: 3,
@@ -4047,7 +4768,7 @@ async function structured(adapter, schemaOrOptions, promptInput, callOptions) {
     });
     const selfHealSource = resolveSelfHealSource(previous);
     const repairPrompt = buildSelfHealPrompt({
-      rawOutput: previous.raw,
+      rawOutput: composeParseSource(previous.text, previous.reasoning),
       issues: previous.zodIssues,
       schema: normalized.schema,
       schemaInstruction: normalized.schemaInstruction,
@@ -4120,74 +4841,6 @@ function normalizeStructuredInput(schemaOrOptions, promptInput, callOptions) {
 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) {
-  const prompt = typeof value.prompt === "string" ? value.prompt : undefined;
-  const messages = Array.isArray(value.messages) ? value.messages.filter(isLLMMessage) : undefined;
-  if ((!prompt || prompt.trim().length === 0) && (!messages || messages.length === 0)) {
-    throw new Error("Structured prompt payload must include a non-empty prompt or messages.");
-  }
-  return {
-    prompt,
-    systemPrompt: typeof value.systemPrompt === "string" ? value.systemPrompt : undefined,
-    messages: messages && messages.length > 0 ? messages.map((message) => ({ ...message })) : undefined
-  };
-}
-function applyPromptOutdent(payload, enabled) {
-  if (!enabled) {
-    return payload;
-  }
-  return {
-    prompt: typeof payload.prompt === "string" ? structuredOutdent.string(payload.prompt) : undefined,
-    systemPrompt: applyOutdentToOptionalPrompt(payload.systemPrompt, enabled),
-    messages: payload.messages?.map((message) => ({
-      ...message,
-      content: typeof message.content === "string" ? structuredOutdent.string(message.content) : message.content
-    }))
-  };
-}
-function isLLMMessage(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  if (candidate.role !== "system" && candidate.role !== "user" && candidate.role !== "assistant" && candidate.role !== "tool") {
-    return false;
-  }
-  return "content" in candidate;
-}
-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 prepareStructuredPromptPayload(payload, systemPrompt, schema, schemaInstruction) {
   if (Array.isArray(payload.messages) && payload.messages.length > 0) {
     const messages = payload.messages.map((message) => ({ ...message }));
@@ -4368,7 +5021,7 @@ function resolveSelfHealSource(attempt) {
   }
   return {
     kind: "raw",
-    text: attempt.raw
+    text: composeParseSource(attempt.text, attempt.reasoning)
   };
 }
 function isSelfHealStalled(previous, current) {
@@ -4378,60 +5031,22 @@ function isSelfHealStalled(previous, current) {
   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(RE_WHITESPACE2, " ").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)
-    };
+  if (current.parsed.errors.length < previous.parsed.errors.length) {
+    return false;
   }
-  return {
-    enabled: option.enabled ?? true,
-    colors: option.colors ?? true,
-    logger: option.logger ?? ((line) => console.log(line))
-  };
+  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(RE_WHITESPACE2, " ").trim();
 }
 async function executeAttempt(adapter, input) {
-  const response = await callModel(adapter, {
+  const response = await callModel2(adapter, {
     prompt: input.prompt,
     messages: input.messages,
     systemPrompt: input.systemPrompt,
@@ -4444,7 +5059,7 @@ async function executeAttempt(adapter, input) {
     selfHealEnabled: input.selfHealEnabled,
     timeout: input.timeout
   });
-  const parsed = parseWithObserve(response.text, input.schema, input.parseOptions, {
+  const parsed = parseWithObserve(response.parseSource, input.schema, input.parseOptions, {
     observe: input.observe,
     attempt: input.attemptNumber,
     selfHeal: input.selfHeal
@@ -4453,8 +5068,8 @@ async function executeAttempt(adapter, input) {
     attempt: input.attemptNumber,
     selfHeal: input.selfHeal,
     via: response.via,
-    raw: response.text,
-    thinkBlocks: parsed.thinkBlocks,
+    text: response.text,
+    reasoning: response.reasoning,
     json: parsed.parsed,
     candidates: parsed.candidates.map((candidate) => candidate.content),
     repairLog: collectRepairLog(parsed),
@@ -4469,199 +5084,26 @@ async function executeAttempt(adapter, input) {
     trace
   };
 }
-function withToolTimeout(client, toolTimeoutMs) {
-  return {
-    id: client.id,
-    listTools: client.listTools.bind(client),
-    close: client.close?.bind(client),
-    async callTool(params) {
-      let timeoutId;
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => reject(new Error(`Tool call timed out after ${toolTimeoutMs}ms`)), toolTimeoutMs);
-      });
-      try {
-        return await Promise.race([client.callTool(params), timeoutPromise]);
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    }
-  };
-}
-function applyToolTimeout(clients, toolTimeoutMs) {
-  return clients.map((client) => withToolTimeout(client, toolTimeoutMs));
-}
-async function callModel(adapter, options) {
-  const requestSignal = options.request?.signal ?? (options.timeout?.request !== undefined ? AbortSignal.timeout(options.timeout.request) : undefined);
-  const requestPayload = {
-    prompt: options.prompt,
-    messages: options.messages,
-    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,
-    transformToolOutput: options.request?.transformToolOutput,
-    transformToolArguments: options.request?.transformToolArguments,
-    transformToolCallParams: options.request?.transformToolCallParams,
-    unknownToolError: options.request?.unknownToolError,
-    toolDebug: options.request?.toolDebug,
-    body: options.request?.body,
-    signal: requestSignal
-  };
-  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 = preferLatestUsage(latestUsage, chunk.usage);
-        }
-        if (chunk.finishReason) {
-          latestFinishReason = chunk.finishReason;
-        }
-      }
-    });
-    const finalText = typeof response2.text === "string" && response2.text.length > 0 ? response2.text : streamedRaw;
-    const usage = preferLatestUsage(latestUsage, response2.usage);
-    const finishReason = response2.finishReason ?? latestFinishReason;
-    emitStreamingData(finalText, true, usage, finishReason);
-    emitObserve(options.observe, {
-      stage: "llm.response",
+async function callModel2(adapter, options) {
+  return callModel(adapter, {
+    ...options,
+    buildEvent: ({ stage, message, details }) => ({
+      stage,
       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
+      message,
+      details
+    }),
+    buildSnapshot: (normalized) => ({
+      text: normalized.text,
+      reasoning: normalized.reasoning,
+      data: parseStreamingStructuredData(normalized.parseSource) ?? null
+    }),
+    debugLabel: "structured"
   });
-  return {
-    text: response.text,
-    via: "complete",
-    usage: response.usage,
-    finishReason: response.finishReason
-  };
 }
-function parseStreamingStructuredData(raw) {
-  const sanitized = sanitizeThink(raw);
+function parseStreamingStructuredData(parseSource) {
+  const sanitized = sanitizeThink(parseSource);
   const start = findFirstJsonRootStart(sanitized.visibleText);
   if (start < 0) {
     return null;
@@ -4721,13 +5163,6 @@ function findFirstJsonRootStart(input) {
   }
   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, {
@@ -4757,38 +5192,20 @@ function buildSuccessResult(data, attempts) {
   const final = attempts.at(-1);
   return {
     data,
-    raw: final?.raw ?? "",
-    thinkBlocks: final?.thinkBlocks ?? [],
+    text: final?.text ?? "",
+    reasoning: final?.reasoning ?? "",
     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: [],
+      text: "",
+      reasoning: "",
       candidates: [],
       zodIssues: [],
       repairLog: [],
@@ -4796,8 +5213,8 @@ function toStructuredError(attempt) {
     });
   }
   return new StructuredParseError({
-    raw: attempt.raw,
-    thinkBlocks: attempt.thinkBlocks,
+    text: attempt.text,
+    reasoning: attempt.reasoning,
     candidates: attempt.candidates,
     zodIssues: attempt.zodIssues,
     repairLog: attempt.repairLog,
@@ -4807,59 +5224,6 @@ function toStructuredError(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 requestMessages = input.requestPayload.messages !== undefined ? JSON.stringify(input.requestPayload.messages, 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 ?? "(none)",
-    color(config, "messages:", "yellow"),
-    requestMessages,
-    color(config, "systemPrompt:", "yellow"),
-    input.requestPayload.systemPrompt ?? "(none)",
-    color(config, "request.body:", "yellow"),
-    requestBody
-  ];
-  emitDebug(config, lines.join(`
-`));
-}
-function emitDebugResponse(config, input) {
-  const 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()) {
@@ -4873,6 +5237,17 @@ function createLLM(config, registry = createDefaultProviderRegistry()) {
       const merged = mergeStructuredOptions(defaults, options);
       return structured(adapter, schema, prompt, merged);
     },
+    async generate(promptOrOptions, options) {
+      if (isGenerateOptions2(promptOrOptions)) {
+        const merged2 = {
+          ...mergeGenerateOptions(defaults, promptOrOptions),
+          prompt: promptOrOptions.prompt
+        };
+        return generate(adapter, merged2);
+      }
+      const merged = mergeGenerateOptions(defaults, options);
+      return generate(adapter, promptOrOptions, merged);
+    },
     async embed(input, options = {}) {
       if (!adapter.embed) {
         throw new Error(`Provider "${adapter.provider ?? "unknown"}" does not support embeddings.`);
@@ -4902,6 +5277,26 @@ function mergeStructuredOptions(defaults, overrides) {
     timeout: mergeObjectLike(defaults?.timeout, overrides?.timeout)
   };
 }
+function mergeGenerateOptions(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return {};
+  }
+  return {
+    outdent: overrides?.outdent ?? defaults?.outdent,
+    systemPrompt: overrides?.systemPrompt ?? defaults?.systemPrompt,
+    request: {
+      ...defaults?.request ?? {},
+      ...overrides?.request ?? {}
+    },
+    stream: mergeObjectLike(defaults?.stream, overrides?.stream),
+    debug: mergeObjectLike(defaults?.debug, overrides?.debug),
+    timeout: mergeObjectLike(defaults?.timeout, overrides?.timeout),
+    observe: overrides?.observe ?? defaults?.observe
+  };
+}
+function isGenerateOptions2(value) {
+  return typeof value === "object" && value !== null && "prompt" in value;
+}
 function mergeObjectLike(defaults, overrides) {
   if (overrides === undefined) {
     return defaults;