@cognipeer/agent-sdk 0.4.8 → 0.5.0

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var zod = require('zod');
 var module$1 = require('module');
+var zodToJsonSchema = require('zod-to-json-schema');
 var fs = require('fs');
 var path = require('path');
 var buffer = require('buffer');
@@ -134,12 +135,377 @@ function createSimpleTool({
   };
 }
 
+// src/structuredOutput/types.ts
+function getNestedValue(obj, path2) {
+  let current = obj;
+  for (const key of path2) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function formatZodError(error, rawContent) {
+  const fieldErrors = error.issues.map((issue) => ({
+    path: issue.path.join(".") || "root",
+    expected: issue.expected ?? issue.code,
+    received: issue.received ?? "unknown",
+    message: issue.message
+  }));
+  return {
+    type: "validation_error",
+    message: `Schema validation failed: ${fieldErrors.map((f) => `${f.path}: ${f.message}`).join("; ")}`,
+    fieldErrors,
+    rawContent
+  };
+}
+
+// src/structuredOutput/nativeStrategy.ts
+var NativeJsonSchemaStrategy = class {
+  constructor() {
+    this.kind = "native";
+  }
+  resolveJsonPointer(document, pointer) {
+    if (!pointer.startsWith("#/")) {
+      return void 0;
+    }
+    const segments = pointer.slice(2).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let current = document;
+    for (const segment of segments) {
+      if (!current || typeof current !== "object" || !(segment in current)) {
+        return void 0;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  unwrapRootObjectSchema(schema) {
+    if (schema.type === "object") {
+      return schema;
+    }
+    const ref = typeof schema.$ref === "string" ? schema.$ref : null;
+    if (!ref) {
+      return schema;
+    }
+    const resolved = this.resolveJsonPointer(schema, ref);
+    if (!resolved || typeof resolved !== "object" || Array.isArray(resolved)) {
+      return schema;
+    }
+    const resolvedSchema = { ...resolved };
+    if (resolvedSchema.type !== "object") {
+      return schema;
+    }
+    if (schema.definitions && resolvedSchema.definitions === void 0) {
+      resolvedSchema.definitions = schema.definitions;
+    }
+    if (schema.$defs && resolvedSchema.$defs === void 0) {
+      resolvedSchema.$defs = schema.$defs;
+    }
+    return resolvedSchema;
+  }
+  normalizeOpenAIStrictSchema(schema) {
+    const visit = (node) => {
+      if (!node || typeof node !== "object") return node;
+      if (Array.isArray(node)) {
+        return node.map(visit);
+      }
+      const clone2 = { ...node };
+      if (clone2.properties && typeof clone2.properties === "object") {
+        const normalizedProperties = {};
+        for (const [key, value] of Object.entries(clone2.properties)) {
+          normalizedProperties[key] = visit(value);
+        }
+        clone2.properties = normalizedProperties;
+        clone2.required = Object.keys(normalizedProperties);
+        if (clone2.additionalProperties === void 0) {
+          clone2.additionalProperties = false;
+        }
+      }
+      if (clone2.items) {
+        clone2.items = visit(clone2.items);
+      }
+      if (clone2.definitions && typeof clone2.definitions === "object") {
+        const normalizedDefinitions = {};
+        for (const [key, value] of Object.entries(clone2.definitions)) {
+          normalizedDefinitions[key] = visit(value);
+        }
+        clone2.definitions = normalizedDefinitions;
+      }
+      if (clone2.$defs && typeof clone2.$defs === "object") {
+        const normalizedDefs = {};
+        for (const [key, value] of Object.entries(clone2.$defs)) {
+          normalizedDefs[key] = visit(value);
+        }
+        clone2.$defs = normalizedDefs;
+      }
+      for (const compositeKey of ["anyOf", "oneOf", "allOf"]) {
+        if (Array.isArray(clone2[compositeKey])) {
+          clone2[compositeKey] = clone2[compositeKey].map(visit);
+        }
+      }
+      return clone2;
+    };
+    return visit(schema);
+  }
+  /**
+   * Convert a Zod schema to the JSON Schema object used in response_format.
+   */
+  toJsonSchema(schema, name = "structured_response") {
+    const result = zodToJsonSchema.zodToJsonSchema(schema, {
+      name,
+      openaiStrictMode: true,
+      nameStrategy: "duplicate-ref",
+      $refStrategy: "extract-to-root",
+      nullableStrategy: "property"
+    });
+    const normalized = this.normalizeOpenAIStrictSchema(result);
+    return this.unwrapRootObjectSchema(normalized);
+  }
+  /**
+   * Build response_format configuration for the model call.
+   * Returns the object that should be spread into model invocation options.
+   */
+  buildResponseFormat(schema, name) {
+    const schemaName = name || "structured_response";
+    const jsonSchema = this.toJsonSchema(schema, schemaName);
+    delete jsonSchema["$schema"];
+    return {
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: schemaName,
+          strict: true,
+          schema: jsonSchema
+        }
+      }
+    };
+  }
+  /**
+   * Parse and validate model response content.
+   * With native support, content is guaranteed JSON — but we still validate with Zod
+   * for type safety and field-level error reporting.
+   */
+  extractOutput(content, schema) {
+    try {
+      const raw = JSON.parse(content);
+      const validated = schema.parse(raw);
+      return { data: validated };
+    } catch (e) {
+      if (e?.issues) {
+        return { error: formatZodError(e, content) };
+      }
+      return {
+        error: {
+          type: "parse_error",
+          message: `Failed to parse native structured output: ${e?.message}`,
+          rawContent: content
+        }
+      };
+    }
+  }
+  buildCorrectionPrompt(error, previousAttempt) {
+    const fieldIssues = error.issues.map((issue) => {
+      const pathStr = issue.path.join(".") || "root";
+      const received = getNestedValue(previousAttempt, issue.path);
+      return `- "${pathStr}": ${issue.message} (received: ${JSON.stringify(received)})`;
+    }).join("\n");
+    return [
+      "Your previous JSON response had validation errors:",
+      fieldIssues,
+      "",
+      "Please output corrected JSON matching the schema."
+    ].join("\n");
+  }
+};
+
+// src/tool.ts
+function createTool({
+  name,
+  description,
+  schema,
+  func,
+  needsApproval,
+  approvalPrompt,
+  approvalDefaults,
+  maxExecutionsPerRun
+}) {
+  const execute = async (input) => func(input);
+  const toolRecord = {
+    name,
+    description,
+    schema,
+    // Our runtime prefers invoke but fallback helpers keep compatibility with LC-style tools.
+    invoke: execute,
+    call: execute,
+    run: execute,
+    func: execute
+  };
+  if (typeof needsApproval === "boolean") {
+    toolRecord.needsApproval = needsApproval;
+  }
+  if (approvalPrompt !== void 0) {
+    toolRecord.approvalPrompt = approvalPrompt;
+  }
+  if (approvalDefaults !== void 0) {
+    toolRecord.approvalDefaults = approvalDefaults;
+  }
+  if (maxExecutionsPerRun !== void 0) {
+    toolRecord.maxExecutionsPerRun = maxExecutionsPerRun;
+  }
+  toolRecord.__source = toolRecord.__source || "smart";
+  toolRecord.__impl = func;
+  return toolRecord;
+}
+
+// src/structuredOutput/toolStrategy.ts
+var ToolBasedStrategy = class {
+  constructor() {
+    this.kind = "tool_based";
+  }
+  /**
+   * Create the `response` tool for a given Zod schema.
+   * The tool validates input against the schema and returns a sentinel object
+   * that the tools node picks up to finalize the structured output.
+   */
+  createResponseTool(schema) {
+    return createTool({
+      name: "response",
+      description: "Finalize the answer by returning the final structured JSON matching the required schema. Call exactly once when you are fully done, then stop.",
+      schema,
+      func: async (data) => {
+        try {
+          const validated = schema.parse ? schema.parse(data) : data;
+          return { __finalStructuredOutput: true, data: validated };
+        } catch (e) {
+          const zodError = e;
+          if (zodError?.issues) {
+            const soError = formatZodError(zodError);
+            return {
+              error: "Schema validation failed",
+              details: soError.message,
+              fieldErrors: soError.fieldErrors
+            };
+          }
+          return { error: "Schema validation failed", details: e?.message };
+        }
+      }
+    });
+  }
+  /**
+   * Try to extract structured output from raw assistant text content.
+   * Used as a last resort when the model writes JSON directly instead of calling the tool.
+   */
+  extractFromText(content, schema) {
+    let jsonText = null;
+    const fenced = content.match(/```(?:json)?\n([\s\S]*?)```/i);
+    if (fenced && fenced[1]) {
+      jsonText = fenced[1].trim();
+    } else {
+      const braceIdx = content.indexOf("{");
+      const bracketIdx = content.indexOf("[");
+      const candidates = [braceIdx, bracketIdx].filter((i) => i >= 0).sort((a, b) => a - b);
+      if (candidates.length > 0) {
+        jsonText = content.slice(candidates[0]).trim();
+      }
+    }
+    try {
+      const raw = JSON.parse(jsonText ?? content);
+      const validated = schema.parse(raw);
+      return { data: validated };
+    } catch (e) {
+      if (e?.issues) {
+        return { error: formatZodError(e, content) };
+      }
+      return {
+        error: {
+          type: "parse_error",
+          message: `Failed to parse JSON from assistant message: ${e?.message}`,
+          rawContent: content
+        }
+      };
+    }
+  }
+  buildCorrectionPrompt(error, previousAttempt) {
+    const fieldIssues = error.issues.map((issue) => {
+      const pathStr = issue.path.join(".") || "root";
+      const received = getNestedValue(previousAttempt, issue.path);
+      return `- "${pathStr}": ${issue.message} (received: ${JSON.stringify(received)})`;
+    }).join("\n");
+    return [
+      "Your previous structured output had validation errors:",
+      fieldIssues,
+      "",
+      "Please call `response` again with corrected values matching the schema."
+    ].join("\n");
+  }
+};
+
+// src/structuredOutput/resolver.ts
+function resolveStrategy(model) {
+  const capabilities = getModelCapabilities(model);
+  if (capabilities.structuredOutput === "native") {
+    return new NativeJsonSchemaStrategy();
+  }
+  return new ToolBasedStrategy();
+}
+function getModelCapabilities(model) {
+  if (model?.capabilities && typeof model.capabilities === "object") {
+    return model.capabilities;
+  }
+  const provider = detectProvider(model);
+  if (provider) {
+    return {
+      provider,
+      structuredOutput: supportsNativeStructuredOutput(provider) ? "native" : "tool_based",
+      strictToolCalling: requiresStrictToolCalling(provider),
+      streaming: true
+    };
+  }
+  return { structuredOutput: "tool_based" };
+}
+function detectProvider(model) {
+  if (!model || typeof model !== "object") return void 0;
+  if (typeof model.provider === "string") return model.provider;
+  const lcModel = model._lc;
+  if (lcModel) {
+    return detectProviderFromLCModel(lcModel);
+  }
+  const modelName = model.modelName || model.model || "";
+  if (modelName.startsWith("gpt-") || modelName.startsWith("o1") || modelName.startsWith("o3") || modelName.startsWith("o4")) return "openai";
+  if (modelName.startsWith("claude")) return "anthropic";
+  if (modelName.startsWith("gemini")) return "google";
+  if (modelName.startsWith("amazon.") || modelName.startsWith("anthropic.")) return "bedrock";
+  return void 0;
+}
+function detectProviderFromLCModel(lcModel) {
+  if (!lcModel) return void 0;
+  const className = lcModel.constructor?.name || "";
+  if (className.includes("ChatOpenAI") || className.includes("AzureChatOpenAI")) return "openai";
+  if (className.includes("ChatAnthropic")) return "anthropic";
+  if (className.includes("ChatGoogleGenerativeAI") || className.includes("ChatVertexAI")) return "google";
+  if (className.includes("ChatBedrock") || className.includes("BedrockChat")) return "bedrock";
+  if (className.includes("ChatGroq")) return "groq";
+  if (className.includes("ChatMistralAI")) return "mistral";
+  const llmType = typeof lcModel._llmType === "function" ? lcModel._llmType() : lcModel._llmType;
+  if (typeof llmType === "string") {
+    if (llmType.includes("openai")) return "openai";
+    if (llmType.includes("anthropic")) return "anthropic";
+    if (llmType.includes("google")) return "google";
+  }
+  return void 0;
+}
+function supportsNativeStructuredOutput(provider) {
+  return ["openai", "google", "groq", "mistral"].includes(provider);
+}
+function requiresStrictToolCalling(provider) {
+  return ["openai"].includes(provider);
+}
+
 // src/model.ts
 function isSmartModel(m) {
   return !!m && typeof m === "object" && typeof m.invoke === "function";
 }
-function withTools(model, tools) {
-  if (model?.bindTools) return model.bindTools(tools);
+function withTools(model, tools, options) {
+  if (model?.bindTools) return model.bindTools(tools, options);
   return model;
 }
 function fromLangchainModel(lcModel) {
@@ -184,7 +550,8 @@ function fromLangchainModel(lcModel) {
           role: response.role || "assistant",
           content,
           tool_calls: response.tool_calls,
-          usage: response.usage,
+          usage: response.usage ?? response.usage_metadata ?? response.response_metadata?.token_usage ?? response.response_metadata?.tokenUsage,
+          usage_metadata: response.usage_metadata,
           response_metadata: response.response_metadata,
           ...response
         };
@@ -200,14 +567,14 @@ function fromLangchainModel(lcModel) {
         yield chunk;
       }
     },
-    bindTools: (tools) => {
+    bindTools: (tools, options) => {
       const lcReady = toLangchainTools(tools);
       if (typeof lcModel.bindTools === "function") {
-        const bound = lcModel.bindTools(lcReady);
+        const bound = lcModel.bindTools(lcReady, options);
         return fromLangchainModel(bound);
       }
       if (typeof lcModel.bind === "function") {
-        const bound = lcModel.bind({ tools: lcReady });
+        const bound = lcModel.bind({ tools: lcReady, ...options || {} });
         return fromLangchainModel(bound);
       }
       return adapted;
@@ -215,48 +582,10 @@ function fromLangchainModel(lcModel) {
     modelName: lcModel.modelName || lcModel._modelId || lcModel._llmType || lcModel.name,
     _lc: lcModel
   };
+  adapted.capabilities = getModelCapabilities(adapted);
   return adapted;
 }
 
-// src/tool.ts
-function createTool({
-  name,
-  description,
-  schema,
-  func,
-  needsApproval,
-  approvalPrompt,
-  approvalDefaults,
-  maxExecutionsPerRun
-}) {
-  const execute = async (input) => func(input);
-  const toolRecord = {
-    name,
-    description,
-    schema,
-    // Our runtime prefers invoke but fallback helpers keep compatibility with LC-style tools.
-    invoke: execute,
-    call: execute,
-    run: execute,
-    func: execute
-  };
-  if (typeof needsApproval === "boolean") {
-    toolRecord.needsApproval = needsApproval;
-  }
-  if (approvalPrompt !== void 0) {
-    toolRecord.approvalPrompt = approvalPrompt;
-  }
-  if (approvalDefaults !== void 0) {
-    toolRecord.approvalDefaults = approvalDefaults;
-  }
-  if (maxExecutionsPerRun !== void 0) {
-    toolRecord.maxExecutionsPerRun = maxExecutionsPerRun;
-  }
-  toolRecord.__source = toolRecord.__source || "smart";
-  toolRecord.__impl = func;
-  return toolRecord;
-}
-
 // src/prompts.ts
 var DEFAULT_TODO_LIST_PROMPT = `Planning tools are available when they materially improve execution.
 
@@ -339,23 +668,39 @@ function normalizeUsage(raw) {
     raw.totalTokens,
     (typeof prompt === "number" ? prompt : 0) + (typeof completion === "number" ? completion : 0)
   );
-  const promptDetailsSrc = raw.prompt_tokens_details || raw.promptTokensDetails || raw.input_token_details || raw.inputTokenDetails || {};
-  const completionDetailsSrc = raw.completion_tokens_details || raw.completionTokensDetails || raw.output_token_details || raw.outputTokenDetails || {};
+  const promptDetailsSrc = raw.prompt_tokens_details || raw.promptTokensDetails || raw.input_token_details || raw.inputTokenDetails || raw.input_tokens_details || raw.inputTokensDetails || {};
+  const completionDetailsSrc = raw.completion_tokens_details || raw.completionTokensDetails || raw.output_token_details || raw.outputTokenDetails || raw.output_tokens_details || raw.outputTokensDetails || {};
+  const cachedTokens = num(
+    promptDetailsSrc.cached_tokens,
+    promptDetailsSrc.cachedTokens,
+    promptDetailsSrc.cached,
+    promptDetailsSrc.cache_read,
+    promptDetailsSrc.cacheRead,
+    promptDetailsSrc.cache_read_tokens,
+    raw.cached_input_tokens,
+    raw.cachedInputTokens,
+    raw.cached_prompt_tokens,
+    raw.cachedPromptTokens,
+    raw.cache_read_input_tokens,
+    raw.cacheReadInputTokens
+  );
   const normalized = {
     prompt_tokens: safe(prompt),
     completion_tokens: safe(completion),
     total_tokens: safe(total || (prompt || 0) + (completion || 0)),
     prompt_tokens_details: {
-      cached_tokens: safe(
-        promptDetailsSrc.cached_tokens || promptDetailsSrc.cached || promptDetailsSrc.cache_read || raw.cached_input_tokens || raw.cached_prompt_tokens || raw.cache_read_input_tokens
-      ),
-      audio_tokens: safe(promptDetailsSrc.audio_tokens || promptDetailsSrc.audio)
+      cached_tokens: safe(cachedTokens),
+      audio_tokens: safe(num(promptDetailsSrc.audio_tokens, promptDetailsSrc.audioTokens, promptDetailsSrc.audio))
     },
     completion_tokens_details: {
-      reasoning_tokens: safe(completionDetailsSrc.reasoning_tokens),
-      audio_tokens: safe(completionDetailsSrc.audio_tokens),
-      accepted_prediction_tokens: safe(completionDetailsSrc.accepted_prediction_tokens),
-      rejected_prediction_tokens: safe(completionDetailsSrc.rejected_prediction_tokens)
+      reasoning_tokens: safe(num(completionDetailsSrc.reasoning_tokens, completionDetailsSrc.reasoningTokens)),
+      audio_tokens: safe(num(completionDetailsSrc.audio_tokens, completionDetailsSrc.audioTokens)),
+      accepted_prediction_tokens: safe(
+        num(completionDetailsSrc.accepted_prediction_tokens, completionDetailsSrc.acceptedPredictionTokens)
+      ),
+      rejected_prediction_tokens: safe(
+        num(completionDetailsSrc.rejected_prediction_tokens, completionDetailsSrc.rejectedPredictionTokens)
+      )
     },
     raw
   };
@@ -465,21 +810,21 @@ var METADATA_PATHS = {
     "lc_kwargs.provider"
   ]
 };
-function getNestedValue(obj, path2) {
+function getNestedValue2(obj, path2) {
   if (!obj || typeof path2 !== "string") return void 0;
   return path2.split(".").reduce((current, key) => current?.[key], obj);
 }
 function extractMetadata(model, paths) {
   if (!model) return void 0;
   for (const path2 of paths) {
-    const value = getNestedValue(model, path2);
+    const value = getNestedValue2(model, path2);
     const str = coerceToString(value);
     if (str) return str;
   }
   const maybeLc = model?._lc;
   if (maybeLc) {
     for (const path2 of paths) {
-      const value = getNestedValue(maybeLc, path2);
+      const value = getNestedValue2(maybeLc, path2);
       const str = coerceToString(value);
       if (str) return str;
     }
@@ -487,7 +832,7 @@ function extractMetadata(model, paths) {
   const maybeClient = model?.client || model?.api || model?.service;
   if (maybeClient) {
     for (const path2 of paths) {
-      const value = getNestedValue(maybeClient, path2);
+      const value = getNestedValue2(maybeClient, path2);
       const str = coerceToString(value);
       if (str) return str;
     }
@@ -519,7 +864,7 @@ function inferModelFromMessages(messageList) {
     const message = messageList[i];
     if (!message) continue;
     for (const path2 of messagePaths) {
-      const value = getNestedValue(message, path2);
+      const value = getNestedValue2(message, path2);
       const str = coerceToString(value);
       if (str) return str;
     }
@@ -538,7 +883,7 @@ function inferProviderFromMessages(messageList) {
     const message = messageList[i];
     if (!message) continue;
     for (const path2 of messagePaths) {
-      const value = getNestedValue(message, path2);
+      const value = getNestedValue2(message, path2);
       const str = coerceToString(value);
       if (str) return str;
     }
@@ -1549,7 +1894,13 @@ function createAgentCoreNode(opts) {
       tracing: opts.tracing
     };
     const tools = runtime.tools ?? [];
-    const modelWithTools = runtime.model?.bindTools ? runtime.model.bindTools(tools) : runtime.model;
+    const shouldUseStrictToolCalling = Boolean(
+      runtime.responseFormat && runtime.model?.capabilities?.strictToolCalling
+    );
+    const modelWithTools = runtime.model?.bindTools ? runtime.model.bindTools(
+      tools,
+      shouldUseStrictToolCalling ? { strict: true } : void 0
+    ) : runtime.model;
     const traceSession = state.ctx?.__traceSession;
     const actorName = runtime.name ?? opts.name ?? "agent";
     const actorVersion = runtime.version ?? opts.version;
@@ -1626,6 +1977,7 @@ function createAgentCoreNode(opts) {
     const streamingEnabled = Boolean(state.ctx?.__streaming);
     const cancellationToken = state.ctx?.__cancellationToken;
     const abortSignal = state.ctx?.__abortSignal;
+    const responseFormat = runtime.responseFormat;
     const extractText = (chunk) => {
       if (chunk == null) return "";
       if (typeof chunk === "string") return chunk;
@@ -1644,7 +1996,8 @@ function createAgentCoreNode(opts) {
       if (streamingEnabled && typeof modelWithTools.stream === "function") {
         let streamedText = "";
         let streamedMessage;
-        for await (const chunk of modelWithTools.stream(normalizedMessages, { signal: abortSignal, cancellationToken })) {
+        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat };
+        for await (const chunk of modelWithTools.stream(normalizedMessages, streamOptions)) {
           if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
             break;
           }
@@ -1667,7 +2020,7 @@ function createAgentCoreNode(opts) {
           response = { role: "assistant", content: streamedText };
         }
       } else {
-        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken });
+        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat });
       }
     } catch (err) {
       const durationMs2 = Date.now() - start;
@@ -1689,7 +2042,7 @@ function createAgentCoreNode(opts) {
       ...state.messages,
       response
     ];
-    const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage;
+    const rawUsage = response?.usage || response?.usage_metadata || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage || response?.response_metadata?.usage_metadata || response?.response_metadata?.usageMetadata;
     const normalized = normalizeUsage(rawUsage);
     const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
     const durationMs = Date.now() - start;
@@ -2214,6 +2567,16 @@ function countSuccessfulToolExecutions(toolHistory, toolName) {
   if (!Array.isArray(toolHistory)) return 0;
   return toolHistory.filter((entry) => entry?.toolName === toolName && (entry?.status === "success" || entry?.status === "handoff")).length;
 }
+function normalizeToolCall(call) {
+  if (!call || typeof call !== "object") return null;
+  const name = call.name ?? call.tool ?? call.function?.name ?? call.function_call?.name;
+  if (typeof name !== "string" || name.length === 0) return null;
+  return {
+    id: call.id,
+    name,
+    args: call.args ?? call.arguments ?? call.input ?? call.function?.arguments ?? call.function_call?.arguments
+  };
+}
 function createToolsNode(initialTools, opts) {
   return async (state) => {
     const runtime = state.agent || {
@@ -2248,12 +2611,14 @@ function createToolsNode(initialTools, opts) {
       if (anyTool._stateRef && typeof anyTool._stateRef === "object") {
         anyTool._stateRef.toolHistory = state.toolHistory;
         anyTool._stateRef.toolHistoryArchived = state.toolHistoryArchived;
+        anyTool._stateRef.pendingApprovals = pendingApprovals;
+        anyTool._stateRef.ctx = state.ctx || (state.ctx = {});
         anyTool._stateRef.__onEvent = onEvent;
       }
     }
     const last = state.messages[state.messages.length - 1];
     let toolCount = state.toolCallCount || 0;
-    const toolCalls = Array.isArray(last?.tool_calls) ? last.tool_calls : [];
+    const toolCalls = Array.isArray(last?.tool_calls) ? last.tool_calls.map((toolCall) => normalizeToolCall(toolCall)).filter((toolCall) => toolCall !== null) : [];
     const toolHistory = state.toolHistory || [];
     const toolHistoryArchived = state.toolHistoryArchived || [];
     const remaining = Math.max(0, limits.maxToolCalls - toolCount);
@@ -2312,6 +2677,13 @@ function createToolsNode(initialTools, opts) {
         args = validatedArgs.value;
       }
       const toolName = tool.name || tc.name;
+      const toolStateRef = tool._stateRef && typeof tool._stateRef === "object" ? tool._stateRef : null;
+      if (toolStateRef) {
+        toolStateRef.pendingApprovals = pendingApprovals;
+        toolStateRef.ctx = state.ctx || (state.ctx = {});
+        toolStateRef.__currentToolCallId = toolCallId;
+        delete toolStateRef.__awaitingApproval;
+      }
       const maxExecutionsPerRun = normalizeMaxExecutionsPerRun(tool.maxExecutionsPerRun);
       if (maxExecutionsPerRun !== null) {
         const currentExecutions = countSuccessfulToolExecutions(toolHistory, toolName);
@@ -2424,6 +2796,22 @@ function createToolsNode(initialTools, opts) {
           toolCount += 1;
           return { status: "success", approval: approvalEntry };
         }
+        if (output && typeof output === "object" && output.__awaitingToolApproval) {
+          if (toolStateRef?.ctx && typeof toolStateRef.ctx === "object") {
+            state.ctx = toolStateRef.ctx;
+          }
+          const pendingApproval = pendingApprovals.find(
+            (entry) => entry.toolCallId === output.toolCallId || entry.id === output.approvalId
+          );
+          if (!pendingApproval) {
+            throw new Error(`Tool ${toolName} requested approval but no pending approval entry was recorded.`);
+          }
+          awaitingApproval = true;
+          return {
+            status: "awaiting_approval",
+            approval: pendingApproval
+          };
+        }
         if (output && typeof output === "object" && output.__finalStructuredOutput) {
           if (!state.ctx) state.ctx = {};
           state.ctx.__structuredOutputParsed = output.data;
@@ -2846,6 +3234,153 @@ function resolveToolApprovalState(state, resolution) {
   };
 }
 
+// src/structuredOutput/manager.ts
+var StructuredOutputManager = class {
+  constructor(schema, strategy, config) {
+    this.schema = schema;
+    this.strategy = strategy;
+    this.maxRetries = config?.maxRetries ?? 2;
+  }
+  // --- Setup Phase ---
+  /**
+   * Get the `response` tool for tool-based strategy.
+   * Returns undefined for native strategy (no tool needed).
+   */
+  getResponseTool() {
+    if (this.strategy.kind !== "tool_based") return void 0;
+    return this.strategy.createResponseTool(this.schema);
+  }
+  /**
+   * Get response_format config for native strategy.
+   * Returns undefined for tool-based strategy.
+   */
+  getResponseFormat() {
+    if (this.strategy.kind !== "native") return void 0;
+    return this.strategy.buildResponseFormat(this.schema);
+  }
+  /**
+   * Build the system prompt hint that tells the model how to produce structured output.
+   */
+  buildSystemPromptHint() {
+    if (this.strategy.kind === "native") {
+      return [
+        "A structured output schema is active.",
+        "Your response MUST be valid JSON matching the output schema.",
+        "Do NOT wrap the JSON in code fences or add any text before/after it."
+      ].join("\n");
+    }
+    return [
+      "A structured output schema is active.",
+      "Do NOT output the final JSON directly as an assistant message.",
+      "When completely finished, call tool `response` passing the final JSON matching the schema as its arguments (direct object).",
+      "Call it exactly once then STOP producing further assistant messages."
+    ].join("\n");
+  }
+  /**
+   * Build a nudge message for when the model didn't produce structured output.
+   * Used by the agent loop when it needs to retry.
+   */
+  buildNudgeMessage(isLastAttempt) {
+    if (this.strategy.kind === "native") {
+      return {
+        role: "system",
+        content: [
+          "A structured output schema is active.",
+          "You MUST respond with valid JSON matching the schema.",
+          "Do NOT include any text outside the JSON object.",
+          isLastAttempt ? "This is your FINAL attempt. Produce the JSON NOW." : ""
+        ].filter(Boolean).join("\n")
+      };
+    }
+    return {
+      role: "system",
+      content: [
+        "A structured output schema is active.",
+        "You MUST now call tool `response` with the final JSON object that matches the schema.",
+        "Do not write the JSON in the assistant message.",
+        "Call `response` exactly once, then stop.",
+        isLastAttempt ? "Do NOT call any other tools. Produce the response NOW based on whatever information you have gathered so far." : ""
+      ].filter(Boolean).join("\n")
+    };
+  }
+  /**
+   * Build a correction message when schema validation failed.
+   */
+  buildCorrectionMessage(error, _previousAttempt) {
+    if (error.fieldErrors && error.fieldErrors.length > 0) {
+      const fieldIssues = error.fieldErrors.map((f) => `- "${f.path}": ${f.message} (received: ${JSON.stringify(f.received)})`).join("\n");
+      const action = this.strategy.kind === "native" ? "Please output corrected JSON matching the schema." : "Please call `response` again with corrected values matching the schema.";
+      return {
+        role: "system",
+        content: [
+          "Your previous structured output had validation errors:",
+          fieldIssues,
+          "",
+          action
+        ].join("\n")
+      };
+    }
+    return this.buildNudgeMessage(false);
+  }
+  // --- Parse Phase ---
+  /**
+   * Try to parse structured output from the tool-based finalization result.
+   * Called when __structuredOutputParsed is available in ctx.
+   */
+  parseFromToolResult(data) {
+    return { success: true, data, attempts: 1 };
+  }
+  /**
+   * Try to parse structured output from assistant message content.
+   * For native strategy: content should be valid JSON.
+   * For tool-based strategy: last-resort fallback extraction from text.
+   */
+  parseFromContent(content) {
+    if (this.strategy.kind === "native") {
+      const result2 = this.strategy.extractOutput(content, this.schema);
+      if ("data" in result2) {
+        return { success: true, data: result2.data, attempts: 1 };
+      }
+      return { success: false, error: result2.error, attempts: 1, rawContent: content };
+    }
+    const result = this.strategy.extractFromText(content, this.schema);
+    if ("data" in result) {
+      return { success: true, data: result.data, attempts: 1 };
+    }
+    return { success: false, error: result.error, attempts: 1, rawContent: content };
+  }
+  /**
+   * Create a "no output" error result.
+   */
+  noOutputResult(attempts, rawContent) {
+    return {
+      success: false,
+      error: {
+        type: "no_output",
+        message: "Model did not produce structured output after all retry attempts.",
+        rawContent
+      },
+      attempts,
+      rawContent
+    };
+  }
+  /**
+   * Create a "max retries" error result.
+   */
+  maxRetriesResult(lastError, attempts, rawContent) {
+    return {
+      success: false,
+      error: {
+        ...lastError,
+        type: "max_retries",
+        message: `Structured output failed after ${attempts} attempts: ${lastError.message}`
+      },
+      attempts,
+      rawContent
+    };
+  }
+};
+
 // src/agent.ts
 function isSyntheticSummaryMessage(message) {
   if (!message) return false;
@@ -2897,14 +3432,13 @@ function createAgent(opts) {
   const resolver = createResolverNode();
   const agentCore = createAgentCoreNode(opts);
   const toolsBase = [...opts.tools ?? []];
-  if (opts.outputSchema) {
-    const responseTool = createTool({
-      name: "response",
-      description: "Finalize the answer by returning the final structured JSON matching the required schema. Call exactly once when you are fully done, then stop.",
-      schema: opts.outputSchema,
-      func: async (data) => ({ __finalStructuredOutput: true, data })
-    });
-    toolsBase.push(responseTool);
+  const soManager = opts.outputSchema ? new StructuredOutputManager(opts.outputSchema, resolveStrategy(opts.model)) : void 0;
+  if (soManager) {
+    const modelCapabilities = getModelCapabilities(opts.model);
+    const responseTool = soManager.getResponseTool();
+    if (responseTool && modelCapabilities.structuredOutput !== "native") {
+      toolsBase.push(responseTool);
+    }
   }
   const toolsNode = createToolsNode(toolsBase, opts);
   const finalizeNode = createToolLimitFinalizeNode();
@@ -2939,6 +3473,7 @@ function createAgent(opts) {
     limits: opts.limits,
     useTodoList: void 0,
     outputSchema: opts.outputSchema,
+    responseFormat: soManager?.getResponseFormat(),
     tracing: opts.tracing
   };
   const summarizationThreshold = getActiveSummarizationThreshold(opts);
@@ -3077,10 +3612,11 @@ function createAgent(opts) {
           });
           const tokenCount = countMessagesTokens(tokCountMessages);
           if (tokenCount > summarizationThreshold) {
+            const summarizationExhausted = !!state.ctx?.__summarizationExhausted;
             const hasFreshSummary = (state.messages || []).some(
               (m) => m.role === "tool" && typeof m.content === "string" && (m.content === "SUMMARIZED" || m.content.startsWith("SUMMARIZED_TOOL_RESPONSE"))
             );
-            if (hasFreshSummary && tokenCount <= summarizationThreshold * 1.15) ; else {
+            if (hasFreshSummary && tokenCount <= summarizationThreshold * 1.15) ; else if (summarizationExhausted) ; else {
               const ctx = { ...state.ctx || {}, __needsSummarization: true };
               state = { ...state, ctx };
               break;
@@ -3157,7 +3693,15 @@ function createAgent(opts) {
         state = { ...state, ...await finalizeNode(state) };
         continue;
       }
-      if (toolCalls.length === 0) break;
+      if (toolCalls.length === 0) {
+        if (soManager && !state.ctx?.__finalizedDueToStructuredOutput && !state.ctx?.__structuredOutputForceFinalize) {
+          const nudge = soManager.buildNudgeMessage(false);
+          const ctx = { ...state.ctx || {}, __structuredOutputForceFinalize: true };
+          state = { ...state, messages: [...state.messages, nudge], ctx };
+          continue;
+        }
+        break;
+      }
       onProgress?.({ stage: "tools", message: "Running tools" });
       if (cancelIfRequested("before_tools")) break;
       state = { ...state, ...await toolsNode(state) };
@@ -3166,35 +3710,28 @@ function createAgent(opts) {
       if (checkpointIfRequested("after_tools")) break;
       if (state.ctx?.__finalizedDueToStructuredOutput) break;
     }
-    if (opts.outputSchema && !state.ctx?.__finalizedDueToStructuredOutput) {
-      const last = state.messages[state.messages.length - 1];
-      const lastHasToolCalls = Array.isArray(last?.tool_calls) && last.tool_calls.length > 0;
-      if (!lastHasToolCalls) {
-        const forceMsg = {
-          role: "system",
-          content: [
-            "A structured output schema is active.",
-            "You MUST now call tool `response` with the final JSON object that matches the schema.",
-            "Do not write the JSON in the assistant message.",
-            "Call `response` exactly once, then stop."
-          ].join("\n")
-        };
-        const alreadyForced = Boolean(state.ctx?.__structuredOutputForceFinalize);
-        if (!alreadyForced) {
-          const ctx = { ...state.ctx || {}, __structuredOutputForceFinalize: true };
-          state = { ...state, messages: [...state.messages, forceMsg], ctx };
-          try {
-            state = { ...state, ...await agentCore(state) };
-            const lastAfter = state.messages[state.messages.length - 1];
-            const toolCallsAfter = Array.isArray(lastAfter?.tool_calls) ? lastAfter.tool_calls : [];
-            if (toolCallsAfter.length > 0) {
-              state = { ...state, ...await toolsNode(state) };
-            }
-          } catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            emit?.({ type: "metadata", error: `Structured output force-finalize failed: ${errMsg}` });
-            throw err;
+    if (soManager && !state.ctx?.__finalizedDueToStructuredOutput) {
+      const maxPostLoopRetries = soManager.maxRetries;
+      for (let postRetry = 0; postRetry < maxPostLoopRetries; postRetry++) {
+        if (state.ctx?.__finalizedDueToStructuredOutput) break;
+        const last = state.messages[state.messages.length - 1];
+        const lastHasToolCalls = Array.isArray(last?.tool_calls) && last.tool_calls.length > 0;
+        if (!lastHasToolCalls) {
+          const isLastAttempt = postRetry === maxPostLoopRetries - 1;
+          const nudge = soManager.buildNudgeMessage(isLastAttempt);
+          state = { ...state, messages: [...state.messages, nudge] };
+        }
+        try {
+          state = { ...state, ...await agentCore(state) };
+          const lastAfter = state.messages[state.messages.length - 1];
+          const toolCallsAfter = Array.isArray(lastAfter?.tool_calls) ? lastAfter.tool_calls : [];
+          if (toolCallsAfter.length > 0) {
+            state = { ...state, ...await toolsNode(state) };
           }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          emit?.({ type: "metadata", error: `Structured output force-finalize failed: ${errMsg}` });
+          throw err;
         }
       }
     }
@@ -3284,23 +3821,22 @@ function createAgent(opts) {
     const finalAssistantMsg = getLastAssistantMessage(res.messages);
     const content = getMessageText(finalAssistantMsg);
     let parsed = void 0;
-    const schema = opts.outputSchema;
-    if (schema && res.ctx?.__structuredOutputParsed) {
-      parsed = res.ctx.__structuredOutputParsed;
-    } else if (schema && content) {
-      let jsonText = null;
-      const fenced = content.match(/```(?:json)?\n([\s\S]*?)```/i);
-      if (fenced && fenced[1]) jsonText = fenced[1].trim();
-      else {
-        const braceIdx = content.indexOf("{");
-        const bracketIdx = content.indexOf("[");
-        const start = [braceIdx, bracketIdx].filter((i) => i >= 0).sort((a, b) => a - b)[0];
-        if (start !== void 0) jsonText = content.slice(start).trim();
-      }
-      try {
-        const raw = JSON.parse(jsonText ?? content);
-        parsed = schema.parse(raw);
-      } catch {
+    let outputError = void 0;
+    if (soManager) {
+      if (res.ctx?.__structuredOutputParsed) {
+        parsed = res.ctx.__structuredOutputParsed;
+      } else if (content) {
+        const fallbackResult = soManager.parseFromContent(content);
+        if (fallbackResult.success) {
+          parsed = fallbackResult.data;
+        } else {
+          outputError = fallbackResult.error;
+        }
+      } else {
+        const noResult = soManager.noOutputResult(1);
+        if (!noResult.success) {
+          outputError = noResult.error;
+        }
       }
     }
     emit({ type: "finalAnswer", content });
@@ -3311,6 +3847,7 @@ function createAgent(opts) {
     return {
       content,
       output: parsed,
+      outputError,
       metadata: { usage: res.usage },
       messages: res.messages,
       state: res
@@ -3434,7 +3971,7 @@ function createAgentNode(opts) {
       ...messages,
       response
     ];
-    const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.usage;
+    const rawUsage = response?.usage || response?.usage_metadata || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage || response?.response_metadata?.usage_metadata || response?.response_metadata?.usageMetadata;
     const normalized = normalizeUsage(rawUsage);
     const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
     const providerName = getProviderName(runtime.model || opts.model);
@@ -3493,14 +4030,23 @@ function collectRecentTurns(messages, lastTurnsToKeep) {
   if (lastTurnsToKeep <= 0) return [];
   const systemPrefix = messages.filter((message, index) => index === 0 && message.role === "system");
   const body = systemPrefix.length > 0 ? messages.slice(1) : [...messages];
-  let userTurnCount = 0;
+  const totalUserTurns = body.filter((m) => m.role === "user").length;
+  const countAssistantTurns = totalUserTurns < lastTurnsToKeep;
+  let turnCount = 0;
   const collected = [];
   for (let index = body.length - 1; index >= 0; index -= 1) {
     const message = body[index];
     collected.unshift(message);
-    if (message.role === "user") {
-      userTurnCount += 1;
-      if (userTurnCount >= lastTurnsToKeep) break;
+    const isTurnBoundary = countAssistantTurns ? message.role === "assistant" : message.role === "user";
+    if (isTurnBoundary) {
+      turnCount += 1;
+      if (turnCount >= lastTurnsToKeep) break;
+    }
+  }
+  if (countAssistantTurns && collected.length > 0 && collected[0].role !== "user") {
+    const firstUserMsg = body.find((m) => m.role === "user");
+    if (firstUserMsg && !collected.includes(firstUserMsg)) {
+      collected.unshift(firstUserMsg);
     }
   }
   return [...systemPrefix, ...collected];
@@ -3540,16 +4086,53 @@ function clampToBudget(messages, maxContextTokens) {
     if (tokenCount <= maxContextTokens) return working;
     const firstNonSystem = working.findIndex((message, index) => !(index === 0 && message.role === "system"));
     if (firstNonSystem < 0) break;
-    working.splice(firstNonSystem, 1);
-  }
-  return working;
-}
-function buildModelMessages(state, config) {
-  const rawMessages = state.messages || [];
-  if (config.context.policy === "raw") {
-    return clampToBudget(rawMessages, config.limits.maxContextTokens);
-  }
-  const recentMessages = collectRecentTurns(rawMessages, config.context.lastTurnsToKeep);
+    const target = working[firstNonSystem];
+    if (target.role === "assistant" && Array.isArray(target.tool_calls) && target.tool_calls.length > 0) {
+      const toolCallIds = new Set(
+        target.tool_calls.map((tc) => tc.id).filter(Boolean)
+      );
+      working = working.filter((m, idx) => {
+        if (idx === firstNonSystem) return false;
+        if (m.role === "tool" && m.tool_call_id && toolCallIds.has(m.tool_call_id)) return false;
+        return true;
+      });
+    } else if (target.role === "tool") {
+      const toolCallId = target.tool_call_id;
+      let parentIdx = -1;
+      if (toolCallId) {
+        for (let i = firstNonSystem - 1; i >= 0; i--) {
+          const m = working[i];
+          if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.some((tc) => tc.id === toolCallId)) {
+            parentIdx = i;
+            break;
+          }
+        }
+      }
+      if (parentIdx >= 0) {
+        const parent = working[parentIdx];
+        const parentToolCallIds = new Set(
+          (parent.tool_calls || []).map((tc) => tc.id).filter(Boolean)
+        );
+        working = working.filter((m, idx) => {
+          if (idx === parentIdx) return false;
+          if (m.role === "tool" && m.tool_call_id && parentToolCallIds.has(m.tool_call_id)) return false;
+          return true;
+        });
+      } else {
+        working.splice(firstNonSystem, 1);
+      }
+    } else {
+      working.splice(firstNonSystem, 1);
+    }
+  }
+  return working;
+}
+function buildModelMessages(state, config) {
+  const rawMessages = state.messages || [];
+  if (config.context.policy === "raw") {
+    return clampToBudget(rawMessages, config.limits.maxContextTokens);
+  }
+  const recentMessages = collectRecentTurns(rawMessages, config.context.lastTurnsToKeep);
   const latestSummary = state.summaryRecords?.[state.summaryRecords.length - 1];
   const summaryText = renderStructuredSummary(latestSummary);
   const memoryText = renderMemoryBlock(state.memoryFacts);
@@ -4190,6 +4773,12 @@ function calculateAdherenceScore(todoList) {
   const completedCount = todoList.filter((item) => item.status === "completed").length;
   return todoList.length === 0 ? 1 : Number((completedCount / todoList.length).toFixed(2));
 }
+function formatTodoListSummary(todoList) {
+  if (!Array.isArray(todoList) || todoList.length === 0) {
+    return "No plan items.";
+  }
+  return todoList.map((item) => `${item.id}. ${item.title || item.step || item.description || `Step ${item.id}`} [${item.status}]`).join("\n");
+}
 function createContextTools(stateRef, opts) {
   const tools = [];
   if (opts?.planningEnabled) {
@@ -4202,11 +4791,43 @@ function createContextTools(stateRef, opts) {
         todoList: zod.z.array(zod.z.union([todoWriteItemSchema, todoUpdateItemSchema])).optional()
       }),
       func: async ({ operation, expectedVersion, todoList }) => {
-        const onEvent = manageTodo._stateRef?.__onEvent;
+        const toolStateRef = manageTodo._stateRef;
+        const onEvent = toolStateRef?.__onEvent;
+        const emitPlanEvent = (list) => {
+          const version = stateRef.planVersion || 1;
+          const adherenceScore = stateRef.adherenceScore || 0;
+          const planData = {
+            source: "manage_todo_list",
+            operation,
+            version,
+            adherenceScore,
+            count: Array.isArray(list) ? list.length : 0
+          };
+          onEvent?.({ type: "plan", todoList: list, ...planData });
+          const traceSession = toolStateRef?.ctx?.__traceSession;
+          recordTraceEvent(traceSession, {
+            type: "plan",
+            label: `Plan ${operation}`,
+            actor: { scope: "agent", name: "manage_todo_list", role: "planner" },
+            sections: [
+              {
+                kind: "summary",
+                label: "Todo List",
+                content: formatTodoListSummary(list)
+              },
+              {
+                kind: "metadata",
+                label: "Plan Metadata",
+                data: planData
+              }
+            ],
+            debug: planData
+          });
+        };
         const currentVersion = stateRef.planVersion || 0;
         if (operation === "read") {
           const list = stateRef.todoList || [];
-          onEvent?.({ type: "plan", source: "manage_todo_list", operation: "read", todoList: list, version: stateRef.planVersion || 1, adherenceScore: stateRef.adherenceScore || 0 });
+          emitPlanEvent(list);
           return list;
         }
         if (typeof expectedVersion === "number" && expectedVersion !== currentVersion) {
@@ -4271,9 +4892,10 @@ function createContextTools(stateRef, opts) {
               adherenceScore: stateRef.adherenceScore || 0
             };
           }
-          const patchIds = /* @__PURE__ */ new Set();
+          const currentMap = new Map(currentList.map((item) => [item.id, item]));
+          const patchMap = /* @__PURE__ */ new Map();
           for (const item of parsed.data) {
-            if (patchIds.has(item.id)) {
+            if (patchMap.has(item.id)) {
               return {
                 status: "error",
                 operation,
@@ -4282,10 +4904,7 @@ function createContextTools(stateRef, opts) {
                 adherenceScore: stateRef.adherenceScore || 0
               };
             }
-            patchIds.add(item.id);
-          }
-          const currentMap = new Map(currentList.map((item) => [item.id, item]));
-          for (const item of parsed.data) {
+            patchMap.set(item.id, item);
             if (!currentMap.has(item.id)) {
               return {
                 status: "error",
@@ -4297,7 +4916,7 @@ function createContextTools(stateRef, opts) {
             }
           }
           const mergedList = currentList.map((item) => {
-            const patch = parsed.data.find((candidate) => candidate.id === item.id);
+            const patch = patchMap.get(item.id);
             return patch ? normalizeTodoItem(patch, item) : item;
           });
           const validation = validatePlanInvariants(mergedList, false);
@@ -4321,7 +4940,7 @@ function createContextTools(stateRef, opts) {
           version: stateRef.planVersion || 1,
           adherenceScore: stateRef.adherenceScore || 0
         };
-        onEvent?.({ type: "plan", source: "manage_todo_list", operation, todoList: stateRef.todoList, version: stateRef.planVersion || 1, adherenceScore: stateRef.adherenceScore || 0 });
+        emitPlanEvent(stateRef.todoList || []);
         return payload;
       }
     });
@@ -4346,23 +4965,6 @@ function createContextTools(stateRef, opts) {
   });
   getTool._stateRef = stateRef;
   tools.push(getTool);
-  if (opts?.outputSchema) {
-    const responseTool = createTool({
-      name: "response",
-      description: "Finalize the answer by returning the final structured JSON matching the required schema. Call exactly once when you are fully done, then stop.",
-      schema: opts.outputSchema.shape ? opts.outputSchema : zod.z.any(),
-      func: async (data) => {
-        try {
-          const validated = opts.outputSchema.parse ? opts.outputSchema.parse(data) : data;
-          return { __finalStructuredOutput: true, data: validated };
-        } catch (e) {
-          return { error: "Schema validation failed", details: e?.message };
-        }
-      }
-    });
-    responseTool._stateRef = stateRef;
-    tools.push(responseTool);
-  }
   return tools;
 }
 
@@ -4571,7 +5173,7 @@ function createSmartAgent(opts) {
     useTodoList: planningEnabled
   };
   const stateRef = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0, planVersion: 0, adherenceScore: 0 };
-  const contextTools = createContextTools(stateRef, { planningEnabled, outputSchema: void 0 });
+  const contextTools = createContextTools(stateRef, { planningEnabled });
   const mergedTools = [...opts.tools ?? [], ...contextTools];
   const base = createAgent({ ...runtimeOpts, tools: mergedTools });
   base.__runtime.runtimeProfile = resolved.runtimeProfile;
@@ -4580,12 +5182,8 @@ function createSmartAgent(opts) {
   const summarizer = summarizationEnabled ? createContextSummarizeNode(runtimeOpts) : void 0;
   const decideBefore = resolverDecisionFactory(runtimeOpts, summarizationEnabled);
   const decideAfter = toolsDecisionFactory(runtimeOpts, summarizationEnabled);
-  const structuredOutputHint = opts.outputSchema ? [
-    "A structured output schema is active.",
-    "Do NOT output the final JSON directly as an assistant message.",
-    "When completely finished, call tool `response` passing the final JSON matching the schema as its arguments (direct object).",
-    "Call it exactly once then STOP producing further assistant messages."
-  ].join("\n") : "";
+  const soManager = opts.outputSchema ? new StructuredOutputManager(opts.outputSchema, resolveStrategy(opts.model)) : void 0;
+  const structuredOutputHint = soManager ? soManager.buildSystemPromptHint() : "";
   const runtimeHint = [
     resolved.runtimeProfile === resolved.baseProfile ? `Runtime profile: ${resolved.runtimeProfile}.` : `Runtime profile: ${resolved.runtimeProfile} (base: ${resolved.baseProfile}).`,
     `Context policy: ${resolved.context.policy}.`,
@@ -4655,8 +5253,13 @@ function createSmartAgent(opts) {
         const next = summarizationEnabled ? decideBefore(state) : "agent";
         if (next === "contextSummarize" && summarizer) {
           const delta = await summarizer(state);
-          if (!delta || Object.keys(delta).length === 0) ; else {
-            state = await persistLatestSummary(syncPlanState({ ...state, ...delta }));
+          if (!delta || Object.keys(delta).length === 0) {
+            const ctx = { ...state.ctx || {}, __summarizationExhausted: true };
+            state = { ...state, ctx };
+          } else {
+            const ctx = { ...state.ctx || {} };
+            delete ctx.__summarizationExhausted;
+            state = await persistLatestSummary(syncPlanState({ ...state, ...delta, ctx }));
             rawMessages = [...state.messages || rawMessages];
             continue;
           }
@@ -4689,20 +5292,32 @@ function createSmartAgent(opts) {
           state = { ...state, ctx };
           const delta = await summarizer(state);
           if (delta && Object.keys(delta).length > 0) {
-            state = await persistLatestSummary(syncPlanState({ ...state, ...delta }));
+            const successCtx = { ...state.ctx || {} };
+            delete successCtx.__summarizationExhausted;
+            state = await persistLatestSummary(syncPlanState({ ...state, ...delta, ctx: successCtx }));
             rawMessages = [...state.messages || rawMessages];
             continue;
+          } else {
+            const exhaustedCtx = { ...state.ctx || {}, __summarizationExhausted: true };
+            state = { ...state, ctx: exhaustedCtx };
+            continue;
           }
         }
         if (state.ctx?.__finalizedDueToStructuredOutput) break;
+        if (opts.outputSchema && lastResult?.output != null) break;
         if (summarizationEnabled) {
           const after = decideAfter(state);
           if (after === "contextSummarize" && summarizer) {
             const delta = await summarizer(state);
             if (delta && Object.keys(delta).length > 0) {
-              state = await persistLatestSummary(syncPlanState({ ...state, ...delta }));
+              const successCtx = { ...state.ctx || {} };
+              delete successCtx.__summarizationExhausted;
+              state = await persistLatestSummary(syncPlanState({ ...state, ...delta, ctx: successCtx }));
               rawMessages = [...state.messages || rawMessages];
               continue;
+            } else {
+              const exhaustedCtx = { ...state.ctx || {}, __summarizationExhausted: true };
+              state = { ...state, ctx: exhaustedCtx };
             }
           }
         }
@@ -5145,9 +5760,1754 @@ function createCodeGuardrail(options) {
   });
 }
 
+// src/providers/types.ts
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cachedWriteTokens: 0,
+    cachedOutputTokens: 0,
+    reasoningTokens: 0
+  };
+}
+var ProviderError = class extends Error {
+  constructor(message, provider, statusCode, responseBody) {
+    super(message);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ProviderError";
+  }
+};
+
+// src/providers/base.ts
+var BaseProvider = class {
+};
+
+// src/providers/utils/sse.ts
+async function* parseSSEStream(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) ;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/\r?\n\r?\n/);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        if (!part.trim()) continue;
+        const event = parseSSEBlock(part);
+        if (event) yield event;
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseSSEBlock(buffer);
+      if (event) yield event;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseSSEBlock(block) {
+  let event;
+  let id;
+  let retry;
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith(":")) continue;
+    const colonIdx = line.indexOf(":");
+    let field;
+    let value;
+    if (colonIdx === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        event = value;
+        break;
+      case "data":
+        dataLines.push(value);
+        break;
+      case "id":
+        id = value;
+        break;
+      case "retry": {
+        const n = parseInt(value, 10);
+        if (!isNaN(n)) retry = n;
+        break;
+      }
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join("\n"), id, retry };
+}
+
+// src/providers/openai.ts
+var OpenAIProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.providerName = "openai";
+    this.apiKey = config.apiKey;
+    this.baseURL = (config.baseURL ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    this.defaultModel = config.defaultModel ?? "gpt-4o";
+    this.defaultHeaders = {
+      ...config.defaultHeaders,
+      ...config.organization ? { "OpenAI-Organization": config.organization } : {}
+    };
+  }
+  async complete(request) {
+    const body = this.buildRequestBody(request, false);
+    const res = await this.doFetch(body);
+    const json = await res.json();
+    return this.parseResponse(json);
+  }
+  async *completeStream(request) {
+    const body = this.buildRequestBody(request, true);
+    const res = await this.doFetch(body);
+    if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    let id = "";
+    let model = "";
+    const toolCallBuffers = /* @__PURE__ */ new Map();
+    let usage;
+    for await (const event of parseSSEStream(res.body)) {
+      if (event.data === "[DONE]") break;
+      let chunk;
+      try {
+        chunk = JSON.parse(event.data);
+      } catch {
+        continue;
+      }
+      id = chunk.id ?? id;
+      model = chunk.model ?? model;
+      const choice = chunk.choices?.[0];
+      if (chunk.usage) {
+        usage = this.extractUsage(chunk.usage);
+      }
+      if (!choice) {
+        if (usage) yield { id, model, delta: {}, usage };
+        continue;
+      }
+      const delta = choice.delta ?? {};
+      const out = {
+        id,
+        model,
+        delta: {},
+        finishReason: mapFinishReason(choice.finish_reason)
+      };
+      if (delta.content) {
+        out.delta.content = delta.content;
+      }
+      if (delta.tool_calls) {
+        const partials = [];
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          if (!toolCallBuffers.has(idx)) {
+            toolCallBuffers.set(idx, { id: tc.id ?? "", name: "", arguments: "" });
+          }
+          const buf = toolCallBuffers.get(idx);
+          if (tc.id) buf.id = tc.id;
+          if (tc.function?.name) buf.name = tc.function.name;
+          if (tc.function?.arguments) buf.arguments += tc.function.arguments;
+          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments });
+        }
+        out.delta.toolCalls = partials;
+      }
+      if (usage) out.usage = usage;
+      yield out;
+    }
+  }
+  // ─── Internals ───────────────────────────────────────────────────────────
+  buildRequestBody(request, stream) {
+    const body = {
+      model: request.model || this.defaultModel,
+      messages: request.messages.map((m) => this.toOpenAIMessage(m)),
+      stream
+    };
+    if (stream) {
+      body.stream_options = { include_usage: true };
+    }
+    if (request.temperature != null) body.temperature = request.temperature;
+    if (request.maxTokens != null) body.max_tokens = request.maxTokens;
+    if (request.topP != null) body.top_p = request.topP;
+    if (request.stop) body.stop = request.stop;
+    if (request.tools?.length) {
+      body.tools = request.tools.map((t) => this.toOpenAITool(t));
+    }
+    if (request.toolChoice != null) {
+      if (typeof request.toolChoice === "string") {
+        body.tool_choice = request.toolChoice;
+      } else {
+        body.tool_choice = { type: "function", function: { name: request.toolChoice.name } };
+      }
+    }
+    if (request.responseFormat) {
+      if (request.responseFormat.type === "json_schema") {
+        body.response_format = {
+          type: "json_schema",
+          json_schema: {
+            name: request.responseFormat.name ?? "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else if (request.responseFormat.type === "json_object") {
+        body.response_format = { type: "json_object" };
+      }
+    }
+    if (request.extra) {
+      Object.assign(body, request.extra);
+    }
+    return body;
+  }
+  toOpenAIMessage(m) {
+    const msg = { role: m.role };
+    if (typeof m.content === "string") {
+      msg.content = m.content;
+    } else if (Array.isArray(m.content)) {
+      msg.content = m.content.map((part) => {
+        if (part.type === "text") return { type: "text", text: part.text };
+        if (part.type === "image") {
+          const src = part.source;
+          const url = src.type === "url" ? src.url : `data:${src.mediaType};base64,${src.data}`;
+          return { type: "image_url", image_url: { url } };
+        }
+        return part;
+      });
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      msg.tool_calls = m.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }));
+    }
+    if (m.role === "tool" && m.toolCallId) {
+      msg.tool_call_id = m.toolCallId;
+    }
+    if (m.name) msg.name = m.name;
+    return msg;
+  }
+  toOpenAITool(t) {
+    const fn = {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    };
+    if (t.strict) {
+      fn.strict = true;
+    }
+    return { type: "function", function: fn };
+  }
+  async doFetch(body) {
+    const url = `${this.baseURL}/chat/completions`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...this.defaultHeaders
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `OpenAI API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
+  parseResponse(json) {
+    const choice = json.choices?.[0];
+    const message = choice?.message ?? {};
+    const toolCalls = (message.tool_calls ?? []).map((tc) => ({
+      id: tc.id,
+      name: tc.function?.name ?? "",
+      arguments: tc.function?.arguments ?? "{}"
+    }));
+    return {
+      id: json.id ?? "",
+      model: json.model ?? "",
+      content: message.content ?? null,
+      toolCalls,
+      usage: this.extractUsage(json.usage),
+      finishReason: mapFinishReason(choice?.finish_reason),
+      raw: json
+    };
+  }
+  extractUsage(usage) {
+    if (!usage) return emptyUsage();
+    const promptDetails = usage.prompt_tokens_details ?? {};
+    const completionDetails = usage.completion_tokens_details ?? {};
+    return {
+      inputTokens: usage.prompt_tokens ?? 0,
+      outputTokens: usage.completion_tokens ?? 0,
+      totalTokens: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
+      cachedInputTokens: promptDetails.cached_tokens ?? 0,
+      cachedWriteTokens: 0,
+      cachedOutputTokens: 0,
+      reasoningTokens: completionDetails.reasoning_tokens ?? 0
+    };
+  }
+};
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+
+// src/providers/anthropic.ts
+var AnthropicProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.providerName = "anthropic";
+    this.apiKey = config.apiKey;
+    this.baseURL = (config.baseURL ?? "https://api.anthropic.com").replace(/\/$/, "");
+    this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    this.anthropicVersion = config.anthropicVersion ?? "2023-06-01";
+  }
+  async complete(request) {
+    const body = this.buildRequestBody(request, false);
+    const res = await this.doFetch(body);
+    const json = await res.json();
+    return this.parseResponse(json);
+  }
+  async *completeStream(request) {
+    const body = this.buildRequestBody(request, true);
+    const res = await this.doFetch(body);
+    if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    let id = "";
+    let model = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    let cacheCreationInputTokens = 0;
+    const currentToolCalls = /* @__PURE__ */ new Map();
+    for await (const event of parseSSEStream(res.body)) {
+      let data;
+      try {
+        data = JSON.parse(event.data);
+      } catch {
+        continue;
+      }
+      const eventType = event.event ?? data.type;
+      switch (eventType) {
+        case "message_start": {
+          const msg = data.message;
+          id = msg?.id ?? "";
+          model = msg?.model ?? "";
+          if (msg?.usage) {
+            inputTokens = msg.usage.input_tokens ?? 0;
+            cacheReadInputTokens = msg.usage.cache_read_input_tokens ?? 0;
+            cacheCreationInputTokens = msg.usage.cache_creation_input_tokens ?? 0;
+          }
+          break;
+        }
+        case "content_block_start": {
+          const idx = data.index ?? 0;
+          const block = data.content_block;
+          if (block?.type === "tool_use") {
+            currentToolCalls.set(idx, {
+              id: block.id ?? "",
+              name: block.name ?? "",
+              arguments: ""
+            });
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const idx = data.index ?? 0;
+          const delta = data.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            yield {
+              id,
+              model,
+              delta: { content: delta.text }
+            };
+          } else if (delta?.type === "input_json_delta" && delta.partial_json) {
+            const tc = currentToolCalls.get(idx);
+            if (tc) {
+              tc.arguments += delta.partial_json;
+              yield {
+                id,
+                model,
+                delta: {
+                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json }]
+                }
+              };
+            }
+          }
+          break;
+        }
+        case "content_block_stop":
+          break;
+        case "message_delta": {
+          const delta = data.delta;
+          if (data.usage) {
+            outputTokens = data.usage.output_tokens ?? outputTokens;
+          }
+          const finishReason = mapAnthropicStopReason(delta?.stop_reason);
+          const usage = {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            cachedInputTokens: cacheReadInputTokens,
+            cachedWriteTokens: cacheCreationInputTokens,
+            cachedOutputTokens: 0,
+            reasoningTokens: 0
+          };
+          yield {
+            id,
+            model,
+            delta: {},
+            finishReason,
+            usage
+          };
+          break;
+        }
+        case "message_stop":
+          break;
+        case "error": {
+          const errMsg = data.error?.message ?? "Unknown Anthropic streaming error";
+          throw new ProviderError(errMsg, this.providerName);
+        }
+      }
+    }
+  }
+  // ─── Internals ───────────────────────────────────────────────────────────
+  buildRequestBody(request, stream) {
+    const { system, messages } = this.splitSystemMessages(request.messages);
+    const body = {
+      model: request.model || this.defaultModel,
+      messages: messages.map((m) => this.toAnthropicMessage(m)),
+      max_tokens: request.maxTokens ?? 4096,
+      stream
+    };
+    if (system) body.system = system;
+    if (request.temperature != null) body.temperature = request.temperature;
+    if (request.topP != null) body.top_p = request.topP;
+    if (request.stop) body.stop_sequences = request.stop;
+    if (request.tools?.length) {
+      body.tools = request.tools.map((t) => this.toAnthropicTool(t));
+    }
+    if (request.toolChoice != null) {
+      if (request.toolChoice === "auto") {
+        body.tool_choice = { type: "auto" };
+      } else if (request.toolChoice === "required") {
+        body.tool_choice = { type: "any" };
+      } else if (request.toolChoice === "none") ; else {
+        body.tool_choice = { type: "tool", name: request.toolChoice.name };
+      }
+    }
+    if (request.extra) {
+      Object.assign(body, request.extra);
+    }
+    return body;
+  }
+  splitSystemMessages(messages) {
+    const systemParts = [];
+    const rest = [];
+    for (const m of messages) {
+      if (m.role === "system") {
+        if (typeof m.content === "string") {
+          systemParts.push(m.content);
+        } else {
+          const text = m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+          if (text) systemParts.push(text);
+        }
+      } else {
+        rest.push(m);
+      }
+    }
+    return {
+      system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+      messages: rest
+    };
+  }
+  toAnthropicMessage(m) {
+    if (m.role === "tool" && m.toolCallId) {
+      const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+      return {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: m.toolCallId,
+            content
+          }
+        ]
+      };
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      const content = [];
+      if (typeof m.content === "string" && m.content) {
+        content.push({ type: "text", text: m.content });
+      }
+      for (const tc of m.toolCalls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: safeJsonParse(tc.arguments)
+        });
+      }
+      return { role: "assistant", content };
+    }
+    const msg = { role: m.role };
+    if (typeof m.content === "string") {
+      msg.content = m.content;
+    } else if (Array.isArray(m.content)) {
+      msg.content = m.content.map((part) => {
+        if (part.type === "text") return { type: "text", text: part.text };
+        if (part.type === "image") {
+          const src = part.source;
+          if (src.type === "base64") {
+            return {
+              type: "image",
+              source: { type: "base64", media_type: src.mediaType, data: src.data }
+            };
+          }
+          return {
+            type: "image",
+            source: { type: "url", url: src.url }
+          };
+        }
+        return part;
+      });
+    }
+    return msg;
+  }
+  toAnthropicTool(t) {
+    return {
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters
+    };
+  }
+  async doFetch(body) {
+    const url = `${this.baseURL}/v1/messages`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": this.anthropicVersion,
+        ...this.defaultHeaders
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Anthropic API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
+  parseResponse(json) {
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of json.content ?? []) {
+      if (block.type === "text") {
+        textParts.push(block.text);
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input)
+        });
+      }
+    }
+    const usage = json.usage ?? {};
+    const tokenUsage = {
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+      cachedInputTokens: usage.cache_read_input_tokens ?? 0,
+      cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
+      cachedOutputTokens: 0,
+      reasoningTokens: 0
+    };
+    return {
+      id: json.id ?? "",
+      model: json.model ?? "",
+      content: textParts.join("") || null,
+      toolCalls,
+      usage: tokenUsage,
+      finishReason: mapAnthropicStopReason(json.stop_reason),
+      raw: json
+    };
+  }
+};
+function mapAnthropicStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    default:
+      return "stop";
+  }
+}
+function safeJsonParse(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return {};
+  }
+}
+
+// src/providers/azure.ts
+var AzureProvider = class extends OpenAIProvider {
+  constructor(config) {
+    super({
+      provider: "openai",
+      apiKey: config.apiKey,
+      defaultModel: config.defaultModel ?? config.deploymentName ?? "gpt-4o",
+      defaultHeaders: config.defaultHeaders
+    });
+    this.providerName = "azure";
+    this.endpoint = config.endpoint.replace(/\/$/, "");
+    this.apiVersion = config.apiVersion ?? "2024-10-21";
+    this.deploymentName = config.deploymentName;
+    this.azureApiKey = config.apiKey;
+  }
+  async doFetch(body) {
+    const deployment = this.deploymentName ?? body.model;
+    if (!deployment) {
+      throw new ProviderError("Azure requires a deploymentName or model", this.providerName);
+    }
+    const url = `${this.endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${this.apiVersion}`;
+    const { model: _model, ...bodyWithoutModel } = body;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.azureApiKey,
+        ...this.defaultHeaders
+      },
+      body: JSON.stringify(bodyWithoutModel)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Azure OpenAI API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
+};
+
+// src/providers/openaiCompatible.ts
+var OpenAICompatibleProvider = class extends OpenAIProvider {
+  constructor(config) {
+    super({
+      provider: "openai",
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+      defaultModel: config.defaultModel,
+      defaultHeaders: config.defaultHeaders
+    });
+    this.providerName = "openai-compatible";
+  }
+};
+function signRequest(req) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStamp = toDateStamp(now);
+  const amzDate = toAmzDate(now);
+  const parsed = new URL(req.url);
+  const host = parsed.host;
+  const canonicalUri = parsed.pathname || "/";
+  const canonicalQuerystring = sortQueryParams(parsed.searchParams);
+  const headers = {
+    ...req.headers,
+    host,
+    "x-amz-date": amzDate
+  };
+  if (req.credentials.sessionToken) {
+    headers["x-amz-security-token"] = req.credentials.sessionToken;
+  }
+  const signedHeaderKeys = Object.keys(headers).map((k) => k.toLowerCase()).sort();
+  const canonicalHeaders = signedHeaderKeys.map((k) => `${k}:${headers[Object.keys(headers).find((h) => h.toLowerCase() === k)]?.trim()}`).join("\n") + "\n";
+  const signedHeaders = signedHeaderKeys.join(";");
+  const payloadHash = sha256(req.body);
+  const canonicalRequest = [
+    req.method,
+    canonicalUri,
+    canonicalQuerystring,
+    canonicalHeaders,
+    signedHeaders,
+    payloadHash
+  ].join("\n");
+  const credentialScope = `${dateStamp}/${req.region}/${req.service}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    credentialScope,
+    sha256(canonicalRequest)
+  ].join("\n");
+  const signingKey = getSignatureKey(
+    req.credentials.secretAccessKey,
+    dateStamp,
+    req.region,
+    req.service
+  );
+  const signature = hmacHex(signingKey, stringToSign);
+  const authorization = `AWS4-HMAC-SHA256 Credential=${req.credentials.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  const result = {
+    ...req.headers,
+    "x-amz-date": amzDate,
+    Authorization: authorization
+  };
+  if (req.credentials.sessionToken) {
+    result["x-amz-security-token"] = req.credentials.sessionToken;
+  }
+  return result;
+}
+function toDateStamp(d) {
+  return d.toISOString().replace(/[-:T]/g, "").slice(0, 8);
+}
+function toAmzDate(d) {
+  return d.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
+function sha256(data) {
+  return crypto.createHash("sha256").update(data, "utf8").digest("hex");
+}
+function hmac(key, data) {
+  return crypto.createHmac("sha256", key).update(data, "utf8").digest();
+}
+function hmacHex(key, data) {
+  return crypto.createHmac("sha256", key).update(data, "utf8").digest("hex");
+}
+function getSignatureKey(secret, dateStamp, region, service) {
+  const kDate = hmac(`AWS4${secret}`, dateStamp);
+  const kRegion = hmac(kDate, region);
+  const kService = hmac(kRegion, service);
+  return hmac(kService, "aws4_request");
+}
+function sortQueryParams(params) {
+  const sorted = [...params.entries()].sort(([a], [b]) => a.localeCompare(b));
+  return sorted.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+}
+
+// src/providers/bedrock.ts
+var BedrockProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.providerName = "bedrock";
+    this.region = config.region;
+    this.defaultModel = config.defaultModel ?? "anthropic.claude-sonnet-4-20250514-v1:0";
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    this.credentials = {
+      accessKeyId: config.accessKeyId ?? process.env.AWS_ACCESS_KEY_ID ?? "",
+      secretAccessKey: config.secretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY ?? "",
+      sessionToken: config.sessionToken ?? process.env.AWS_SESSION_TOKEN
+    };
+    if (!this.credentials.accessKeyId || !this.credentials.secretAccessKey) {
+      throw new ProviderError(
+        "AWS credentials required: provide accessKeyId/secretAccessKey or set AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY env vars",
+        "bedrock"
+      );
+    }
+  }
+  async complete(request) {
+    const modelId = request.model || this.defaultModel;
+    const body = this.buildConverseBody(request);
+    const json = await this.doFetch(modelId, body);
+    return this.parseResponse(json, modelId);
+  }
+  async *completeStream(request) {
+    const response = await this.complete(request);
+    yield {
+      id: response.id,
+      model: response.model,
+      delta: {
+        content: response.content ?? void 0,
+        toolCalls: response.toolCalls.length > 0 ? response.toolCalls : void 0
+      },
+      usage: response.usage,
+      finishReason: response.finishReason
+    };
+  }
+  // ─── Internals ───────────────────────────────────────────────────────────
+  buildConverseBody(request) {
+    const { system, messages } = this.splitSystemMessages(request.messages);
+    const body = {
+      messages: messages.map((m) => this.toBedrockMessage(m))
+    };
+    if (system.length > 0) {
+      body.system = system.map((s) => ({ text: s }));
+    }
+    const inferenceConfig = {};
+    if (request.maxTokens != null) inferenceConfig.maxTokens = request.maxTokens;
+    if (request.temperature != null) inferenceConfig.temperature = request.temperature;
+    if (request.topP != null) inferenceConfig.topP = request.topP;
+    if (request.stop) inferenceConfig.stopSequences = request.stop;
+    if (Object.keys(inferenceConfig).length > 0) body.inferenceConfig = inferenceConfig;
+    if (request.tools?.length) {
+      body.toolConfig = {
+        tools: request.tools.map((t) => this.toBedrockTool(t))
+      };
+      if (request.toolChoice != null) {
+        if (request.toolChoice === "auto") {
+          body.toolConfig.toolChoice = { auto: {} };
+        } else if (request.toolChoice === "required") {
+          body.toolConfig.toolChoice = { any: {} };
+        } else if (typeof request.toolChoice === "object") {
+          body.toolConfig.toolChoice = { tool: { name: request.toolChoice.name } };
+        }
+      }
+    }
+    if (request.extra) {
+      Object.assign(body, request.extra);
+    }
+    return body;
+  }
+  splitSystemMessages(messages) {
+    const system = [];
+    const rest = [];
+    for (const m of messages) {
+      if (m.role === "system") {
+        const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+        if (text) system.push(text);
+      } else {
+        rest.push(m);
+      }
+    }
+    return { system, messages: rest };
+  }
+  toBedrockMessage(m) {
+    if (m.role === "tool" && m.toolCallId) {
+      const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+      return {
+        role: "user",
+        content: [
+          {
+            toolResult: {
+              toolUseId: m.toolCallId,
+              content: [{ text }],
+              status: "success"
+            }
+          }
+        ]
+      };
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      const content2 = [];
+      if (typeof m.content === "string" && m.content) {
+        content2.push({ text: m.content });
+      }
+      for (const tc of m.toolCalls) {
+        content2.push({
+          toolUse: {
+            toolUseId: tc.id,
+            name: tc.name,
+            input: safeJsonParse2(tc.arguments)
+          }
+        });
+      }
+      return { role: "assistant", content: content2 };
+    }
+    const content = [];
+    if (typeof m.content === "string") {
+      content.push({ text: m.content });
+    } else if (Array.isArray(m.content)) {
+      for (const part of m.content) {
+        if (part.type === "text") {
+          content.push({ text: part.text });
+        } else if (part.type === "image") {
+          const src = part.source;
+          if (src.type === "base64") {
+            content.push({
+              image: {
+                format: mediaTypeToFormat(src.mediaType),
+                source: { bytes: src.data }
+              }
+            });
+          }
+        }
+      }
+    }
+    return { role: m.role === "user" ? "user" : "assistant", content };
+  }
+  toBedrockTool(t) {
+    return {
+      toolSpec: {
+        name: t.name,
+        description: t.description,
+        inputSchema: { json: t.parameters }
+      }
+    };
+  }
+  async doFetch(modelId, body) {
+    const host = `bedrock-runtime.${this.region}.amazonaws.com`;
+    const url = `https://${host}/model/${encodeURIComponent(modelId)}/converse`;
+    const bodyStr = JSON.stringify(body);
+    const headers = signRequest({
+      method: "POST",
+      url,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.defaultHeaders
+      },
+      body: bodyStr,
+      region: this.region,
+      service: "bedrock",
+      credentials: this.credentials
+    });
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: bodyStr
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Bedrock API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res.json();
+  }
+  parseResponse(json, modelId) {
+    const output = json.output?.message;
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of output?.content ?? []) {
+      if (block.text) {
+        textParts.push(block.text);
+      } else if (block.toolUse) {
+        toolCalls.push({
+          id: block.toolUse.toolUseId,
+          name: block.toolUse.name,
+          arguments: typeof block.toolUse.input === "string" ? block.toolUse.input : JSON.stringify(block.toolUse.input ?? {})
+        });
+      }
+    }
+    const usage = json.usage ?? {};
+    const tokenUsage = {
+      inputTokens: usage.inputTokens ?? 0,
+      outputTokens: usage.outputTokens ?? 0,
+      totalTokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
+      cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
+      cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
+      cachedOutputTokens: 0,
+      reasoningTokens: 0
+    };
+    return {
+      id: json.requestId ?? json.$metadata?.requestId ?? "",
+      model: modelId,
+      content: textParts.join("") || null,
+      toolCalls,
+      usage: tokenUsage,
+      finishReason: mapBedrockStopReason(json.stopReason),
+      raw: json
+    };
+  }
+};
+function mapBedrockStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    case "content_filtered":
+    case "guardrail":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+function mediaTypeToFormat(mediaType) {
+  const map = {
+    "image/jpeg": "jpeg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/webp": "webp"
+  };
+  return map[mediaType] ?? "png";
+}
+function safeJsonParse2(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return {};
+  }
+}
+
+// src/providers/vertex.ts
+var VertexProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.providerName = "vertex";
+    this.tokenExpiry = 0;
+    this.projectId = config.projectId;
+    this.location = config.location ?? "us-central1";
+    this.defaultModel = config.defaultModel ?? "gemini-2.0-flash";
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    if (config.accessToken) {
+      this.accessToken = config.accessToken;
+      this.tokenExpiry = Date.now() + 36e5;
+    }
+    if (config.serviceAccountJson) {
+      this.serviceAccountJson = typeof config.serviceAccountJson === "string" ? JSON.parse(config.serviceAccountJson) : config.serviceAccountJson;
+    }
+  }
+  async complete(request) {
+    const modelId = request.model || this.defaultModel;
+    const body = this.buildGeminiBody(request);
+    const url = this.buildUrl(modelId, false);
+    const res = await this.doFetch(url, body);
+    const json = await res.json();
+    return this.parseResponse(json, modelId);
+  }
+  async *completeStream(request) {
+    const modelId = request.model || this.defaultModel;
+    const body = this.buildGeminiBody(request);
+    const url = this.buildUrl(modelId, true);
+    const res = await this.doFetch(url, body);
+    if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      for await (const event of parseSSEStream(res.body)) {
+        if (event.data === "[DONE]") break;
+        let chunk;
+        try {
+          chunk = JSON.parse(event.data);
+        } catch {
+          continue;
+        }
+        yield this.parseStreamChunk(chunk, modelId);
+      }
+    } else {
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim().replace(/^,/, "").replace(/^\[/, "").replace(/\]$/, "");
+            if (!trimmed || trimmed === "[" || trimmed === "]") continue;
+            try {
+              const chunk = JSON.parse(trimmed);
+              yield this.parseStreamChunk(chunk, modelId);
+            } catch {
+              buffer = line + "\n" + buffer;
+              break;
+            }
+          }
+        }
+        const remaining = buffer.trim().replace(/^,/, "").replace(/^\[/, "").replace(/\]$/, "");
+        if (remaining && remaining !== "[" && remaining !== "]") {
+          try {
+            const chunk = JSON.parse(remaining);
+            yield this.parseStreamChunk(chunk, modelId);
+          } catch {
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  }
+  // ─── Internals ───────────────────────────────────────────────────────────
+  buildUrl(modelId, stream) {
+    const base = `https://${this.location}-aiplatform.googleapis.com/v1`;
+    const path2 = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/${modelId}`;
+    const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    return `${base}/${path2}:${action}`;
+  }
+  buildGeminiBody(request) {
+    const { system, contents } = this.buildContents(request.messages);
+    const body = { contents };
+    if (system) {
+      body.systemInstruction = { parts: [{ text: system }] };
+    }
+    const generationConfig = {};
+    if (request.maxTokens != null) generationConfig.maxOutputTokens = request.maxTokens;
+    if (request.temperature != null) generationConfig.temperature = request.temperature;
+    if (request.topP != null) generationConfig.topP = request.topP;
+    if (request.stop) generationConfig.stopSequences = request.stop;
+    if (request.responseFormat) {
+      if (request.responseFormat.type === "json_schema" || request.responseFormat.type === "json_object") {
+        generationConfig.responseMimeType = "application/json";
+        if (request.responseFormat.schema) {
+          generationConfig.responseSchema = request.responseFormat.schema;
+        }
+      }
+    }
+    if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+    if (request.tools?.length) {
+      body.tools = [
+        {
+          functionDeclarations: request.tools.map((t) => this.toGeminiTool(t))
+        }
+      ];
+      if (request.toolChoice != null) {
+        const mode = request.toolChoice === "auto" ? "AUTO" : request.toolChoice === "required" ? "ANY" : request.toolChoice === "none" ? "NONE" : "AUTO";
+        body.toolConfig = { functionCallingConfig: { mode } };
+      }
+    }
+    if (request.extra) {
+      Object.assign(body, request.extra);
+    }
+    return body;
+  }
+  buildContents(messages) {
+    const systemParts = [];
+    const contents = [];
+    for (const m of messages) {
+      if (m.role === "system") {
+        const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+        if (text) systemParts.push(text);
+        continue;
+      }
+      contents.push(this.toGeminiContent(m));
+    }
+    return {
+      system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+      contents
+    };
+  }
+  toGeminiContent(m) {
+    if (m.role === "tool" && m.toolCallId) {
+      const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+      let response;
+      try {
+        response = JSON.parse(text);
+      } catch {
+        response = { result: text };
+      }
+      return {
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: m.name ?? m.toolCallId,
+              response
+            }
+          }
+        ]
+      };
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      const parts2 = [];
+      if (typeof m.content === "string" && m.content) {
+        parts2.push({ text: m.content });
+      }
+      for (const tc of m.toolCalls) {
+        parts2.push({
+          functionCall: {
+            name: tc.name,
+            args: safeJsonParse3(tc.arguments)
+          }
+        });
+      }
+      return { role: "model", parts: parts2 };
+    }
+    const role = m.role === "assistant" ? "model" : "user";
+    const parts = [];
+    if (typeof m.content === "string") {
+      parts.push({ text: m.content });
+    } else if (Array.isArray(m.content)) {
+      for (const part of m.content) {
+        if (part.type === "text") {
+          parts.push({ text: part.text });
+        } else if (part.type === "image") {
+          const src = part.source;
+          if (src.type === "base64") {
+            parts.push({
+              inlineData: { mimeType: src.mediaType, data: src.data }
+            });
+          } else {
+            parts.push({
+              fileData: { mimeType: "image/jpeg", fileUri: src.url }
+            });
+          }
+        }
+      }
+    }
+    return { role, parts };
+  }
+  toGeminiTool(t) {
+    return {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    };
+  }
+  async getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return this.accessToken;
+    }
+    if (this.serviceAccountJson) {
+      const token = await this.getTokenFromServiceAccount(this.serviceAccountJson);
+      this.accessToken = token;
+      this.tokenExpiry = Date.now() + 35e5;
+      return token;
+    }
+    try {
+      const { execSync } = await import('child_process');
+      const token = execSync("gcloud auth print-access-token", { encoding: "utf8" }).trim();
+      this.accessToken = token;
+      this.tokenExpiry = Date.now() + 35e5;
+      return token;
+    } catch {
+      throw new ProviderError(
+        "No access token available. Provide accessToken, serviceAccountJson, or ensure gcloud CLI is authenticated.",
+        this.providerName
+      );
+    }
+  }
+  async getTokenFromServiceAccount(sa) {
+    const { createSign } = await import('crypto');
+    const now = Math.floor(Date.now() / 1e3);
+    const header = { alg: "RS256", typ: "JWT" };
+    const claims = {
+      iss: sa.client_email,
+      scope: "https://www.googleapis.com/auth/cloud-platform",
+      aud: "https://oauth2.googleapis.com/token",
+      iat: now,
+      exp: now + 3600
+    };
+    const segments = [
+      base64url(JSON.stringify(header)),
+      base64url(JSON.stringify(claims))
+    ];
+    const signingInput = segments.join(".");
+    const sign = createSign("RSA-SHA256");
+    sign.update(signingInput);
+    const signature = sign.sign(sa.private_key, "base64url");
+    const jwt = `${signingInput}.${signature}`;
+    const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${jwt}`
+    });
+    if (!tokenRes.ok) {
+      const text = await tokenRes.text().catch(() => "");
+      throw new ProviderError(`Failed to get Vertex access token: ${text}`, this.providerName);
+    }
+    const tokenJson = await tokenRes.json();
+    return tokenJson.access_token;
+  }
+  async doFetch(url, body) {
+    const token = await this.getAccessToken();
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        ...this.defaultHeaders
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Vertex AI API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
+  parseResponse(json, modelId) {
+    const candidate = json.candidates?.[0];
+    const parts = candidate?.content?.parts ?? [];
+    const textParts = [];
+    const toolCalls = [];
+    let toolCallIdx = 0;
+    for (const part of parts) {
+      if (part.text) {
+        textParts.push(part.text);
+      } else if (part.functionCall) {
+        toolCalls.push({
+          id: `call_${toolCallIdx++}`,
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args ?? {})
+        });
+      }
+    }
+    const usageMeta = json.usageMetadata ?? {};
+    const tokenUsage = {
+      inputTokens: usageMeta.promptTokenCount ?? 0,
+      outputTokens: usageMeta.candidatesTokenCount ?? 0,
+      totalTokens: usageMeta.totalTokenCount ?? 0,
+      cachedInputTokens: usageMeta.cachedContentTokenCount ?? 0,
+      cachedWriteTokens: 0,
+      cachedOutputTokens: 0,
+      reasoningTokens: usageMeta.thoughtsTokenCount ?? 0
+    };
+    return {
+      id: json.responseId ?? "",
+      model: modelId,
+      content: textParts.join("") || null,
+      toolCalls,
+      usage: tokenUsage,
+      finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      raw: json
+    };
+  }
+  parseStreamChunk(chunk, modelId) {
+    const candidate = chunk.candidates?.[0];
+    const parts = candidate?.content?.parts ?? [];
+    const delta = {};
+    for (const part of parts) {
+      if (part.text) {
+        delta.content = (delta.content ?? "") + part.text;
+      } else if (part.functionCall) {
+        if (!delta.toolCalls) delta.toolCalls = [];
+        delta.toolCalls.push({
+          id: `call_${delta.toolCalls.length}`,
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args ?? {})
+        });
+      }
+    }
+    let usage;
+    if (chunk.usageMetadata) {
+      const u = chunk.usageMetadata;
+      usage = {
+        inputTokens: u.promptTokenCount ?? 0,
+        outputTokens: u.candidatesTokenCount ?? 0,
+        totalTokens: u.totalTokenCount ?? 0,
+        cachedInputTokens: u.cachedContentTokenCount ?? 0,
+        cachedWriteTokens: 0,
+        cachedOutputTokens: 0,
+        reasoningTokens: u.thoughtsTokenCount ?? 0
+      };
+    }
+    return {
+      id: chunk.responseId ?? "",
+      model: modelId,
+      delta,
+      usage,
+      finishReason: mapGeminiFinishReason(candidate?.finishReason)
+    };
+  }
+};
+function mapGeminiFinishReason(reason) {
+  switch (reason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+      return "content_filter";
+    case "TOOL_CALLS":
+      return "tool_calls";
+    default:
+      return "stop";
+  }
+}
+function base64url(str) {
+  return Buffer.from(str).toString("base64url");
+}
+function safeJsonParse3(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return {};
+  }
+}
+function fromNativeProvider(provider, options) {
+  let boundTools = options?.__tools;
+  const modelName = options?.model ?? provider.defaultModel ?? provider.providerName;
+  const adapted = {
+    modelName,
+    capabilities: resolveCapabilities(provider.providerName),
+    invoke: async (messages, _invokeOptions) => {
+      const request = buildRequest(messages, boundTools, options, _invokeOptions);
+      const response = await provider.complete(request);
+      return toBaseChatMessage(response);
+    },
+    stream: async function* (messages, _invokeOptions) {
+      const request = buildRequest(messages, boundTools, options, _invokeOptions);
+      request.stream = true;
+      let fullContent = "";
+      let allToolCalls = [];
+      let lastUsage;
+      const toolCallBuffers = /* @__PURE__ */ new Map();
+      for await (const chunk of provider.completeStream(request)) {
+        if (chunk.delta.content) {
+          fullContent += chunk.delta.content;
+          yield chunk.delta.content;
+        }
+        if (chunk.delta.toolCalls) {
+          for (const tc of chunk.delta.toolCalls) {
+            if (tc.id) {
+              const existing = toolCallBuffers.get(tc.id);
+              if (existing) {
+                if (tc.arguments) existing.arguments += tc.arguments;
+              } else {
+                toolCallBuffers.set(tc.id, {
+                  id: tc.id,
+                  name: tc.name ?? "",
+                  arguments: tc.arguments ?? ""
+                });
+              }
+            }
+          }
+        }
+        if (chunk.usage) lastUsage = chunk.usage;
+      }
+      allToolCalls = [...toolCallBuffers.values()];
+      const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
+      yield finalMessage;
+    },
+    bindTools: (tools, _bindOptions) => {
+      const strict = _bindOptions?.strict ?? false;
+      const toolDefs = tools.map((t) => toToolDefinition(t, strict));
+      return fromNativeProvider(provider, { ...options, __tools: toolDefs });
+    }
+  };
+  return adapted;
+  function buildRequest(messages, tools, opts, invokeOptions) {
+    const req = {
+      model: opts?.model ?? modelName,
+      messages: messages.map(toUnifiedMessage)
+    };
+    if (opts?.temperature != null) req.temperature = opts.temperature;
+    if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
+    if (tools?.length) req.tools = tools;
+    if (opts?.extra) req.extra = opts.extra;
+    const rf = invokeOptions?.response_format;
+    if (rf && typeof rf === "object" && rf.type) {
+      if (rf.type === "json_schema" && rf.json_schema) {
+        req.responseFormat = {
+          type: "json_schema",
+          schema: rf.json_schema.schema,
+          name: rf.json_schema.name
+        };
+      } else if (rf.type === "json_object") {
+        req.responseFormat = { type: "json_object" };
+      } else if (rf.type === "text") {
+        req.responseFormat = { type: "text" };
+      }
+    }
+    if (!req.responseFormat) {
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.__responseFormat) {
+        req.responseFormat = lastMsg.__responseFormat;
+      }
+    }
+    return req;
+  }
+}
+function toUnifiedMessage(msg) {
+  const unified = {
+    role: msg.role,
+    content: convertContent(msg.content)
+  };
+  if (msg.name) unified.name = msg.name;
+  if (msg.tool_call_id) unified.toolCallId = msg.tool_call_id;
+  if (msg.tool_calls?.length) {
+    unified.toolCalls = msg.tool_calls.map((tc) => ({
+      id: tc.id,
+      name: tc.function?.name ?? tc.name ?? "",
+      arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
+    }));
+  }
+  return unified;
+}
+function convertContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return String(content ?? "");
+  return content.map((part) => {
+    if (part.type === "text" || !part.type && part.text) {
+      return { type: "text", text: part.text ?? part.content ?? "" };
+    }
+    if (part.type === "image_url") {
+      const img = part.image_url;
+      if (typeof img === "string" || img?.url?.startsWith("http")) {
+        return {
+          type: "image",
+          source: { type: "url", url: typeof img === "string" ? img : img.url }
+        };
+      }
+      if (img?.url?.startsWith("data:")) {
+        const match = img.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          return {
+            type: "image",
+            source: { type: "base64", mediaType: match[1], data: match[2] }
+          };
+        }
+      }
+    }
+    return { type: "text", text: part.text ?? part.content ?? JSON.stringify(part) };
+  });
+}
+function isZodSchema(obj) {
+  return obj != null && typeof obj === "object" && typeof obj.safeParse === "function" && "_def" in obj;
+}
+function convertToJsonSchema(schema, strict = false) {
+  if (!schema || typeof schema !== "object") {
+    return { type: "object", properties: {}, required: [], additionalProperties: false };
+  }
+  if (isZodSchema(schema)) {
+    const converted = zodToJsonSchema.zodToJsonSchema(schema, {
+      $refStrategy: "none",
+      ...strict ? { openaiStrictMode: true } : {}
+    });
+    delete converted["$schema"];
+    if (!converted.type) converted.type = "object";
+    return converted;
+  }
+  if (!schema.type && schema.properties) {
+    return { type: "object", ...schema };
+  }
+  return schema;
+}
+function normalizeStrictSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const clone2 = { ...schema };
+  if (clone2.type === "object" || clone2.properties) {
+    if (!clone2.type) clone2.type = "object";
+    if (clone2.properties && typeof clone2.properties === "object") {
+      const normalized = {};
+      for (const [k, v] of Object.entries(clone2.properties)) {
+        normalized[k] = normalizeStrictSchema(v);
+      }
+      clone2.properties = normalized;
+      clone2.required = Object.keys(normalized);
+    } else {
+      clone2.properties = {};
+      clone2.required = [];
+    }
+    clone2.additionalProperties = false;
+  }
+  if (clone2.items) clone2.items = normalizeStrictSchema(clone2.items);
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    if (Array.isArray(clone2[key])) {
+      clone2[key] = clone2[key].map((s) => normalizeStrictSchema(s));
+    }
+  }
+  if (clone2.definitions && typeof clone2.definitions === "object") {
+    const nd = {};
+    for (const [k, v] of Object.entries(clone2.definitions)) {
+      nd[k] = normalizeStrictSchema(v);
+    }
+    clone2.definitions = nd;
+  }
+  if (clone2.$defs && typeof clone2.$defs === "object") {
+    const nd = {};
+    for (const [k, v] of Object.entries(clone2.$defs)) {
+      nd[k] = normalizeStrictSchema(v);
+    }
+    clone2.$defs = nd;
+  }
+  return clone2;
+}
+function toToolDefinition(tool, strict) {
+  let name;
+  let description;
+  let parameters;
+  if (tool.type === "function" && tool.function) {
+    name = tool.function.name;
+    description = tool.function.description ?? "";
+    parameters = tool.function.parameters ?? { type: "object", properties: {}, additionalProperties: false };
+  } else {
+    name = tool.name ?? "unknown";
+    description = tool.description ?? "";
+    const rawSchema = tool.schema ?? tool.parameters;
+    parameters = convertToJsonSchema(rawSchema, strict);
+  }
+  if (strict) {
+    parameters = normalizeStrictSchema(parameters);
+  }
+  return { name, description, parameters, ...strict ? { strict: true } : {} };
+}
+function toBaseChatMessage(response) {
+  const msg = {
+    role: "assistant",
+    content: response.content ?? "",
+    usage: {
+      prompt_tokens: response.usage.inputTokens,
+      completion_tokens: response.usage.outputTokens,
+      total_tokens: response.usage.totalTokens,
+      prompt_tokens_details: {
+        cached_tokens: response.usage.cachedInputTokens
+      },
+      completion_tokens_details: {
+        reasoning_tokens: response.usage.reasoningTokens
+      }
+    },
+    response_metadata: {
+      token_usage: {
+        prompt_tokens: response.usage.inputTokens,
+        completion_tokens: response.usage.outputTokens,
+        total_tokens: response.usage.totalTokens,
+        cached_tokens: response.usage.cachedInputTokens,
+        cache_write_tokens: response.usage.cachedWriteTokens
+      },
+      finish_reason: response.finishReason,
+      model_name: response.model
+    }
+  };
+  if (response.toolCalls.length > 0) {
+    msg.tool_calls = response.toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: { name: tc.name, arguments: tc.arguments }
+    }));
+  }
+  return msg;
+}
+function assembleMessage(content, toolCalls, usage) {
+  const msg = {
+    role: "assistant",
+    content
+  };
+  if (usage) {
+    msg.usage = {
+      prompt_tokens: usage.inputTokens,
+      completion_tokens: usage.outputTokens,
+      total_tokens: usage.totalTokens,
+      prompt_tokens_details: {
+        cached_tokens: usage.cachedInputTokens
+      },
+      completion_tokens_details: {
+        reasoning_tokens: usage.reasoningTokens
+      }
+    };
+    msg.response_metadata = {
+      token_usage: {
+        prompt_tokens: usage.inputTokens,
+        completion_tokens: usage.outputTokens,
+        total_tokens: usage.totalTokens,
+        cached_tokens: usage.cachedInputTokens,
+        cache_write_tokens: usage.cachedWriteTokens
+      }
+    };
+  }
+  if (toolCalls.length > 0) {
+    msg.tool_calls = toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: { name: tc.name, arguments: tc.arguments }
+    }));
+  }
+  return msg;
+}
+function resolveCapabilities(provider) {
+  switch (provider) {
+    case "openai":
+    case "azure":
+    case "openai-compatible":
+      return {
+        structuredOutput: "native",
+        strictToolCalling: true,
+        streaming: true,
+        provider
+      };
+    case "anthropic":
+      return {
+        structuredOutput: "tool_based",
+        strictToolCalling: false,
+        streaming: true,
+        provider: "anthropic"
+      };
+    case "bedrock":
+      return {
+        structuredOutput: "tool_based",
+        strictToolCalling: false,
+        streaming: false,
+        // streaming uses binary protocol
+        provider: "bedrock"
+      };
+    case "vertex":
+      return {
+        structuredOutput: "native",
+        strictToolCalling: false,
+        streaming: true,
+        provider: "google"
+      };
+    default:
+      return { provider };
+  }
+}
+
+// src/providers/index.ts
+function createProvider(config) {
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIProvider(config);
+    case "anthropic":
+      return new AnthropicProvider(config);
+    case "azure":
+      return new AzureProvider(config);
+    case "openai-compatible":
+      return new OpenAICompatibleProvider(config);
+    case "bedrock":
+      return new BedrockProvider(config);
+    case "vertex":
+      return new VertexProvider(config);
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}
+
+exports.AnthropicProvider = AnthropicProvider;
+exports.AzureProvider = AzureProvider;
+exports.BaseProvider = BaseProvider;
+exports.BedrockProvider = BedrockProvider;
 exports.DEFAULT_PROFILE_CONFIGS = DEFAULT_PROFILE_CONFIGS;
 exports.GuardrailPhase = GuardrailPhase;
 exports.InMemoryMemoryStore = InMemoryMemoryStore;
+exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
+exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
+exports.OpenAIProvider = OpenAIProvider;
+exports.ProviderError = ProviderError;
+exports.StructuredOutputManager = StructuredOutputManager;
+exports.ToolBasedStrategy = ToolBasedStrategy;
+exports.VertexProvider = VertexProvider;
 exports.agentVerdictRule = agentVerdictRule;
 exports.applyTokenLimits = applyTokenLimits;
 exports.buildSystemPrompt = buildSystemPrompt;
@@ -5163,6 +7523,7 @@ exports.createContextSummarizeNode = createContextSummarizeNode;
 exports.createContextTools = createContextTools;
 exports.createGuardrail = createGuardrail;
 exports.createJsonGuardrail = createJsonGuardrail;
+exports.createProvider = createProvider;
 exports.createRegexGuardrail = createRegexGuardrail;
 exports.createResolverNode = createResolverNode;
 exports.createSmartAgent = createSmartAgent;
@@ -5171,12 +7532,17 @@ exports.createToolLimitFinalizeNode = createToolLimitFinalizeNode;
 exports.createToolsNode = createToolsNode;
 exports.customCallbackRule = customCallbackRule;
 exports.customSink = customSink;
+exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
 exports.fileSink = fileSink;
+exports.formatZodError = formatZodError;
 exports.fromLangchainModel = fromLangchainModel;
 exports.fromLangchainTools = fromLangchainTools;
+exports.fromNativeProvider = fromNativeProvider;
 exports.generateSpanId = generateSpanId;
 exports.generateTraceId = generateTraceId;
+exports.getModelCapabilities = getModelCapabilities;
+exports.getNestedValue = getNestedValue;
 exports.getResolvedSmartConfig = getResolvedSmartConfig;
 exports.httpSink = httpSink;
 exports.isSmartModel = isSmartModel;
@@ -5187,6 +7553,7 @@ exports.readMemoryFacts = readMemoryFacts;
 exports.regexRule = regexRule;
 exports.renderMemoryFacts = renderMemoryFacts;
 exports.resolveMemoryStore = resolveMemoryStore;
+exports.resolveStrategy = resolveStrategy;
 exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.restoreSnapshot = restoreSnapshot;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;