@dexto/core 1.6.1 → 1.6.2

package/dist/llm/executor/provider-options.d.ts

@@ -1,49 +1,15 @@
 /**
  * Provider-specific options builder for Vercel AI SDK's streamText/generateText.
- *
- * Centralizes provider-specific configuration that requires explicit opt-in:
- * - Anthropic: cacheControl for prompt caching, sendReasoning for extended thinking
- * - Bedrock/Vertex Claude: Same as Anthropic (Claude models on these platforms)
- * - Google: thinkingConfig for Gemini thinking models
- * - OpenAI: reasoningEffort for o1/o3/codex/gpt-5 models
- *
- * Caching notes:
- * - Anthropic: Requires explicit cacheControl option (we enable it)
- * - OpenAI: Automatic for prompts ≥1024 tokens (no config needed)
- * - Google: Implicit caching automatic for Gemini 2.5+ (≥1024 tokens for Flash,
- *   ≥2048 for Pro). Explicit caching requires pre-created cachedContent IDs.
- * All providers return cached token counts in the response (cachedInputTokens).
  */
-import type { LLMProvider } from '../types.js';
-export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+import type { LLMProvider, LLMReasoningConfig } from '../types.js';
 export interface ProviderOptionsConfig {
     provider: LLMProvider;
     model: string;
-    reasoningEffort?: ReasoningEffort | undefined;
+    reasoning?: LLMReasoningConfig | undefined;
 }
+export declare function getEffectiveReasoningBudgetTokens(providerOptions: Record<string, Record<string, unknown>> | undefined): number | undefined;
 /**
  * Build provider-specific options for streamText/generateText.
- *
- * @param config Provider, model, and optional reasoning effort configuration
- * @returns Provider options object or undefined if no special options needed
  */
 export declare function buildProviderOptions(config: ProviderOptionsConfig): Record<string, Record<string, unknown>> | undefined;
-/**
- * Determine the default reasoning effort for OpenAI models.
- *
- * OpenAI reasoning effort levels (from lowest to highest):
- * - 'none': No reasoning, fastest responses
- * - 'low': Minimal reasoning, fast responses
- * - 'medium': Balanced reasoning (OpenAI's recommended daily driver)
- * - 'high': Thorough reasoning for complex tasks
- * - 'xhigh': Extra high reasoning for quality-critical, non-latency-sensitive tasks
- *
- * Default strategy:
- * - Reasoning-capable models (codex, o1, o3, gpt-5): 'medium' - OpenAI's recommended default
- * - Other models: undefined (no reasoning effort needed)
- *
- * @param model The model name
- * @returns Reasoning effort level or undefined if not applicable
- */
-export declare function getDefaultReasoningEffort(model: string): Exclude<ReasoningEffort, 'none'> | undefined;
 //# sourceMappingURL=provider-options.d.ts.map

package/dist/llm/executor/provider-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider-options.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/provider-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AAEvF,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;CACjD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,qBAAqB,GAC9B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAgErD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACrC,KAAK,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,SAAS,CAS9C"}
+{"version":3,"file":"provider-options.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/provider-options.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAcnE,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;CAC9C;AA4LD,wBAAgB,iCAAiC,CAC7C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GACrE,MAAM,GAAG,SAAS,CA4BpB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,qBAAqB,GAC9B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CA2IrD"}

package/dist/llm/executor/provider-options.js

@@ -1,63 +1,263 @@
 import "../../chunk-PTJYTZNU.js";
 import { isReasoningCapableModel } from "../registry/index.js";
