@dexto/core 1.5.3 → 1.5.4

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) {
@@ -55,13 +56,32 @@ class TurnExecutor {
    * Used to pass approval info from tool execution to result persistence.
    */
   approvalMetadata = /* @__PURE__ */ new Map();
+  /**
+   * Tracks whether compaction occurred during this turn.
+   * Used to signal to the caller that session continuation may be needed.
+   */
+  compactionOccurred = false;
+  /**
+   * Compaction data captured during this turn.
+   * Contains summary text and preserved messages for session continuation.
+   * This data is passed up the call chain (NOT persisted to original session).
+   */
+  compactionData = null;
+  /**
+   * Virtual context for remaining iterations after compaction.
+   * When set, the main loop uses this instead of calling getFormattedMessagesForLLM().
+   * This provides reduced context to the LLM without persisting to the original session.
+   */
+  virtualContext = null;
   /**
    * 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 +137,34 @@ 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 = this.virtualContext ? await this.buildMessagesFromVirtualContext(contributorContext) : 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`
+            );
+            await this.compactToVirtualContext(estimatedTokens);
+            if (this.virtualContext) {
+              prepared = await this.buildMessagesFromVirtualContext(contributorContext);
+              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 +172,7 @@ class TurnExecutor {
             this.eventBus,
             this.resourceManager,
             this.stepAbortController.signal,
-            this.getStreamProcessorConfig(),
+            this.getStreamProcessorConfig(estimatedTokens),
             this.logger,
             streaming,
             this.approvalMetadata
@@ -170,6 +211,28 @@ 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 diff = estimatedTokens - result.usage.inputTokens;
+            const diffPercent = result.usage.inputTokens > 0 ? (diff / result.usage.inputTokens * 100).toFixed(1) : "0.0";
+            this.logger.info(
+              `Context estimation accuracy: estimated=${estimatedTokens}, actual=${result.usage.inputTokens}, error=${diff} (${diffPercent}%)`
+            );
+            this.contextManager.setLastActualInputTokens(result.usage.inputTokens);
+            if (result.usage?.outputTokens !== void 0) {
+              this.contextManager.setLastActualOutputTokens(result.usage.outputTokens);
+            }
+            await this.contextManager.recordLastCallMessageCount();
+          }
+          if (!this.virtualContext && result.usage?.inputTokens && this.shouldCompactFromActual(result.usage.inputTokens)) {
+            this.logger.debug(
+              `Post-response: actual ${result.usage.inputTokens} tokens exceeds threshold, compacting`
+            );
+            await this.compactToVirtualContext(result.usage.inputTokens);
+          }
           if (result.finishReason !== "tool-calls") {
             const queuedOnTerminate = this.messageQueue.dequeueAll();
             if (queuedOnTerminate) {
@@ -193,7 +256,6 @@ class TurnExecutor {
             lastFinishReason = "max-steps";
             break;
           }
-          await this.pruneOldToolOutputs();
         }
       } catch (error) {
         const mappedError = this.mapProviderError(error);
@@ -223,7 +285,14 @@ class TurnExecutor {
         text: lastText,
         stepCount,
         usage: lastStepTokens,
-        finishReason: lastFinishReason
+        finishReason: lastFinishReason,
+        // Signal to caller that compaction occurred during this turn
+        // Caller can use this to trigger session-native continuation
+        didCompact: this.compactionOccurred,
+        // Pass compaction data up the chain (NOT persisted to original session)
+        // Caller uses this to create the continuation session with summary
+        // Use spread to conditionally include only when data exists (exactOptionalPropertyTypes)
+        ...this.compactionData && { compaction: this.compactionData }
       };
     } catch (_2) {
       var _error = _2, _hasError = true;
@@ -521,7 +590,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,55 +659,175 @@ 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 using ReactiveOverflowStrategy WITHOUT persisting to original session.
+   *
+   * Key design: Creates a virtual context (summary + preserved messages) that will be used
+   * for the remaining iterations of this turn. The compaction data is passed up the call chain
+   * so the caller can create a continuation session with the summary.
    *
-   * @param originalTokens The actual input token count from API that triggered overflow
+   * The original session remains UNTOUCHED - no messages are added or modified.
+   *
+   * @param originalTokens The estimated input token count that triggered overflow
    */
-  async compress(originalTokens) {
+  async compactToVirtualContext(originalTokens) {
     if (!this.compactionStrategy) {
       return;
     }
     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();
+    if (history.length < 4) {
+      this.logger.debug("Compaction skipped: history too short to summarize");
+      return;
+    }
+    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)");
+      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: history.length,
+        compactedMessages: history.length,
+        // No change
+        strategy: this.compactionStrategy.name,
+        reason: "overflow"
+      });
+      return;
+    }
+    const summaryMessage = summaryMessages[0];
+    if (!summaryMessage) {
+      this.logger.warn("Compaction returned empty summary message array");
       return;
     }
-    for (const summary of summaryMessages) {
-      await this.contextManager.addMessage(summary);
+    const summaryText = this.extractSummaryText(summaryMessage);
+    const summarizedCount = summaryMessage.metadata?.originalMessageCount ?? 0;
+    let existingSummaryIndex = -1;
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      if (msg?.metadata?.isSummary === true || msg?.metadata?.isSessionSummary === true) {
+        existingSummaryIndex = i;
+        break;
+      }
     }
