@cognipeer/agent-sdk 0.6.0 → 0.6.2

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm](https://img.shields.io/npm/v/@cognipeer/agent-sdk?color=success)](https://npmjs.com/package/@cognipeer/agent-sdk) [Docs Website](https://cognipeer.github.io/agent-sdk/) 
 
-Lightweight, message-first agent runtime that keeps tool calls transparent, automatically summarizes long histories, and ships with planning, multi-agent handoffs, and structured tracing.
+Lightweight, message-first agent runtime that keeps tool calls transparent, supports provider-native reasoning plus post-tool reflection, automatically summarizes long histories, and ships with planning, multi-agent handoffs, and structured tracing.
 
 - SDK source: `src/`
 - Examples: `examples/`
@@ -15,6 +15,7 @@ Lightweight, message-first agent runtime that keeps tool calls transparent, auto
 - [Install](#install)
 - [Quick start](#quick-start)
   - [Smart agent (planning + summarization)](#smart-agent-planning--summarization)
+  - [Reasoning & reflection](#reasoning--reflection)
   - [Base agent (minimal loop)](#base-agent-minimal-loop)
 - [Key capabilities](#key-capabilities)
 - [Examples](#examples)
@@ -33,9 +34,10 @@ Highlights:
 - **Message-first design** – assistant tool calls and tool responses stay in the transcript.
 - **Token-aware summarization** – chunked rewriting archives oversized tool outputs while exposing `get_tool_response` for lossless retrieval.
 - **Planning mode** – adaptive system prompt + TODO tool supports full plan writes and version-safe partial updates.
+- **Unified reasoning surface** – one `reasoning` config controls provider-native reasoning and post-tool plain-text reflections.
 - **Structured output** – provide a Zod schema and the agent injects a finalize tool to capture JSON deterministically.
 - **Multi-agent and handoffs** – wrap agents as tools or transfer control mid-run with `asTool` / `asHandoff`.
-- **Usage + events** – normalize provider usage, surface `tool_call`, `plan`, `summarization`, `metadata`, and `handoff` events.
+- **Usage + events** – normalize provider usage, surface `tool_call`, `plan`, `summarization`, `reflection`, `metadata`, and `handoff` events.
 - **Structured tracing** – optional per-invoke JSON traces with metadata, payload capture, and pluggable sinks (file, HTTP, Cognipeer, custom).
 
 ## What’s inside
@@ -181,6 +183,52 @@ const agent = createSmartAgent({
 });
 ```
 
+### Reasoning & reflection
+
+Both `createAgent(...)` and `createSmartAgent(...)` accept a unified `reasoning` config:
+
+```ts
+const agent = createSmartAgent({
+  model: fromNativeProvider(
+    createProvider({ provider: "openai", apiKey: process.env.OPENAI_API_KEY! }),
+    { model: "gpt-5" },
+  ),
+  tools: [echo],
+  reasoning: {
+    enabled: true,
+    level: "high",
+    native: { effort: "high" },
+    reflection: {
+      cadence: "after_tool",
+      mode: "piggyback",
+      maxTokens: 450,
+      keepLast: 4,
+      summarize: false,
+    },
+  },
+});
+
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "Research the repo and propose the next implementation step." }],
+}, {
+  onEvent(event) {
+    if (event.type === "reflection") {
+      console.log("reflection:", event.text);
+    }
+  },
+});
+
+console.log(result.state?.reflections?.at(-1)?.text);
+```
+
+What this does:
+
+- `reasoning.native` passes provider-specific reasoning knobs through the native provider layer.
+- `reasoning.reflection` adds a short plain-text reflection after qualifying turns without committing that note as a normal assistant message.
+- Reflection notes are persisted on `result.state.reflections`; only the last `keepLast` are re-injected into the next prompt as synthetic system context.
+
+Use this only with models/endpoints that actually support provider-native reasoning. Unsupported models usually return a provider error rather than silently degrading.
+
 ### Base agent (minimal loop)
 
 Prefer a tiny core without system prompt or summarization? Use `createAgent`:
@@ -213,6 +261,7 @@ console.log(res.content);
 
 - **Native provider layer** – call OpenAI, Anthropic, Azure, Bedrock, Vertex, and any OpenAI-compatible API directly. No LangChain required. Unified `ChatCompletionRequest` / `ChatCompletionResponse` schema with per-provider wire format conversion.
 - **Full token tracking** – every response surfaces `inputTokens`, `outputTokens`, `cachedInputTokens`, `cachedWriteTokens`, and `reasoningTokens` for all six providers.
+- **Unified reasoning controls** – enable provider-native reasoning (`reasoning.native`) and post-tool reflection (`reasoning.reflection`) from one config surface.
 - **Summarization pipeline** – automatic chunking keeps tool call history within `contextTokenLimit` / `summaryTokenLimit`, archiving originals so `get_tool_response` can fetch them later.
 - **Retention controls** – tool outputs can be kept full, reduced to structured previews, archived, or dropped based on size tiers, critical-tool fallback, per-tool overrides, and recent-response pinning.
 - **Planning discipline** – when planning is enabled the system prompt distinguishes full plan writes from incremental plan updates and emits `plan` events as todos change.
@@ -220,7 +269,7 @@ console.log(res.content);
 - **Multi-agent orchestration** – reuse agents via `agent.asTool({ toolName })` or perform handoffs that swap runtimes mid-execution.
 - **MCP + LangChain tools** – any object satisfying the minimal tool interface works; LangChain’s `Tool` implementations plug in directly.
 - **Vision input** – message parts accept base64 or URL images for multimodal requests.
-- **Observability hooks** – `config.onEvent` surfaces tool lifecycle, summarization, metadata, and final answer events for streaming UIs or CLIs.
+- **Observability hooks** – `config.onEvent` surfaces tool lifecycle, summarization, reflection, metadata, and final answer events for streaming UIs or CLIs.
 
 ## Examples
 
@@ -269,10 +318,11 @@ OPENAI_API_KEY=... npx tsx basic/basic.ts
 The agent is a deterministic while-loop – no external graph runtime. Each turn flows through:
 
 1. **resolver** – normalize state (messages, counters, limits).
-2. **contextSummarize** (optional) – when token estimates exceed `limits.maxToken`, archive heavy tool outputs.
+2. **contextSummarize** (optional) – when token estimates exceed the active summarization threshold, archive heavy tool outputs.
 3. **agent** – invoke the model (binding tools when supported).
 4. **tools** – execute proposed tool calls with configurable parallelism.
-5. **toolLimitFinalize** – if tool-call cap is hit, inject a system notice so the next assistant turn must answer directly.
+5. **reflect** (optional) – append a plain-text reflection after tool turns when `reasoning.reflection` is enabled.
+6. **toolLimitFinalize** – if tool-call cap is hit, inject a system notice so the next assistant turn must answer directly.
 
 The loop stops when the assistant produces a message without tool calls, a structured output finalize signal is observed, or a handoff transfers control. See `docs/architecture/README.md` for diagrams and heuristics.
 
@@ -289,7 +339,7 @@ Exported helpers (`agent-sdk/src/index.ts`):
 - `createProvider(config)` – factory for all six providers
 - `fromNativeProvider(provider, options?)` – wraps a provider as a `BaseChatModel`
 - `OpenAIProvider`, `AnthropicProvider`, `AzureProvider`, `OpenAICompatibleProvider`, `BedrockProvider`, `VertexProvider`
-- Types: `ChatCompletionRequest`, `ChatCompletionResponse`, `TokenUsage`, `ProviderConfig`
+- Types: `ChatCompletionRequest`, `ChatCompletionResponse`, `TokenUsage`, `ProviderConfig`, `ReasoningConfig`, `ReflectionRecord`, `ReflectionEvent`
 
 **LangChain adapters (optional):**
 - `fromLangchainModel(model)`
@@ -300,7 +350,7 @@ Exported helpers (`agent-sdk/src/index.ts`):
 - `buildSystemPrompt(extra?, planning?, name?)`
 - Node factories (`nodes/*`), context helpers, token utilities, and full TypeScript types (`SmartAgentOptions`, `SmartState`, `AgentInvokeResult`, etc.).
 
-`SmartAgentOptions` accepts the usual suspects (`model`, `tools`, `limits`, `runtimeProfile`, `customProfile`, `useTodoList`, `summarization`, `usageConverter`, `tracing`). See `docs/api/` for detailed type references.
+`SmartAgentOptions` accepts the usual suspects (`model`, `tools`, `limits`, `runtimeProfile`, `customProfile`, `useTodoList`, `summarization`, `reasoning`, `usageConverter`, `tracing`). See `docs/api/` for detailed type references.
 
 Tools can also declare `maxExecutionsPerRun` to cap successful executions for that tool within a single agent run. Leave it unset or set it to `null` for unlimited usage. This is separate from global limits such as `limits.maxToolCalls` and `limits.maxParallelTools`.
 
@@ -309,7 +359,7 @@ Tools can also declare `maxExecutionsPerRun` to cap successful executions for th
 Enable tracing by passing `tracing: { enabled: true }`. Each invocation writes `trace.session.json` into `logs/<SESSION_ID>/` detailing:
 
 - Model/provider, agent name/version, limits, and timing metadata
-- Structured events for model calls, tool executions, summaries, and errors
+- Structured events for model calls, tool executions, summaries, reflections, and errors
 - Optional payload captures (request/response/tool bodies) when `logData` is `true`
 - Aggregated token usage, byte counts, and error summaries for dashboards
 

package/dist/index.cjs

@@ -1978,7 +1978,9 @@ function createAgentCoreNode(opts) {
     const cancellationToken = state.ctx?.__cancellationToken;
     const abortSignal = state.ctx?.__abortSignal;
     const responseFormat = runtime.responseFormat;
-    const extractText = (chunk) => {
+    const reasoningForCall = state.ctx?.__reasoning;
+    const reasoningInvokeOpts = reasoningForCall ? { reasoning: reasoningForCall } : void 0;
+    const extractText2 = (chunk) => {
       if (chunk == null) return "";
       if (typeof chunk === "string") return chunk;
       if (typeof chunk?.content === "string") return chunk.content;
@@ -1996,7 +1998,7 @@ function createAgentCoreNode(opts) {
       if (streamingEnabled && typeof modelWithTools.stream === "function") {
         let streamedText = "";
         let streamedMessage;
-        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat };
+        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts };
         for await (const chunk of modelWithTools.stream(normalizedMessages, streamOptions)) {
           if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
             break;
@@ -2004,7 +2006,7 @@ function createAgentCoreNode(opts) {
           if (chunk && typeof chunk === "object" && chunk.role) {
             streamedMessage = chunk;
           }
-          const text = extractText(chunk);
+          const text = extractText2(chunk);
           if (text) {
             streamedText += text;
             onStream?.({ text });
@@ -2020,7 +2022,7 @@ function createAgentCoreNode(opts) {
           response = { role: "assistant", content: streamedText };
         }
       } else {
-        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat });
+        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts });
       }
     } catch (err) {
       const durationMs2 = Date.now() - start;
@@ -2107,8 +2109,6 @@ var BASE_DEFAULTS = {
     policy: "hybrid",
     lastTurnsToKeep: 8,
     toolResponsePolicy: "summarize_archive",
-    archiveLargeToolResponses: true,
-    retrieveArchivedToolResponseOnDemand: true,
     budget: {
       systemReserveTokens: 1200,
       goalsReserveTokens: 1200,
@@ -2141,8 +2141,7 @@ var BASE_DEFAULTS = {
     defaultPolicy: "summarize_archive",
     toolResponseRetentionByTool: {},
     criticalTools: [...DEFAULT_CRITICAL_TOOLS],
-    schemaValidation: "strict",
-    retryOnSchemaError: true
+    schemaValidation: "strict"
   }
 };
 function buildProfile(overrides) {
@@ -2939,6 +2938,246 @@ function createToolLimitFinalizeNode(_opts) {
     return { messages: [...state.messages, notice], ctx };
   };
 }
+var REFLECTION_SYSTEM_NAME = "agent_reflection";
+var REFLECTION_ASK_NAME = "agent_reflection_ask";
+var DEFAULT_REFLECT_PROMPT = `Reflect briefly \u2014 plain text, no JSON, no tool calls.
+Structure your note (1\u20132 sentences each):
+1) What the latest tool results actually tell us (facts, surprises).
+2) What is still missing or uncertain before we can finish the user's task.
+3) The single next step you plan to take, and why that step over alternatives.
+Be concrete. Do not repeat the task description. Do not apologize. Max ${"${maxChars}"} characters total.`;
+function trimToChars(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars - 1).trimEnd() + "\u2026";
+}
+function countToolCallsInLastTurn(state) {
+  const ids = [];
+  const names = [];
+  for (let i = state.messages.length - 1; i >= 0; i--) {
+    const m = state.messages[i];
+    if (m?.role === "tool") {
+      if (m.tool_call_id) ids.push(m.tool_call_id);
+      if (m.name) names.push(m.name);
+    } else if (m?.role === "assistant") {
+      break;
+    }
+  }
+  return { ids, names };
+}
+function stripReflectionAskMessages(messages) {
+  return messages.filter((m) => !(m?.role === "user" && m?.name === REFLECTION_ASK_NAME));
+}
+function shouldRunReflection(cadence, state, ranToolsThisTurn) {
+  if (cadence === "off") return false;
+  if (cadence === "every_turn") return true;
+  if (cadence === "after_tool") return ranToolsThisTurn;
+  if (cadence === "on_branch") {
+    const reflections = state.reflections || [];
+    const lastReflectionTurn = reflections[reflections.length - 1]?.turn ?? -1;
+    const currentTurnId = state.toolCallCount ?? 0;
+    return currentTurnId - lastReflectionTurn >= 2;
+  }
+  return false;
+}
+function createReflectionNode(opts, resolved) {
+  return async function reflectNode(state, trigger) {
+    if (!resolved.enabled) return {};
+    const runtime = state.agent || {
+      model: opts.model,
+      name: opts.name,
+      version: opts.version
+    };
+    const model = runtime.model;
+    if (!model?.invoke && !model?.stream) return {};
+    const onEvent = state.ctx?.__onEvent;
+    const traceSession = state.ctx?.__traceSession;
+    const maxChars = resolved.maxChars;
+    const promptBody = (resolved.promptTemplate || DEFAULT_REFLECT_PROMPT).replace(/\$\{maxChars\}/g, String(maxChars));
+    const baseMessages = stripReflectionAskMessages([...state.messages]);
+    const askMessage = {
+      role: "user",
+      name: REFLECTION_ASK_NAME,
+      content: promptBody
+    };
+    const messagesForCall = resolved.mode === "piggyback" ? [...baseMessages, askMessage] : buildSeparateCallMessages(baseMessages, promptBody);
+    const start = Date.now();
+    let response;
+    try {
+      response = await model.invoke(messagesForCall, {
+        // tool_choice:"none" so the model won't try to call tools during reflection
+        tool_choice: "none",
+        toolChoice: "none",
+        // Override max_tokens for the reflection call. BaseChatModel passes this through
+        // to the adapter which forwards into the provider body.
+        max_tokens: resolved.maxTokens,
+        maxTokens: resolved.maxTokens
+      });
+    } catch (err) {
+      recordTraceEvent(traceSession, {
+        type: "reflection",
+        label: "Reflection error",
+        actor: { scope: "agent", name: opts.name || "agent", role: "reflection" },
+        status: "error",
+        error: { message: err?.message || String(err) }
+      });
+      return {};
+    }
+    const durationMs = Date.now() - start;
+    const rawText = extractText(response);
+    const text = trimToChars(String(rawText ?? "").trim(), maxChars);
+    if (!text) return {};
+    const rawUsage = response?.usage_metadata || response?.response_metadata?.usage || response?.usage || response?.additional_kwargs?.usage;
+    const usage = normalizeUsage(rawUsage);
+    const { ids, names } = countToolCallsInLastTurn(state);
+    const turn = state.toolCallCount ?? 0;
+    const record = {
+      id: safeRandomId(),
+      turn,
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs,
+      anchorMessageIndex: state.messages.length,
+      trigger,
+      usage: usage ? {
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        cachedInputTokens: usage.prompt_tokens_details?.cached_tokens,
+        totalTokens: usage.total_tokens,
+        reasoningTokens: usage.completion_tokens_details?.reasoning_tokens
+      } : void 0,
+      toolCallIds: ids.length > 0 ? ids : void 0
+    };
+    recordTraceEvent(traceSession, {
+      type: "reflection",
+      label: `Reflection turn ${turn}`,
+      actor: { scope: "agent", name: opts.name || "agent", role: "reflection" },
+      status: "success",
+      durationMs,
+      inputTokens: record.usage?.inputTokens,
+      outputTokens: record.usage?.outputTokens,
+      cachedInputTokens: record.usage?.cachedInputTokens,
+      totalTokens: record.usage?.totalTokens,
+      debug: { text, toolNames: names }
+    });
+    if (resolved.emitEvents) {
+      try {
+        onEvent?.({
+          type: "reflection",
+          id: record.id,
+          turn,
+          text,
+          trigger,
+          durationMs,
+          usage: record.usage,
+          toolCallIds: record.toolCallIds
+        });
+      } catch (e) {
+      }
+    }
+    const nextMessages = stripReflectionAskMessages([...state.messages]);
+    const reflections = [...state.reflections || [], record];
+    const kept = reflections.slice(-Math.max(1, resolved.keepLast));
+    const prunedMessages = nextMessages.filter(
+      (m) => !(m?.role === "system" && m?.name === REFLECTION_SYSTEM_NAME)
+    );
+    for (const r of kept) {
+      prunedMessages.push({
+        role: "system",
+        name: REFLECTION_SYSTEM_NAME,
+        content: `<agent_reflection turn=${r.turn} at=${r.createdAt}>
+${r.text}
+</agent_reflection>`,
+        metadata: { reflectionId: r.id, reflectionTurn: r.turn, reflectionTrigger: r.trigger }
+      });
+    }
+    return { messages: prunedMessages, reflections };
+  };
+}
+function extractText(chunk) {
+  if (chunk == null) return "";
+  if (typeof chunk === "string") return chunk;
+  if (typeof chunk?.content === "string") return chunk.content;
+  if (Array.isArray(chunk?.content)) {
+    return chunk.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("");
+  }
+  if (typeof chunk?.text === "string") return chunk.text;
+  return "";
+}
+function buildSeparateCallMessages(base, promptBody) {
+  const systemMessages = base.filter((m) => m?.role === "system");
+  const tail = base.slice(-8);
+  return [
+    ...systemMessages,
+    ...tail,
+    { role: "user", name: REFLECTION_ASK_NAME, content: promptBody }
+  ];
+}
+function safeRandomId() {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    return `r_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
+  }
+}
+
+// src/smart/reasoning.ts
+var LEVEL_DEFAULTS = {
+  low: {
+    native: { effort: "low" },
+    reflection: { maxTokens: 200, maxChars: 600, cadence: "on_branch" }
+  },
+  medium: {
+    native: { effort: "medium" },
+    reflection: { maxTokens: 350, maxChars: 1200, cadence: "after_tool" }
+  },
+  high: {
+    native: { effort: "high" },
+    reflection: { maxTokens: 600, maxChars: 2e3, cadence: "after_tool" }
+  }
+};
+function resolveReasoning(input) {
+  if (!input || input.enabled === false) return void 0;
+  const enabled = input.enabled ?? (input.native !== void 0 || input.reflection !== void 0 || input.level !== void 0);
+  if (!enabled) return void 0;
+  const level = input.level ?? "medium";
+  const presets = LEVEL_DEFAULTS[level];
+  let native;
+  if (input.native === false) {
+    native = void 0;
+  } else {
+    native = { ...presets.native, ...input.native ?? {} };
+  }
+  const reflection = resolveReflection(input.reflection, presets.reflection);
+  return { enabled: true, level, native, reflection };
+}
+function resolveReflection(input, preset) {
+  if (input === false) {
+    return {
+      enabled: false,
+      cadence: "off",
+      mode: "piggyback",
+      maxTokens: preset.maxTokens,
+      maxChars: preset.maxChars,
+      keepLast: 3,
+      summarize: false,
+      emitEvents: true
+    };
+  }
+  const cfg = input ?? {};
+  const enabled = cfg.enabled ?? true;
+  const cadence = cfg.cadence ?? preset.cadence;
+  return {
+    enabled: enabled && cadence !== "off",
+    cadence: enabled ? cadence : "off",
+    mode: cfg.mode ?? "piggyback",
+    maxTokens: cfg.maxTokens ?? preset.maxTokens,
+    maxChars: cfg.maxChars ?? preset.maxChars,
+    keepLast: cfg.keepLast ?? 3,
+    summarize: cfg.summarize ?? false,
+    promptTemplate: cfg.promptTemplate,
+    emitEvents: cfg.emitEvents ?? true
+  };
+}
 function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -3352,6 +3591,8 @@ function createAgent(opts) {
   }
   const toolsNode = createToolsNode(toolsBase, opts);
   const finalizeNode = createToolLimitFinalizeNode();
+  const resolvedReasoning = resolveReasoning(opts.reasoning);
+  const reflectNode = resolvedReasoning?.reflection.enabled ? createReflectionNode(opts, resolvedReasoning.reflection) : void 0;
   const mergeGuardrailOutcomes = (prev, next) => {
     if (!prev) return next;
     return {
@@ -3406,6 +3647,13 @@ function createAgent(opts) {
     if (summarizationThreshold === void 0) {
       state = clearNeedsSummarization(state);
     }
+    if (resolvedReasoning?.native) {
+      const ctx = { ...state.ctx || {} };
+      if (!ctx.__reasoning) {
+        ctx.__reasoning = resolvedReasoning.native;
+        state = { ...state, ctx };
+      }
+    }
     const mergedLimits = {
       ...opts.limits || {},
       ...config?.limits || {}
@@ -3634,6 +3882,18 @@ function createAgent(opts) {
       if (state.ctx?.__awaitingApproval) break;
       if (checkpointIfRequested("after_tools")) break;
       if (state.ctx?.__finalizedDueToStructuredOutput) break;
+      if (reflectNode && resolvedReasoning?.reflection.enabled) {
+        const cadence = resolvedReasoning.reflection.cadence;
+        if (shouldRunReflection(cadence, state, true)) {
+          try {
+            const patch = await reflectNode(state, cadence);
+            if (patch && Object.keys(patch).length > 0) {
+              state = { ...state, ...patch };
+            }
+          } catch {
+          }
+        }
+      }
     }
     if (soManager && !state.ctx?.__finalizedDueToStructuredOutput) {
       const lastForParse = state.messages[state.messages.length - 1];
@@ -5643,6 +5903,52 @@ function parseSSEBlock(block) {
   return { event, data: dataLines.join("\n"), id, retry };
 }
 
+// src/providers/utils/reasoning.ts
+function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
+  if (!reasoning) return;
+  const effort = normalizeEffort(reasoning.effort);
+  if (mode === "responses") {
+    const obj = {};
+    if (effort) obj.effort = effort;
+    if (reasoning.includeThoughts) obj.summary = "auto";
+    if (reasoning.providerExtras) Object.assign(obj, reasoning.providerExtras);
+    if (Object.keys(obj).length > 0) body.reasoning = obj;
+  } else {
+    if (effort) body.reasoning_effort = effort;
+    if (reasoning.providerExtras) Object.assign(body, reasoning.providerExtras);
+  }
+}
+function applyAnthropicReasoning(body, reasoning) {
+  if (!reasoning) return;
+  const budget = resolveBudget(reasoning, { low: 2048, medium: 8192, high: 16384, minimal: 1024 });
+  if (!budget) return;
+  const thinking = { type: "enabled", budget_tokens: budget };
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  body.thinking = thinking;
+}
+function applyGeminiReasoning(generationConfig, reasoning) {
+  if (!reasoning) return;
+  const budget = resolveBudget(reasoning, { low: 1024, medium: 4096, high: 12e3, minimal: 512 });
+  if (budget == null) return;
+  const thinkingConfig = { thinkingBudget: budget };
+  if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
+  if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
+  generationConfig.thinkingConfig = thinkingConfig;
+}
+function normalizeEffort(effort) {
+  if (!effort) return void 0;
+  const allowed = ["minimal", "low", "medium", "high"];
+  return allowed.includes(effort) ? effort : void 0;
+}
+function resolveBudget(reasoning, effortBudget) {
+  if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    return Math.floor(reasoning.budgetTokens);
+  }
+  const effort = normalizeEffort(reasoning.effort);
+  if (effort && effortBudget[effort]) return effortBudget[effort];
+  return void 0;
+}
+
 // src/providers/openai.ts
 var OpenAIProvider = class extends BaseProvider {
   constructor(config) {
@@ -5758,6 +6064,7 @@ var OpenAIProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyOpenAIReasoning(body, request.reasoning, "legacy_effort");
     return body;
   }
   toOpenAIMessage(m) {
@@ -6016,6 +6323,7 @@ var AnthropicProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyAnthropicReasoning(body, request.reasoning);
     return body;
   }
   splitSystemMessages(messages) {
@@ -6670,6 +6978,7 @@ var VertexProvider = class extends BaseProvider {
         }
       }
     }
+    applyGeminiReasoning(generationConfig, request.reasoning);
     if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
     if (request.tools?.length) {
       body.tools = [
@@ -7008,6 +7317,13 @@ function fromNativeProvider(provider, options) {
     if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
+    const reasoningOverride = invokeOptions?.reasoning;
+    const reasoningCfg = reasoningOverride ?? opts?.reasoning;
+    if (reasoningCfg) req.reasoning = reasoningCfg;
+    const tc = invokeOptions?.tool_choice ?? invokeOptions?.toolChoice;
+    if (tc) {
+      req.toolChoice = tc;
+    }
     const rf = invokeOptions?.response_format;
     if (rf && typeof rf === "object" && rf.type) {
       if (rf.type === "json_schema" && rf.json_schema) {