-function buildProviderOptions(config) {
-  const { provider, model, reasoningEffort } = config;
-  const modelLower = model.toLowerCase();
-  if (provider === "anthropic") {
+import {
+  isAnthropicAdaptiveThinkingModel,
+  supportsAnthropicInterleavedThinking
+} from "../reasoning/anthropic-thinking.js";
+import { ANTHROPIC_INTERLEAVED_THINKING_BETA } from "../reasoning/anthropic-betas.js";
+import { getReasoningProfile } from "../reasoning/profile.js";
+import { isOpenRouterGatewayProvider } from "../reasoning/profiles/openrouter.js";
+import {
+  supportsOpenAIReasoningEffort
+} from "../reasoning/openai-reasoning-effort.js";
+const ANTHROPIC_MIN_THINKING_BUDGET_TOKENS = 1024;
+const ANTHROPIC_DEFAULT_BUDGET_TOKENS = 2048;
+const GOOGLE_DEFAULT_BUDGET_TOKENS = 2048;
+const BEDROCK_DEFAULT_BUDGET_TOKENS = 2048;
+const ANTHROPIC_CACHE_CONTROL = { type: "ephemeral" };
+function coerceBudgetTokens(tokens, minimum) {
+  if (tokens === void 0) return void 0;
+  if (!Number.isFinite(tokens)) return void 0;
+  return Math.max(minimum, Math.floor(tokens));
+}
+function toOpenAIReasoningEffort(reasoningVariant) {
+  return reasoningVariant === "none" || reasoningVariant === "minimal" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" || reasoningVariant === "xhigh" ? reasoningVariant : void 0;
+}
+function toOpenAICompatibleReasoningEffort(reasoningVariant) {
+  return reasoningVariant === "none" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" ? reasoningVariant : void 0;
+}
+function getSelectedReasoningVariant(config) {
+  const profile = getReasoningProfile(config.provider, config.model);
+  const requested = config.reasoning?.variant;
+  if (requested !== void 0) {
+    const supported = profile.variants.some((entry) => entry.id === requested);
+    return {
+      reasoningVariant: supported ? requested : void 0,
+      hasInvalidRequestedReasoningVariant: !supported
+    };
+  }
+  return {
+    reasoningVariant: profile.defaultVariant,
+    hasInvalidRequestedReasoningVariant: false
+  };
+}
+function buildAnthropicProviderOptions(config) {
+  const { model, reasoningVariant, budgetTokens, capable } = config;
+  const adaptiveThinking = isAnthropicAdaptiveThinkingModel(model);
+  if (adaptiveThinking) {
+    if (reasoningVariant === "disabled") {
+      return {
+        anthropic: {
+          cacheControl: ANTHROPIC_CACHE_CONTROL,
+          sendReasoning: false,
+          thinking: { type: "disabled" }
+        }
+      };
+    }
+    const effort = reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" || reasoningVariant === "max" ? reasoningVariant : void 0;
+    return {
+      anthropic: {
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: true,
+        thinking: { type: "adaptive" },
+        ...effort !== void 0 && { effort }
+      }
+    };
+  }
+  if (!capable) {
     return {
       anthropic: {
-        // Enable prompt caching - saves money and improves latency
-        cacheControl: { type: "ephemeral" },
-        // Stream reasoning/thinking content when model supports it
-        sendReasoning: true
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: false,
+        ...reasoningVariant === "disabled" ? { thinking: { type: "disabled" } } : {}
       }
     };
   }
-  if (provider === "bedrock" && modelLower.includes("claude")) {
+  if (reasoningVariant === "disabled") {
     return {
-      bedrock: {
-        cacheControl: { type: "ephemeral" },
-        sendReasoning: true
+      anthropic: {
+        cacheControl: ANTHROPIC_CACHE_CONTROL,
+        sendReasoning: false,
+        thinking: { type: "disabled" }
       }
     };
   }
-  if (provider === "vertex" && modelLower.includes("claude")) {
+  const effectiveBudgetTokens = coerceBudgetTokens(
+    budgetTokens ?? ANTHROPIC_DEFAULT_BUDGET_TOKENS,
+    ANTHROPIC_MIN_THINKING_BUDGET_TOKENS
+  );
+  return {
+    anthropic: {
+      cacheControl: ANTHROPIC_CACHE_CONTROL,
+      sendReasoning: true,
+      ...effectiveBudgetTokens !== void 0 ? { thinking: { type: "enabled", budgetTokens: effectiveBudgetTokens } } : {}
+    }
+  };
+}
+function buildOpenRouterProviderOptions(config) {
+  const { provider, model, reasoningVariant, budgetTokens } = config;
+  const profile = getReasoningProfile(provider, model);
+  if (!profile.capable) {
+    return void 0;
+  }
+  if (reasoningVariant === "disabled") {
+    return { openrouter: { include_reasoning: false } };
+  }
+  if (budgetTokens !== void 0) {
     return {
-      "vertex-anthropic": {
-        cacheControl: { type: "ephemeral" },
-        sendReasoning: true
+      openrouter: {
+        include_reasoning: true,
+        reasoning: { enabled: true, max_tokens: budgetTokens }
       }
     };
   }
+  if (profile.paradigm === "budget") {
+    if (reasoningVariant === void 0 || reasoningVariant === "enabled") {
+      return {
+        openrouter: {
+          include_reasoning: true
+        }
+      };
+    }
+    return void 0;
+  }
+  const explicitEffort = toOpenAIReasoningEffort(reasoningVariant);
+  const effort = explicitEffort ?? (profile.paradigm === "adaptive-effort" && reasoningVariant === "max" ? "xhigh" : void 0);
+  return {
+    openrouter: {
+      include_reasoning: true,
+      ...effort !== void 0 ? { reasoning: { enabled: true, effort } } : {}
+    }
+  };
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function getEffectiveReasoningBudgetTokens(providerOptions) {
+  if (providerOptions === void 0) return void 0;
+  const anthropic = asRecord(providerOptions["anthropic"]);
+  const thinking = asRecord(anthropic?.["thinking"]);
+  if (thinking?.["type"] === "enabled" && typeof thinking["budgetTokens"] === "number") {
+    return thinking["budgetTokens"];
+  }
+  const google = asRecord(providerOptions["google"]);
+  const thinkingConfig = asRecord(google?.["thinkingConfig"]);
+  if (typeof thinkingConfig?.["thinkingBudget"] === "number") {
+    return thinkingConfig["thinkingBudget"];
+  }
+  const bedrock = asRecord(providerOptions["bedrock"]);
+  const reasoningConfig = asRecord(bedrock?.["reasoningConfig"]);
+  if (typeof reasoningConfig?.["budgetTokens"] === "number") {
+    return reasoningConfig["budgetTokens"];
+  }
+  const openrouter = asRecord(providerOptions["openrouter"]);
+  const reasoning = asRecord(openrouter?.["reasoning"]);
+  if (typeof reasoning?.["max_tokens"] === "number") {
+    return reasoning["max_tokens"];
+  }
+  return void 0;
+}
+function buildProviderOptions(config) {
+  const { provider, model, reasoning } = config;
+  const modelLower = model.toLowerCase();
+  const { reasoningVariant, hasInvalidRequestedReasoningVariant } = getSelectedReasoningVariant(config);
+  const budgetTokens = reasoning?.budgetTokens;
+  if (hasInvalidRequestedReasoningVariant) {
+    return void 0;
+  }
+  if (provider === "anthropic") {
+    const capable = isReasoningCapableModel(model, "anthropic");
+    return buildAnthropicProviderOptions({ model, reasoningVariant, budgetTokens, capable });
+  }
+  if (provider === "bedrock") {
+    const capable = isReasoningCapableModel(model, "bedrock");
+    if (!capable) {
+      return { bedrock: {} };
+    }
+    const isAnthropicModel = modelLower.includes("anthropic");
+    const isNovaModel = modelLower.includes("nova");
+    if (!isAnthropicModel && !isNovaModel) {
+      return { bedrock: {} };
+    }
+    const bedrock = {};
+    if (reasoningVariant === "disabled") {
+      bedrock["reasoningConfig"] = { type: "disabled" };
+      return { bedrock };
+    }
+    if (isAnthropicModel) {
+      const effectiveBudgetTokens = coerceBudgetTokens(
+        budgetTokens ?? BEDROCK_DEFAULT_BUDGET_TOKENS,
+        1
+      );
+      if (effectiveBudgetTokens === void 0) {
+        return { bedrock: {} };
+      }
+      bedrock["reasoningConfig"] = { type: "enabled", budgetTokens: effectiveBudgetTokens };
+      if (supportsAnthropicInterleavedThinking(model)) {
+        bedrock["anthropicBeta"] = [ANTHROPIC_INTERLEAVED_THINKING_BETA];
+      }
+      return { bedrock };
+    }
+    const maxReasoningEffort = reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high" ? reasoningVariant : void 0;
+    if (maxReasoningEffort !== void 0) {
+      bedrock["reasoningConfig"] = { type: "enabled", maxReasoningEffort };
+    }
+    return { bedrock };
+  }
+  if (provider === "vertex" && modelLower.includes("claude")) {
+    const capable = isReasoningCapableModel(model, "vertex");
+    return buildAnthropicProviderOptions({ model, reasoningVariant, budgetTokens, capable });
+  }
   if (provider === "google" || provider === "vertex" && !modelLower.includes("claude")) {
+    const profile = getReasoningProfile(provider, model);
+    const includeThoughts = profile.capable && reasoningVariant !== "disabled";
+    const isThinkingLevel = profile.paradigm === "thinking-level";
+    const thinkingLevel = includeThoughts && isThinkingLevel && (reasoningVariant === "minimal" || reasoningVariant === "low" || reasoningVariant === "medium" || reasoningVariant === "high") ? reasoningVariant : void 0;
+    const thinkingBudgetTokens = coerceBudgetTokens(
+      budgetTokens ?? GOOGLE_DEFAULT_BUDGET_TOKENS,
+      1
+    );
     return {
       google: {
         thinkingConfig: {
-          // Include thoughts in the response for transparency
-          includeThoughts: true
+          includeThoughts,
+          ...includeThoughts && isThinkingLevel && thinkingLevel !== void 0 && {
+            thinkingLevel
+          },
+          ...includeThoughts && profile.paradigm === "budget" && thinkingBudgetTokens !== void 0 && {
+            thinkingBudget: thinkingBudgetTokens
+          }
         }
       }
     };
   }
   if (provider === "openai") {
-    const effectiveEffort = reasoningEffort ?? getDefaultReasoningEffort(model);
-    if (effectiveEffort) {
+    const effortCandidate = toOpenAIReasoningEffort(reasoningVariant);
+    if (effortCandidate && supportsOpenAIReasoningEffort(model, effortCandidate)) {
       return {
         openai: {
-          reasoningEffort: effectiveEffort
+          reasoningEffort: effortCandidate,
+          ...effortCandidate !== "none" && { reasoningSummary: "auto" }
         }
       };
     }
   }
-  return void 0;
-}
-function getDefaultReasoningEffort(model) {
-  if (isReasoningCapableModel(model)) {
-    return "medium";
+  if (isOpenRouterGatewayProvider(provider)) {
+    return buildOpenRouterProviderOptions({ provider, model, reasoningVariant, budgetTokens });
+  }
+  if (provider === "openai-compatible") {
+    const profile = getReasoningProfile(provider, model);
+    if (!profile.capable) return void 0;
+    const reasoningEffort = toOpenAICompatibleReasoningEffort(reasoningVariant);
+    if (reasoningEffort === void 0) return void 0;
+    return {
+      openaiCompatible: { reasoningEffort }
+    };
   }
   return void 0;
 }
 export {
   buildProviderOptions,
-  getDefaultReasoningEffort
+  getEffectiveReasoningBudgetTokens
 };

package/dist/llm/executor/stream-processor.cjs

@@ -23,7 +23,7 @@ __export(stream_processor_exports, {
 module.exports = __toCommonJS(stream_processor_exports);
 var import_tool_output_truncator = require("./tool-output-truncator.js");
 var import_utils = require("../../context/utils.js");
-var import_types3 = require("../../logger/v2/types.js");
+var import_types2 = require("../../logger/v2/types.js");
 class StreamProcessor {
   /**
    * @param contextManager Context manager for message persistence
@@ -43,7 +43,7 @@ class StreamProcessor {
     this.config = config;
     this.streaming = streaming;
     this.toolCallMetadata = toolCallMetadata;
-    this.logger = logger.createChild(import_types3.DextoLogComponent.EXECUTOR);
+    this.logger = logger.createChild(import_types2.DextoLogComponent.EXECUTOR);
   }
   assistantMessageId = null;
   actualTokens = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
@@ -127,7 +127,7 @@ class StreamProcessor {
           case "reasoning-delta":
             this.reasoningText += event.text;
             if (event.providerMetadata) {
-              this.reasoningMetadata = event.providerMetadata;
+              this.mergeReasoningMetadata(event.providerMetadata);
             }
             if (this.streaming) {
               this.eventBus.emit("llm:chunk", {
@@ -284,10 +284,8 @@ class StreamProcessor {
             this.logger.info("LLM response complete", {
               finishReason: event.finishReason,
               contentLength: this.accumulatedText.length,
-              content: this.accumulatedText,
               ...this.reasoningText && {
-                reasoningLength: this.reasoningText.length,
-                reasoning: this.reasoningText
+                reasoningLength: this.reasoningText.length
               },
               usage,
               provider: this.config.provider,
@@ -308,15 +306,8 @@ class StreamProcessor {
             }
             const hasContent = this.accumulatedText || this.reasoningText;
             if (this.finishReason !== "tool-calls" || hasContent) {
-              this.eventBus.emit("llm:response", {
-                content: this.accumulatedText,
-                ...this.reasoningText && { reasoning: this.reasoningText },
-                provider: this.config.provider,
-                model: this.config.model,
+              this.emitLLMResponse({
                 tokenUsage: usage,
-                ...this.config.estimatedInputTokens !== void 0 && {
-                  estimatedInputTokens: this.config.estimatedInputTokens
-                },
                 finishReason: this.finishReason
               });
             }
@@ -363,7 +354,7 @@ class StreamProcessor {
           }
           case "error": {
             const err = event.error instanceof Error ? event.error : new Error(String(event.error));
-            this.logger.error(`LLM error: ${err.toString()}}`);
+            this.logger.error("LLM error", { error: err });
             this.eventBus.emit("llm:error", {
               error: err
             });
@@ -373,15 +364,8 @@ class StreamProcessor {
             this.logger.debug("Stream aborted, emitting partial response");
             this.finishReason = "cancelled";
             await this.persistCancelledToolResults();
-            this.eventBus.emit("llm:response", {
-              content: this.accumulatedText,
-              ...this.reasoningText && { reasoning: this.reasoningText },
-              provider: this.config.provider,
-              model: this.config.model,
+            this.emitLLMResponse({
               tokenUsage: this.actualTokens,
-              ...this.config.estimatedInputTokens !== void 0 && {
-                estimatedInputTokens: this.config.estimatedInputTokens
-              },
               finishReason: "cancelled"
             });
             return {
@@ -397,15 +381,8 @@ class StreamProcessor {
         this.logger.debug("Stream cancelled, emitting partial response");
         this.finishReason = "cancelled";
         await this.persistCancelledToolResults();
-        this.eventBus.emit("llm:response", {
-          content: this.accumulatedText,
-          ...this.reasoningText && { reasoning: this.reasoningText },
-          provider: this.config.provider,
-          model: this.config.model,
+        this.emitLLMResponse({
           tokenUsage: this.actualTokens,
-          ...this.config.estimatedInputTokens !== void 0 && {
-            estimatedInputTokens: this.config.estimatedInputTokens
-          },
           finishReason: "cancelled"
         });
         return {
@@ -463,6 +440,52 @@ class StreamProcessor {
     }
     return metadata;
   }
+  getReasoningResponseFields() {
+    return {
+      ...this.config.reasoningVariant !== void 0 && {
+        reasoningVariant: this.config.reasoningVariant
+      },
+      ...this.config.reasoningBudgetTokens !== void 0 && {
+        reasoningBudgetTokens: this.config.reasoningBudgetTokens
+      }
+    };
+  }
+  emitLLMResponse(config) {
+    this.eventBus.emit("llm:response", {
+      content: this.accumulatedText,
+      ...this.reasoningText && { reasoning: this.reasoningText },
+      provider: this.config.provider,
+      model: this.config.model,
+      ...this.getReasoningResponseFields(),
+      tokenUsage: config.tokenUsage,
+      ...this.config.estimatedInputTokens !== void 0 && {
+        estimatedInputTokens: this.config.estimatedInputTokens
+      },
+      finishReason: config.finishReason
+    });
+  }
+  mergeReasoningMetadata(providerMetadata) {
+    if (!this.reasoningMetadata) {
+      this.reasoningMetadata = providerMetadata;
+      return;
+    }
+    const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+    const previous = this.reasoningMetadata;
+    const merged = { ...previous, ...providerMetadata };
+    const previousOpenRouter = previous["openrouter"];
+    const nextOpenRouter = providerMetadata["openrouter"];
+    if (isRecord(previousOpenRouter) && isRecord(nextOpenRouter)) {
+      const previousDetails = previousOpenRouter["reasoning_details"];
+      const nextDetails = nextOpenRouter["reasoning_details"];
+      const combinedDetails = Array.isArray(previousDetails) && Array.isArray(nextDetails) ? [...previousDetails, ...nextDetails] : Array.isArray(nextDetails) ? nextDetails : Array.isArray(previousDetails) ? previousDetails : void 0;
+      merged["openrouter"] = {
+        ...previousOpenRouter,
+        ...nextOpenRouter,
+        ...combinedDetails ? { reasoning_details: combinedDetails } : {}
+      };
+    }
+    this.reasoningMetadata = merged;
+  }
   async createAssistantMessage() {
     await this.contextManager.addAssistantMessage("", [], {});
     return this.getLastMessageId();

package/dist/llm/executor/stream-processor.d.ts

@@ -3,14 +3,18 @@ import { ContextManager } from '../../context/manager.js';
 import { SessionEventBus } from '../../events/index.js';
 import { ResourceManager } from '../../resources/index.js';
 import { StreamProcessorResult } from './types.js';
-import { Logger } from '../../logger/v2/types.js';
-import { LLMProvider } from '../types.js';
+import type { Logger } from '../../logger/v2/types.js';
 import type { ToolPresentationSnapshotV1 } from '../../tools/types.js';
+import type { LLMProvider, ReasoningVariant } from '../types.js';
 export interface StreamProcessorConfig {
     provider: LLMProvider;
     model: string;
     /** Estimated input tokens before LLM call (for analytics/calibration) */
     estimatedInputTokens?: number;
+    /** Reasoning variant used for this call, when the provider exposes it. */
+    reasoningVariant?: ReasoningVariant;
+    /** Reasoning budget tokens used for this call, when the provider exposes it. */
+    reasoningBudgetTokens?: number;
 }
 export declare class StreamProcessor {
     private contextManager;
@@ -53,6 +57,9 @@ export declare class StreamProcessor {
     private getCacheTokensFromProviderMetadata;
     private normalizeUsage;
     private getProviderMetadata;
+    private getReasoningResponseFields;
+    private emitLLMResponse;
+    private mergeReasoningMetadata;
     private createAssistantMessage;
     private getLastMessageId;
     /**

package/dist/llm/executor/stream-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-processor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/stream-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,IAAI,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAmB,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAElD,OAAO,EAAE,WAAW,EAAc,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AA4CvE,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,qBAAa,eAAe;IA2BpB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,gBAAgB,CAAC;IAjC7B,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,YAAY,CAAmE;IACvF,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,iBAAiB,CAAsC;IAC/D,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAS;IAC7B;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAgD;IACxE,OAAO,CAAC,gBAAgB,CAAkE;IAE1F;;;;;;;;;OASG;gBAES,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,EACzB,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,qBAAqB,EACrC,MAAM,EAAE,MAAM,EACN,SAAS,GAAE,OAAc,EACzB,gBAAgB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN;QACI,oBAAoB,CAAC,EAAE,0BAA0B,CAAC;QAClD,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;KAC5C,CACJ,YAAA;IAKC,OAAO,CACT,QAAQ,EAAE,MAAM,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,GACzD,OAAO,CAAC,qBAAqB,CAAC;IA+fjC,OAAO,CAAC,kCAAkC;IAoB1C,OAAO,CAAC,cAAc;IA0CtB,OAAO,CAAC,mBAAmB;YAab,sBAAsB;YAKtB,gBAAgB;IAO9B;;;;OAIG;YACW,2BAA2B;CAmC5C"}
+{"version":3,"file":"stream-processor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/stream-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,IAAI,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAmB,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAc,MAAM,aAAa,CAAC;AA4C7E,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,gFAAgF;IAChF,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,qBAAa,eAAe;IA2BpB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,gBAAgB,CAAC;IAjC7B,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,YAAY,CAAmE;IACvF,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,iBAAiB,CAAsC;IAC/D,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAS;IAC7B;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAgD;IACxE,OAAO,CAAC,gBAAgB,CAAkE;IAE1F;;;;;;;;;OASG;gBAES,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,EACzB,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,qBAAqB,EACrC,MAAM,EAAE,MAAM,EACN,SAAS,GAAE,OAAc,EACzB,gBAAgB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN;QACI,oBAAoB,CAAC,EAAE,0BAA0B,CAAC;QAClD,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;KAC5C,CACJ,YAAA;IAKC,OAAO,CACT,QAAQ,EAAE,MAAM,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,GACzD,OAAO,CAAC,qBAAqB,CAAC;IAuejC,OAAO,CAAC,kCAAkC;IAoB1C,OAAO,CAAC,cAAc;IA0CtB,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,0BAA0B;IAclC,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,sBAAsB;YAwChB,sBAAsB;YAKtB,gBAAgB;IAO9B;;;;OAIG;YACW,2BAA2B;CAmC5C"}