@dexto/core 1.5.2 → 1.5.4

package/dist/agent/DextoAgent.js

@@ -398,7 +398,10 @@ Either:
         llmConfig.model
       );
     }
-    const responseEvent = events.find((e) => e.name === "llm:response");
+    const responseEvents = events.filter(
+      (e) => e.name === "llm:response"
+    );
+    const responseEvent = responseEvents[responseEvents.length - 1];
     if (!responseEvent || responseEvent.name !== "llm:response") {
       const llmConfig = this.stateManager.getLLMConfig(sessionId);
       throw LLMError.generationFailed(
@@ -582,6 +585,30 @@ Either:
       signal: cleanupSignal
     });
     listeners.push({ event: "tool:running", listener: toolRunningListener });
+    const contextCompactingListener = (data) => {
+      if (data.sessionId !== sessionId) return;
+      eventQueue.push({ name: "context:compacting", ...data });
+    };
+    this.agentEventBus.on("context:compacting", contextCompactingListener, {
+      signal: cleanupSignal
+    });
+    listeners.push({ event: "context:compacting", listener: contextCompactingListener });
+    const contextCompactedListener = (data) => {
+      if (data.sessionId !== sessionId) return;
+      eventQueue.push({ name: "context:compacted", ...data });
+    };
+    this.agentEventBus.on("context:compacted", contextCompactedListener, {
+      signal: cleanupSignal
+    });
+    listeners.push({ event: "context:compacted", listener: contextCompactedListener });
+    const sessionContinuedListener = (data) => {
+      if (data.previousSessionId !== sessionId) return;
+      eventQueue.push({ name: "session:continued", ...data });
+    };
+    this.agentEventBus.on("session:continued", sessionContinuedListener, {
+      signal: cleanupSignal
+    });
+    listeners.push({ event: "session:continued", listener: sessionContinuedListener });
     const messageQueuedListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "message:queued", ...data });
@@ -598,6 +625,14 @@ Either:
       signal: cleanupSignal
     });
     listeners.push({ event: "message:dequeued", listener: messageDequeuedListener });
+    const serviceEventListener = (data) => {
+      if (data.sessionId !== sessionId) return;
+      eventQueue.push({ name: "service:event", ...data });
+    };
+    this.agentEventBus.on("service:event", serviceEventListener, {
+      signal: cleanupSignal
+    });
+    listeners.push({ event: "service:event", listener: serviceEventListener });
     const runCompleteListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "run:complete", ...data });
@@ -733,12 +768,18 @@ Either:
             contentParts = [{ type: "text", text: textContent }];
           }
           const session = await this.sessionManager.getSession(sessionId) || await this.sessionManager.createSession(sessionId);
-          await session.stream(contentParts, signal ? { signal } : void 0);
+          const streamResult = await session.stream(
+            contentParts,
+            signal ? { signal } : void 0
+          );
           this.sessionManager.incrementMessageCount(session.id).catch(
             (error) => this.logger.warn(
               `Failed to increment message count: ${error instanceof Error ? error.message : String(error)}`
             )
           );
+          if (streamResult.didCompact && streamResult.compaction) {
+            await this.handleSessionContinuation(session, streamResult.compaction);
+          }
         } catch (err) {
           const error = err instanceof DextoRuntimeError || err instanceof DextoValidationError ? err : err instanceof Error ? err : AgentError.streamFailed(String(err));
           completed = true;
@@ -1112,6 +1153,173 @@ Either:
       sessionId
     });
   }