-    const { filterCompacted, estimateMessagesTokens } = await import("../../context/utils.js");
-    const updatedHistory = await this.contextManager.getHistory();
-    const filteredHistory = filterCompacted(updatedHistory);
-    const compactedTokens = estimateMessagesTokens(filteredHistory);
+    const baseIndex = existingSummaryIndex >= 0 ? existingSummaryIndex + 1 : 0;
+    const preservedMessages = history.slice(baseIndex + summarizedCount);
+    const firstTimestamp = summaryMessage.metadata?.originalFirstTimestamp;
+    const lastTimestamp = summaryMessage.metadata?.originalLastTimestamp;
+    this.compactionData = {
+      summaryText,
+      preservedMessages: [...preservedMessages],
+      // Copy to avoid mutation
+      summarizedCount,
+      ...firstTimestamp !== void 0 && { originalFirstTimestamp: firstTimestamp },
+      ...lastTimestamp !== void 0 && { originalLastTimestamp: lastTimestamp }
+    };
+    this.virtualContext = {
+      summaryMessage,
+      preservedMessages: [...preservedMessages]
+    };
+    this.compactionOccurred = true;
+    this.contextManager.resetActualTokenTracking();
+    const { estimateMessagesTokens: estimateTokens } = await import("../../context/utils.js");
+    const virtualMessages = [summaryMessage, ...preservedMessages];
+    const compactedTokens = estimateTokens(virtualMessages);
     this.eventBus.emit("context:compacted", {
       originalTokens,
       compactedTokens,
       originalMessages: history.length,
-      compactedMessages: filteredHistory.length,
+      compactedMessages: virtualMessages.length,
       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 (virtual context): ${originalTokens} \u2192 ~${compactedTokens} tokens (${history.length} \u2192 ${virtualMessages.length} messages). Original session unchanged - summary will be passed to continuation session.`
     );
   }
+  /**
+   * Extract the summary text from a summary message.
+   */
+  extractSummaryText(summaryMessage) {
+    if (typeof summaryMessage.content === "string") {
+      return summaryMessage.content;
+    }
+    if (Array.isArray(summaryMessage.content)) {
+      return summaryMessage.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+    }
+    return "";
+  }
+  /**
+   * Build formatted messages from virtual context (after compaction).
+   *
+   * This creates LLM-ready messages using:
+   * - System prompt (same as normal flow)
+   * - Summary message (as first message)
+   * - Preserved messages (formatted for LLM)
+   *
+   * Uses the same formatting pipeline as getFormattedMessagesForLLM()
+   * but with our virtual history instead of the stored history.
+   *
+   * @param contributorContext Context for system prompt contributors
+   * @returns Formatted messages ready for LLM call, matching getFormattedMessagesForLLM return type
+   */
+  async buildMessagesFromVirtualContext(contributorContext) {
+    if (!this.virtualContext) {
+      throw new Error("buildMessagesFromVirtualContext called without virtual context");
+    }
+    const { summaryMessage, preservedMessages } = this.virtualContext;
+    const systemPrompt = await this.contextManager.getSystemPrompt(contributorContext);
+    const virtualHistory = [summaryMessage, ...preservedMessages];
+    const formattedMessages = await this.contextManager.getFormattedMessages(
+      contributorContext,
+      this.llmContext,
+      systemPrompt,
+      virtualHistory
+    );
+    return {
+      formattedMessages,
+      systemPrompt,
+      preparedHistory: virtualHistory
+    };
+  }
   /**
    * Set telemetry span attributes for token usage.
    */

package/dist/llm/executor/types.d.ts

@@ -1,5 +1,23 @@
+import type { InternalMessage } from '../../context/types.js';
 import { TokenUsage } from '../types.js';
 import { LLMFinishReason } from '../../events/index.js';
+/**
+ * Data captured during context compaction for session-native continuation.
+ * This is passed through the call chain so the new session can be created
+ * with the summary and preserved messages.
+ */
+export interface CompactionData {
+    /** The generated summary text */
+    summaryText: string;
+    /** Messages preserved (not summarized) - typically last N turns */
+    preservedMessages: InternalMessage[];
+    /** Number of messages that were summarized */
+    summarizedCount: number;
+    /** Timestamp of first summarized message */
+    originalFirstTimestamp?: number;
+    /** Timestamp of last summarized message */
+    originalLastTimestamp?: number;
+}
 export interface ExecutorResult {
     /**
      * The accumulated text from assistant responses.
@@ -13,6 +31,16 @@ export interface ExecutorResult {
     usage: TokenUsage | null;
     /** Reason the execution finished */
     finishReason: LLMFinishReason;
+    /**
+     * Set to true if context compaction occurred during this turn.
+     * Caller can use this to trigger session-native continuation (create new session).
+     */
+    didCompact: boolean;
+    /**
+     * Compaction data when didCompact is true.
+     * Contains the summary text and preserved messages for creating the continuation session.
+     */
+    compaction?: CompactionData;
 }
 export interface StreamProcessorResult {
     /**

package/dist/llm/executor/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,WAAW,cAAc;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,oCAAoC;IACpC,YAAY,EAAE,eAAe,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,eAAe,CAAC;IAC9B,KAAK,EAAE,UAAU,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC3B,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC,8CAA8C;IAC9C,eAAe,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,2CAA2C;IAC3C,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,oCAAoC;IACpC,YAAY,EAAE,eAAe,CAAC;IAC9B;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,eAAe,CAAC;IAC9B,KAAK,EAAE,UAAU,CAAC;CACrB"}

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 {