@dexto/core 1.5.3 → 1.5.5

package/dist/llm/executor/turn-executor.js

@@ -23,7 +23,7 @@ import { ReactiveOverflowStrategy } from "../../context/compaction/strategies/re
 const toolSupportCache = /* @__PURE__ */ new Map();
 const LOCAL_PROVIDERS = ["ollama", "local"];
 class TurnExecutor {
-  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal, compactionStrategy) {
+  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal, compactionStrategy, compactionThresholdPercent = 1) {
     this.model = model;
     this.toolManager = toolManager;
     this.contextManager = contextManager;
@@ -35,6 +35,7 @@ class TurnExecutor {
     this.messageQueue = messageQueue;
     this.modelLimits = modelLimits;
     this.externalSignal = externalSignal;
+    this.compactionThresholdPercent = compactionThresholdPercent;
     this.logger = logger.createChild(DextoLogComponent.EXECUTOR);
     this.stepAbortController = new AbortController();
     if (compactionStrategy !== void 0) {
@@ -57,11 +58,13 @@ class TurnExecutor {
   approvalMetadata = /* @__PURE__ */ new Map();
   /**
    * Get StreamProcessor config from TurnExecutor state.
+   * @param estimatedInputTokens Optional estimated input tokens for analytics
    */
-  getStreamProcessorConfig() {
+  getStreamProcessorConfig(estimatedInputTokens) {
     return {
       provider: this.llmContext.provider,
-      model: this.llmContext.model
+      model: this.llmContext.model,
+      ...estimatedInputTokens !== void 0 && { estimatedInputTokens }
     };
   }
   /**
@@ -117,13 +120,41 @@ class TurnExecutor {
           if (coalesced) {
             await this.injectQueuedMessages(coalesced);
           }
-          if (lastStepTokens && this.checkAndHandleOverflow(lastStepTokens)) {
-            await this.compress(lastStepTokens.inputTokens ?? 0);
-          }
-          const prepared = await this.contextManager.getFormattedMessagesWithCompression(
+          await this.pruneOldToolOutputs();
+          let prepared = await this.contextManager.getFormattedMessagesForLLM(
             contributorContext,
             this.llmContext
           );
+          const toolDefinitions = supportsTools ? await this.toolManager.getAllTools() : {};
+          let estimatedTokens = await this.contextManager.getEstimatedNextInputTokens(
+            prepared.systemPrompt,
+            prepared.preparedHistory,
+            toolDefinitions
+          );
+          if (this.shouldCompact(estimatedTokens)) {
+            this.logger.debug(
+              `Pre-check: estimated ${estimatedTokens} tokens exceeds threshold, compacting`
+            );
+            const didCompact = await this.compactContext(
+              estimatedTokens,
+              contributorContext,
+              toolDefinitions
+            );
+            if (didCompact) {
+              prepared = await this.contextManager.getFormattedMessagesForLLM(
+                contributorContext,
+                this.llmContext
+              );
+              estimatedTokens = await this.contextManager.getEstimatedNextInputTokens(
+                prepared.systemPrompt,
+                prepared.preparedHistory,
+                toolDefinitions
+              );
+              this.logger.debug(
+                `Post-compaction: recomputed estimate is ${estimatedTokens} tokens`
+              );
+            }
+          }
           this.logger.debug(`Step ${stepCount}: Starting`);
           const tools = supportsTools ? await this.createTools() : {};
           const streamProcessor = new StreamProcessor(
@@ -131,7 +162,7 @@ class TurnExecutor {
             this.eventBus,
             this.resourceManager,
             this.stepAbortController.signal,
-            this.getStreamProcessorConfig(),
+            this.getStreamProcessorConfig(estimatedTokens),
             this.logger,
             streaming,
             this.approvalMetadata
@@ -170,6 +201,35 @@ class TurnExecutor {
           this.logger.debug(
             `Step ${stepCount}: Finished with reason="${result.finishReason}", tokens=${JSON.stringify(result.usage)}`
           );
+          if (result.finishReason === "cancelled") {
+            this.logger.info(
+              `Context estimation (cancelled): keeping last known actuals, partial response (${result.text.length} chars) will be estimated`
+            );
+          } else if (result.usage?.inputTokens !== void 0) {
+            const contextInputTokens2 = this.getContextInputTokens(result.usage);
+            const actualInputTokens = contextInputTokens2 ?? result.usage.inputTokens;
+            const diff = estimatedTokens - actualInputTokens;
+            const diffPercent = actualInputTokens > 0 ? (diff / actualInputTokens * 100).toFixed(1) : "0.0";
+            this.logger.info(
+              `Context estimation accuracy: estimated=${estimatedTokens}, actual=${actualInputTokens}, error=${diff} (${diffPercent}%)`
+            );
+            this.contextManager.setLastActualInputTokens(actualInputTokens);
+            if (result.usage?.outputTokens !== void 0) {
+              this.contextManager.setLastActualOutputTokens(result.usage.outputTokens);
+            }
+            await this.contextManager.recordLastCallMessageCount();
+          }
+          const contextInputTokens = result.usage ? this.getContextInputTokens(result.usage) : null;
+          if (contextInputTokens && this.shouldCompactFromActual(contextInputTokens)) {
+            this.logger.debug(
+              `Post-response: actual ${contextInputTokens} tokens exceeds threshold, compacting`
+            );
+            await this.compactContext(
+              contextInputTokens,
+              contributorContext,
+              toolDefinitions
+            );
+          }
           if (result.finishReason !== "tool-calls") {
             const queuedOnTerminate = this.messageQueue.dequeueAll();
             if (queuedOnTerminate) {
@@ -193,7 +253,6 @@ class TurnExecutor {
             lastFinishReason = "max-steps";
             break;
           }
-          await this.pruneOldToolOutputs();
         }
       } catch (error) {
         const mappedError = this.mapProviderError(error);
@@ -521,7 +580,7 @@ class TurnExecutor {
   /**
    * Prunes old tool outputs by marking them with compactedAt timestamp.
    * Does NOT modify content - transformation happens at format time in
-   * ContextManager.getFormattedMessagesWithCompression().
+   * ContextManager.prepareHistory().
    *
    * Algorithm:
    * 1. Go backwards through history (most recent first)
@@ -590,54 +649,108 @@ class TurnExecutor {
     this.messageQueue.clear();
   }
   /**
-   * Check if context has overflowed based on actual token usage from API.
+   * Check if context should be compacted based on estimated token count.
+   * Uses the threshold percentage from compaction config to trigger earlier (e.g., at 90%).
+   *
+   * @param estimatedTokens Estimated token count from the current context
+   * @returns true if compaction is needed before making the LLM call
    */
-  checkAndHandleOverflow(tokens) {
+  shouldCompact(estimatedTokens) {
     if (!this.modelLimits || !this.compactionStrategy) {
       return false;
     }
-    return isOverflow(tokens, this.modelLimits);
+    return isOverflow(
+      { inputTokens: estimatedTokens },
+      this.modelLimits,
+      this.compactionThresholdPercent
+    );
   }
   /**
-   * Compress context using ReactiveOverflowStrategy.
+   * Check if context should be compacted based on actual token count from API response.
+   * This is a post-response check using real token counts rather than estimates.
    *
-   * Generates a summary of older messages and adds it to history.
-   * The actual token reduction happens at read-time via filterCompacted()
-   * in getFormattedMessagesWithCompression().
+   * @param actualTokens Actual input token count from the API response
+   * @returns true if compaction is needed
+   */
+  shouldCompactFromActual(actualTokens) {
+    if (!this.modelLimits || !this.compactionStrategy) {
+      return false;
+    }
+    return isOverflow(
+      { inputTokens: actualTokens },
+      this.modelLimits,
+      this.compactionThresholdPercent
+    );
+  }
+  /**
+   * Compact context by generating a summary and adding it to the same session.
+   *
+   * The summary message is added to the conversation history with `isSummary: true` metadata.
+   * When the context is loaded via getFormattedMessagesForLLM(), filterCompacted() will
+   * exclude all messages before the summary, effectively compacting the context.
    *
-   * @param originalTokens The actual input token count from API that triggered overflow
+   * @param originalTokens The estimated input token count that triggered overflow
+   * @param contributorContext Context for system prompt contributors (needed for accurate token estimation)
+   * @param tools Tool definitions (needed for accurate token estimation)
+   * @returns true if compaction occurred, false if skipped
    */
-  async compress(originalTokens) {
+  async compactContext(originalTokens, contributorContext, tools) {
     if (!this.compactionStrategy) {
-      return;
+      return false;
     }
     this.logger.info(
-      `Context overflow detected (${originalTokens} tokens), running compression`
+      `Context overflow detected (${originalTokens} tokens), checking if compression is possible`
     );
     const history = await this.contextManager.getHistory();
+    const { filterCompacted } = await import("../../context/utils.js");
+    const originalFiltered = filterCompacted(history);
+    const originalMessages = originalFiltered.length;
+    if (history.length < 4) {
+      this.logger.debug("Compaction skipped: history too short to summarize");
+      return false;
+    }
+    this.eventBus.emit("context:compacting", {
+      estimatedTokens: originalTokens
+    });
     const summaryMessages = await this.compactionStrategy.compact(history);
     if (summaryMessages.length === 0) {
-      this.logger.debug("Compaction returned no summary (history too short)");
-      return;
+      this.logger.debug(
+        "Compaction skipped: strategy returned no summary (likely already compacted or nothing to summarize)"
+      );
+      this.eventBus.emit("context:compacted", {
+        originalTokens,
+        compactedTokens: originalTokens,
+        // No change
+        originalMessages,
+        compactedMessages: originalMessages,
+        // No change
+        strategy: this.compactionStrategy.name,
+        reason: "overflow"
+      });
+      return false;
     }
     for (const summary of summaryMessages) {
       await this.contextManager.addMessage(summary);
     }
-    const { filterCompacted, estimateMessagesTokens } = await import("../../context/utils.js");
-    const updatedHistory = await this.contextManager.getHistory();
-    const filteredHistory = filterCompacted(updatedHistory);
-    const compactedTokens = estimateMessagesTokens(filteredHistory);
+    this.contextManager.resetActualTokenTracking();
+    const afterEstimate = await this.contextManager.getContextTokenEstimate(
+      contributorContext,
+      tools
+    );
+    const compactedTokens = afterEstimate.estimated;
+    const compactedMessages = afterEstimate.stats.filteredMessageCount;
     this.eventBus.emit("context:compacted", {
       originalTokens,
       compactedTokens,
-      originalMessages: history.length,
-      compactedMessages: filteredHistory.length,
+      originalMessages,
+      compactedMessages,
       strategy: this.compactionStrategy.name,
       reason: "overflow"
     });
     this.logger.info(
-      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${history.length} \u2192 ${filteredHistory.length} messages after filtering)`
+      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${originalMessages} \u2192 ${compactedMessages} messages after filtering)`
     );
+    return true;
   }
   /**
    * Set telemetry span attributes for token usage.
@@ -660,6 +773,10 @@ class TurnExecutor {
       activeSpan.setAttribute("gen_ai.usage.reasoning_tokens", usage.reasoningTokens);
     }
   }
+  getContextInputTokens(usage) {
+    if (usage.inputTokens === void 0) return null;
+    return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+  }
   /**
    * Map provider errors to DextoRuntimeError.
    */

package/dist/llm/formatters/vercel.cjs

@@ -166,16 +166,26 @@ class VercelMessageFormatter {
   formatSystemPrompt() {
     return null;
   }
-  // Helper to format Assistant messages (with optional tool calls)
+  // Helper to format Assistant messages (with optional tool calls and reasoning)
   formatAssistantMessage(msg) {
-    if (msg.toolCalls && msg.toolCalls.length > 0) {
-      const contentParts = [];
-      if (Array.isArray(msg.content)) {
-        const combined = msg.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
-        if (combined) {
-          contentParts.push({ type: "text", text: combined });
-        }
+    const contentParts = [];
+    if (msg.reasoning) {
+      const reasoningPart = {
+        type: "reasoning",
+        text: msg.reasoning,
+        ...msg.reasoningMetadata && { providerOptions: msg.reasoningMetadata }
+      };
+      contentParts.push(reasoningPart);
+    }
+    if (Array.isArray(msg.content)) {
+      const combined = msg.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+      if (combined) {
+        contentParts.push({ type: "text", text: combined });
       }
+    } else if (typeof msg.content === "string") {
+      contentParts.push({ type: "text", text: msg.content });
+    }
+    if (msg.toolCalls && msg.toolCalls.length > 0) {
       for (const toolCall of msg.toolCalls) {
         const rawArgs = toolCall.function.arguments;
         let parsed = {};
@@ -202,28 +212,26 @@ class VercelMessageFormatter {
         }
         contentParts.push(toolCallPart);
       }
-      const firstToolCall = msg.toolCalls?.[0];
-      if (firstToolCall) {
-        const argString = (() => {
-          const raw = firstToolCall.function.arguments;
-          if (typeof raw === "string") return raw;
-          try {
-            return JSON.stringify(raw ?? {});
-          } catch {
-            return "{}";
-          }
-        })();
-        return {
-          content: contentParts,
-          function_call: {
-            name: firstToolCall.function.name,
-            arguments: argString
-          }
-        };
-      }
+      const firstToolCall = msg.toolCalls[0];
+      const argString = (() => {
+        const raw = firstToolCall.function.arguments;
+        if (typeof raw === "string") return raw;
+        try {
+          return JSON.stringify(raw ?? {});
+        } catch {
+          return "{}";
+        }
+      })();
+      return {
+        content: contentParts,
+        function_call: {
+          name: firstToolCall.function.name,
+          arguments: argString
+        }
+      };
     }
     return {
-      content: typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : msg.content === null ? [] : msg.content
+      content: contentParts.length > 0 ? contentParts : []
     };
   }
   // Helper to format Tool result messages

package/dist/llm/formatters/vercel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../src/llm/formatters/vercel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAiD,MAAM,IAAI,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAiC,MAAM,wBAAwB,CAAC;AAE7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAmB7D;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAGhC;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC,EACpC,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,MAAM,GAAG,IAAI,GAC5B,YAAY,EAAE;IAsJjB;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAK1B,OAAO,CAAC,sBAAsB;IA8E9B,OAAO,CAAC,iBAAiB;CAoE5B"}
+{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../src/llm/formatters/vercel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAiD,MAAM,IAAI,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAiC,MAAM,wBAAwB,CAAC;AAE7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAmB7D;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAGhC;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC,EACpC,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,MAAM,GAAG,IAAI,GAC5B,YAAY,EAAE;IAsJjB;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAK1B,OAAO,CAAC,sBAAsB;IA0F9B,OAAO,CAAC,iBAAiB;CAoE5B"}

package/dist/llm/formatters/vercel.js

@@ -144,16 +144,26 @@ class VercelMessageFormatter {
   formatSystemPrompt() {
     return null;
   }
-  // Helper to format Assistant messages (with optional tool calls)
+  // Helper to format Assistant messages (with optional tool calls and reasoning)
   formatAssistantMessage(msg) {
-    if (msg.toolCalls && msg.toolCalls.length > 0) {
-      const contentParts = [];
-      if (Array.isArray(msg.content)) {
-        const combined = msg.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
-        if (combined) {
-          contentParts.push({ type: "text", text: combined });
-        }
+    const contentParts = [];
+    if (msg.reasoning) {
+      const reasoningPart = {
+        type: "reasoning",
+        text: msg.reasoning,
+        ...msg.reasoningMetadata && { providerOptions: msg.reasoningMetadata }
+      };
+      contentParts.push(reasoningPart);
+    }
+    if (Array.isArray(msg.content)) {
+      const combined = msg.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+      if (combined) {
+        contentParts.push({ type: "text", text: combined });
       }
+    } else if (typeof msg.content === "string") {
+      contentParts.push({ type: "text", text: msg.content });
+    }
+    if (msg.toolCalls && msg.toolCalls.length > 0) {
       for (const toolCall of msg.toolCalls) {
         const rawArgs = toolCall.function.arguments;
         let parsed = {};
@@ -180,28 +190,26 @@ class VercelMessageFormatter {
         }
         contentParts.push(toolCallPart);
       }
-      const firstToolCall = msg.toolCalls?.[0];
-      if (firstToolCall) {
-        const argString = (() => {
-          const raw = firstToolCall.function.arguments;
-          if (typeof raw === "string") return raw;
-          try {
-            return JSON.stringify(raw ?? {});
-          } catch {
-            return "{}";
-          }
-        })();
-        return {
-          content: contentParts,
-          function_call: {
-            name: firstToolCall.function.name,
-            arguments: argString
-          }
-        };
-      }
+      const firstToolCall = msg.toolCalls[0];
+      const argString = (() => {
+        const raw = firstToolCall.function.arguments;
+        if (typeof raw === "string") return raw;
+        try {
+          return JSON.stringify(raw ?? {});
+        } catch {
+          return "{}";
+        }
+      })();
+      return {
+        content: contentParts,
+        function_call: {
+          name: firstToolCall.function.name,
+          arguments: argString
+        }
+      };
     }
     return {
-      content: typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : msg.content === null ? [] : msg.content
+      content: contentParts.length > 0 ? contentParts : []
     };
   }
   // Helper to format Tool result messages

package/dist/llm/services/factory.cjs

@@ -139,7 +139,7 @@ function getOpenAICompatibleBaseURL(llmConfig) {
   }
   return "";
 }
-function createLLMService(config, toolManager, systemPromptManager, historyProvider, sessionEventBus, sessionId, resourceManager, logger, compactionStrategy) {
+function createLLMService(config, toolManager, systemPromptManager, historyProvider, sessionEventBus, sessionId, resourceManager, logger, compactionStrategy, compactionConfig) {
   const model = createVercelModel(config);
   return new import_vercel.VercelLLMService(
     toolManager,
@@ -151,7 +151,8 @@ function createLLMService(config, toolManager, systemPromptManager, historyProvi
     sessionId,
     resourceManager,
     logger,
-    compactionStrategy
+    compactionStrategy,
+    compactionConfig
   );
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/llm/services/factory.d.ts

@@ -6,6 +6,7 @@ import { SessionEventBus } from '../../events/index.js';
 import type { IConversationHistoryProvider } from '../../session/history/types.js';
 import type { SystemPromptManager } from '../../systemPrompt/manager.js';
 import type { IDextoLogger } from '../../logger/v2/types.js';
+import type { CompactionConfigInput } from '../../context/compaction/schemas.js';
 export declare function createVercelModel(llmConfig: ValidatedLLMConfig): LanguageModel;
 /**
  * Create an LLM service instance using the Vercel AI SDK.
@@ -20,7 +21,8 @@ export declare function createVercelModel(llmConfig: ValidatedLLMConfig): Langua
  * @param resourceManager Resource manager for blob storage and resource access
  * @param logger Logger instance for dependency injection
  * @param compactionStrategy Optional compaction strategy for context management
+ * @param compactionConfig Optional compaction configuration for thresholds
  * @returns VercelLLMService instance
  */
-export declare function createLLMService(config: ValidatedLLMConfig, toolManager: ToolManager, systemPromptManager: SystemPromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, sessionId: string, resourceManager: import('../../resources/index.js').ResourceManager, logger: IDextoLogger, compactionStrategy?: import('../../context/compaction/types.js').ICompactionStrategy | null): VercelLLMService;
+export declare function createLLMService(config: ValidatedLLMConfig, toolManager: ToolManager, systemPromptManager: SystemPromptManager, historyProvider: IConversationHistoryProvider, sessionEventBus: SessionEventBus, sessionId: string, resourceManager: import('../../resources/index.js').ResourceManager, logger: IDextoLogger, compactionStrategy?: import('../../context/compaction/types.js').ICompactionStrategy | null, compactionConfig?: CompactionConfigInput): VercelLLMService;
 //# sourceMappingURL=factory.d.ts.map

package/dist/llm/services/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/llm/services/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAUnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,kBAAkB,GAAG,aAAa,CAoJ9E;AAoBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,mBAAmB,EACxC,eAAe,EAAE,4BAA4B,EAC7C,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,OAAO,0BAA0B,EAAE,eAAe,EACnE,MAAM,EAAE,YAAY,EACpB,kBAAkB,CAAC,EAAE,OAAO,mCAAmC,EAAE,mBAAmB,GAAG,IAAI,GAC5F,gBAAgB,CAelB"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/llm/services/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAUnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAEjF,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,kBAAkB,GAAG,aAAa,CAoJ9E;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,mBAAmB,EACxC,eAAe,EAAE,4BAA4B,EAC7C,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,OAAO,0BAA0B,EAAE,eAAe,EACnE,MAAM,EAAE,YAAY,EACpB,kBAAkB,CAAC,EAAE,OAAO,mCAAmC,EAAE,mBAAmB,GAAG,IAAI,EAC3F,gBAAgB,CAAC,EAAE,qBAAqB,GACzC,gBAAgB,CAgBlB"}

package/dist/llm/services/factory.js

@@ -116,7 +116,7 @@ function getOpenAICompatibleBaseURL(llmConfig) {
   }
   return "";
 }
-function createLLMService(config, toolManager, systemPromptManager, historyProvider, sessionEventBus, sessionId, resourceManager, logger, compactionStrategy) {
+function createLLMService(config, toolManager, systemPromptManager, historyProvider, sessionEventBus, sessionId, resourceManager, logger, compactionStrategy, compactionConfig) {
   const model = createVercelModel(config);
   return new VercelLLMService(
     toolManager,
@@ -128,7 +128,8 @@ function createLLMService(config, toolManager, systemPromptManager, historyProvi
     sessionId,
     resourceManager,
     logger,
-    compactionStrategy
+    compactionStrategy,
+    compactionConfig
   );
 }
 export {

package/dist/llm/services/vercel.cjs

@@ -92,13 +92,15 @@ class VercelLLMService {
   resourceManager;
   messageQueue;
   compactionStrategy;
+  modelLimits;
+  compactionThresholdPercent;
   /**
    * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
    */
   getModelId() {
     return typeof this.model === "string" ? this.model : this.model.modelId;
   }
-  constructor(toolManager, model, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager, logger, compactionStrategy) {
+  constructor(toolManager, model, systemPromptManager, historyProvider, sessionEventBus, config, sessionId, resourceManager, logger, compactionStrategy, compactionConfig) {
     this.logger = logger.createChild(import_types2.DextoLogComponent.LLM);
     this.model = model;
     this.config = config;
@@ -107,9 +109,20 @@ class VercelLLMService {
     this.sessionId = sessionId;
     this.resourceManager = resourceManager;
     this.compactionStrategy = compactionStrategy ?? null;
+    this.compactionThresholdPercent = compactionConfig?.thresholdPercent ?? 0.9;
     this.messageQueue = new import_message_queue.MessageQueueService(this.sessionEventBus, this.logger);
     const formatter = new import_vercel.VercelMessageFormatter(this.logger);
     const maxInputTokens = (0, import_registry.getEffectiveMaxInputTokens)(config, this.logger);
+    let effectiveContextWindow = maxInputTokens;
+    if (compactionConfig?.maxContextTokens !== void 0) {
+      effectiveContextWindow = Math.min(maxInputTokens, compactionConfig.maxContextTokens);
+      this.logger.debug(
+        `Compaction: Using maxContextTokens override: ${compactionConfig.maxContextTokens} (model max: ${maxInputTokens})`
+      );
+    }
+    this.modelLimits = {
+      contextWindow: effectiveContextWindow
+    };
     this.contextManager = new import_manager.ContextManager(
       config,
       formatter,
@@ -149,19 +162,23 @@ class VercelLLMService {
       { provider: this.config.provider, model: this.getModelId() },
       this.logger,
       this.messageQueue,
-      void 0,
-      // modelLimits - TurnExecutor will use defaults
+      this.modelLimits,
       externalSignal,
-      this.compactionStrategy
+      this.compactionStrategy,
+      this.compactionThresholdPercent
     );
   }
+  /**
+   * Result from streaming a response.
+   */
+  static StreamResult;
   /**
    * Stream a response for the given content.
    * Primary method for running conversations with multi-image support.
    *
    * @param content - String or ContentPart[] (text, images, files)
    * @param options - { signal?: AbortSignal }
-   * @returns The assistant's text response
+   * @returns Object with text response
    */
   async stream(content, options) {
     const activeSpan = import_api.trace.getActiveSpan();
@@ -191,7 +208,9 @@ class VercelLLMService {
       const executor = this.createTurnExecutor(options?.signal);
       const contributorContext = { mcpManager: this.toolManager.getMcpManager() };
       const result = await executor.execute(contributorContext, true);
-      return result.text ?? "";
+      return {
+        text: result.text ?? ""
+      };
     });
   }
   /**
@@ -236,6 +255,12 @@ class VercelLLMService {
   getMessageQueue() {
     return this.messageQueue;
   }
+  /**
+   * Get the compaction strategy for external access (e.g., session-native compaction)
+   */
+  getCompactionStrategy() {
+    return this.compactionStrategy;
+  }
 }
 _init = __decoratorStart(null);
 VercelLLMService = __decorateElement(_init, 0, "VercelLLMService", _VercelLLMService_decorators, VercelLLMService);