+  /**
+   * Manually compact the context using session-native compaction.
+   *
+   * Session-native compaction creates a NEW session with the summary as initial context,
+   * providing clean session isolation while maintaining traceability via linking.
+   *
+   * The old session is marked as compacted with `continuedTo` pointing to the new session,
+   * and the new session has `continuedFrom` pointing back to the old session.
+   *
+   * @param sessionId Session ID of the session to compact (required)
+   * @returns Compaction result with new session info, or null if compaction was skipped
+   */
+  async compactContext(sessionId) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    const session = await this.sessionManager.getSession(sessionId);
+    if (!session) {
+      throw SessionError.notFound(sessionId);
+    }
+    const llmService = session.getLLMService();
+    const compactionStrategy = llmService.getCompactionStrategy();
+    if (!compactionStrategy) {
+      this.logger.warn(
+        `Compaction strategy not configured for session ${sessionId} - skipping manual compaction`
+      );
+      return null;
+    }
+    const { SessionCompactionService } = await import("../session/compaction-service.js");
+    const compactionService = new SessionCompactionService(
+      this.sessionManager,
+      compactionStrategy,
+      this.logger
+    );
+    const compactionResult = await compactionService.compact(session, {
+      reason: "manual",
+      eventBus: this.agentEventBus
+    });
+    if (!compactionResult) {
+      this.logger.debug(`Compaction skipped for session ${sessionId} - nothing to compact`);
+      return null;
+    }
+    this.logger.info(
+      `Session-native compaction complete: ${sessionId} \u2192 ${compactionResult.newSessionId}, ${compactionResult.originalMessages} messages \u2192 ~${compactionResult.summaryTokens} token summary`
+    );
+    return {
+      previousSessionId: compactionResult.previousSessionId,
+      newSessionId: compactionResult.newSessionId,
+      summaryTokens: compactionResult.summaryTokens,
+      originalMessages: compactionResult.originalMessages
+    };
+  }
+  /**
+   * Get the chain of linked sessions (ancestors and descendants) for a session.
+   * Useful for displaying session history and understanding compaction lineage.
+   *
+   * @param sessionId Any session ID in the chain
+   * @returns Array of session data in the chain, ordered chronologically (oldest first)
+   */
+  async getSessionLineage(sessionId) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    const chain = await this.sessionManager.getSessionChain(sessionId);
+    if (chain.length === 0) {
+      throw SessionError.notFound(sessionId);
+    }
+    const currentIndex = chain.findIndex((s) => s.id === sessionId);
+    if (currentIndex < 0) {
+      throw SessionError.notFound(sessionId);
+    }
+    return {
+      chain: chain.map((s) => {
+        const item = {
+          id: s.id,
+          createdAt: s.createdAt
+        };
+        if (s.continuedFrom !== void 0) {
+          item.continuedFrom = s.continuedFrom;
+        }
+        if (s.continuedTo !== void 0) {
+          item.continuedTo = s.continuedTo;
+        }
+        if (s.compactedAt !== void 0) {
+          item.compactedAt = s.compactedAt;
+        }
+        return item;
+      }),
+      currentIndex
+    };
+  }
+  /**
+   * Get context usage statistics for a session.
+   * Useful for monitoring context window usage and compaction status.
+   *
+   * @param sessionId Session ID (required)
+   * @returns Context statistics including token estimates and message counts
+   */
+  async getContextStats(sessionId) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    const session = await this.sessionManager.getSession(sessionId);
+    if (!session) {
+      throw SessionError.notFound(sessionId);
+    }
+    const contextManager = session.getContextManager();
+    const contributorContext = { mcpManager: this.mcpManager };
+    const llmService = session.getLLMService();
+    const tools = await llmService.getAllTools();
+    const tokenEstimate = await contextManager.getContextTokenEstimate(
+      contributorContext,
+      tools
+    );
+    const history = await contextManager.getHistory();
+    const runtimeConfig = this.stateManager.getRuntimeConfig(sessionId);
+    const compactionConfig = runtimeConfig.compaction;
+    const modelContextWindow = contextManager.getMaxInputTokens();
+    let maxContextTokens = modelContextWindow;
+    if (compactionConfig?.maxContextTokens !== void 0) {
+      maxContextTokens = Math.min(maxContextTokens, compactionConfig.maxContextTokens);
+    }
+    const thresholdPercent = compactionConfig?.thresholdPercent ?? 0.9;
+    if (thresholdPercent < 1) {
+      maxContextTokens = Math.floor(maxContextTokens * thresholdPercent);
+    }
+    const hasSummary = history.some(
+      (msg) => msg.metadata?.isSummary === true || msg.metadata?.isSessionSummary === true
+    );
+    const llmConfig = runtimeConfig.llm;
+    const { getModelDisplayName } = await import("../llm/registry.js");
+    const modelDisplayName = getModelDisplayName(llmConfig.model, llmConfig.provider);
+    const estimatedTokens = tokenEstimate.estimated;
+    const compactionCount = await this.sessionManager.getCompactionCount(sessionId);
+    return {
+      estimatedTokens,
+      actualTokens: tokenEstimate.actual,
+      maxContextTokens,
+      modelContextWindow,
+      thresholdPercent,
+      usagePercent: maxContextTokens > 0 ? Math.round(estimatedTokens / maxContextTokens * 100) : 0,
+      messageCount: tokenEstimate.stats.originalMessageCount,
+      filteredMessageCount: tokenEstimate.stats.filteredMessageCount,
+      prunedToolCount: tokenEstimate.stats.prunedToolCount,
+      hasSummary,
+      compactionCount,
+      model: llmConfig.model,
+      modelDisplayName,
+      breakdown: {
+        systemPrompt: tokenEstimate.breakdown.systemPrompt,
+        tools: tokenEstimate.breakdown.tools,
+        messages: tokenEstimate.breakdown.messages
+      },
+      ...tokenEstimate.calculationBasis && {
+        calculationBasis: tokenEstimate.calculationBasis
+      }
+    };
+  }
   // ============= LLM MANAGEMENT =============
   /**
    * Gets the current LLM configuration with all defaults applied.
@@ -1187,6 +1395,83 @@ Either:
     }
     return validatedConfig;
   }
+  /**
+   * Handles session-native continuation after compaction.
+   *
+   * When context compaction occurs, this method:
+   * 1. Receives compaction data directly (summary text + preserved messages)
+   * 2. Creates a new continuation session
+   * 3. Adds the summary as the first message in the new session
+   * 4. Adds preserved messages to the new session
+   * 5. Links the old and new sessions for traceability
+   * 6. Emits session:continued event for UI to handle session switch
+   *
+   * IMPORTANT: The original session is NOT modified. The summary was never added to it.
+   * This is the clean session-native compaction approach where:
+   * - Original session: UNCHANGED (full history preserved)
+   * - New session: [summary, ...preservedMessages]
+   *
+   * @param currentSession The session that triggered compaction
+   * @param compactionData The compaction data with summary text and preserved messages
+   */
+  async handleSessionContinuation(currentSession, compactionData) {
+    const currentSessionId = currentSession.id;
+    try {
+      const { summaryText, preservedMessages, summarizedCount } = compactionData;
+      if (!summaryText) {
+        this.logger.warn(
+          `Session continuation skipped: empty summary text for session ${currentSessionId}`
+        );
+        return;
+      }
+      const { sessionId: newSessionId, session: newSession } = await this.sessionManager.createContinuationSession(currentSessionId);
+      const sessionSummaryMessage = {
+        role: "assistant",
+        content: [{ type: "text", text: summaryText }],
+        timestamp: Date.now(),
+        metadata: {
+          isSessionSummary: true,
+          continuedFrom: currentSessionId,
+          summarizedAt: Date.now(),
+          originalMessageCount: summarizedCount,
+          originalFirstTimestamp: compactionData.originalFirstTimestamp,
+          originalLastTimestamp: compactionData.originalLastTimestamp
+        }
+      };
+      const newContextManager = newSession.getContextManager();
+      await newContextManager.addMessage(sessionSummaryMessage);
+      for (const msg of preservedMessages) {
+        await newContextManager.addMessage(msg);
+      }
+      await this.sessionManager.markSessionCompacted(currentSessionId, newSessionId);
+      const { estimateMessagesTokens } = await import("../context/utils.js");
+      const summaryTokens = estimateMessagesTokens([sessionSummaryMessage]);
+      const totalOriginalMessages = summarizedCount + preservedMessages.length;
+      const newSessionLLMConfig = this.stateManager.getRuntimeConfig(newSessionId).llm;
+      const { getModelDisplayName } = await import("../llm/registry.js");
+      const modelDisplayName = getModelDisplayName(
+        newSessionLLMConfig.model,
+        newSessionLLMConfig.provider
+      );
+      this.logger.info(
+        `Session continuation: ${currentSessionId} \u2192 ${newSessionId} (${totalOriginalMessages} messages \u2192 summary + ${preservedMessages.length} preserved)`
+      );
+      this.agentEventBus.emit("session:continued", {
+        previousSessionId: currentSessionId,
+        newSessionId,
+        summaryTokens,
+        originalMessages: totalOriginalMessages,
+        reason: "overflow",
+        sessionId: newSessionId,
+        model: newSessionLLMConfig.model,
+        modelDisplayName
+      });
+    } catch (error) {
+      this.logger.error(
+        `Failed to handle session continuation for ${currentSessionId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   /**
    * Performs the actual LLM switch with a validated configuration.
    * This is a helper method that handles state management and session switching.