@dexto/core 1.7.2 → 1.8.1

package/dist/session/chat-session.cjs

@@ -22,8 +22,7 @@ __export(chat_session_exports, {
 });
 module.exports = __toCommonJS(chat_session_exports);
 var import_crypto = require("crypto");
-var import_factory = require("./history/factory.js");
-var import_factory2 = require("../llm/services/factory.js");
+var import_factory = require("../llm/services/factory.js");
 var import_events = require("../events/index.js");
 var import_types = require("../logger/v2/types.js");
 var import_errors = require("../errors/index.js");
@@ -37,7 +36,7 @@ class ChatSession {
    * Creates a new ChatSession instance.
    *
    * Each session creates its own isolated services:
-   * - ConversationHistoryProvider (with session-specific storage, shared across LLM switches)
+   * - ConversationStore (with session-specific storage, shared across LLM switches)
    * - LLM service (creates its own properly-typed ContextManager internally)
    * - SessionEventBus (session-local event handling)
    *
@@ -50,11 +49,19 @@ class ChatSession {
     this.id = id;
     this.logger = logger.createChild(import_types.DextoLogComponent.SESSION);
     this.eventBus = new import_events.SessionEventBus();
-    this.messageQueue = new import_message_queue.MessageQueueService(
+    this.steerQueue = new import_message_queue.MessageQueueService(
       this.eventBus,
       this.logger,
       this.id,
-      this.services.messageQueueStore
+      this.services.steerQueueStore,
+      "steer"
+    );
+    this.followUpQueue = new import_message_queue.MessageQueueService(
+      this.eventBus,
+      this.logger,
+      this.id,
+      this.services.followUpQueueStore,
+      "follow-up"
     );
     this.setupTokenAccumulation();
     this.logger.debug(`ChatSession ${this.id}: Created, awaiting initialization`);
@@ -72,10 +79,10 @@ class ChatSession {
    */
   eventBus;
   /**
-   * History provider that persists conversation messages.
+   * Store that persists conversation messages.
    * Shared across LLM switches to maintain conversation continuity.
    */
-  historyProvider;
+  conversationStore;
   /**
    * Handles AI model interactions, tool execution, and response generation for this session.
    *
@@ -84,10 +91,11 @@ class ChatSession {
    */
   llmService;
   /**
-   * Durable queued follow-up messages for this session.
-   * Reused across LLM switches so mid-task follow-ups survive service recreation.
+   * Durable queued user input for this session.
+   * Reused across LLM switches so mid-task steer/follow-up input survives service recreation.
    */
-  messageQueue;
+  steerQueue;
+  followUpQueue;
   activeForwarderCleanup = null;
   /**
    * Token accumulator listener for cleanup.
@@ -128,9 +136,10 @@ class ChatSession {
   setupTokenAccumulation() {
     this.tokenAccumulatorListener = (payload) => {
       if (payload.tokenUsage) {
+        const tokenUsage = (0, import_usage_metadata.normalizeTokenUsageForAccounting)(payload.tokenUsage);
         const llmConfig = this.services.stateManager.getLLMConfig(this.id);
         const isChatGPTLogin = llmConfig.provider === "openai-compatible" && (0, import_codex_base_url.parseCodexBaseURL)(llmConfig.baseURL)?.authMode === "chatgpt";
-        const hasMeaningfulUsage = (0, import_usage_metadata.hasMeaningfulTokenUsage)(payload.tokenUsage);
+        const hasMeaningfulUsage = (0, import_usage_metadata.hasMeaningfulTokenUsage)(tokenUsage);
         if (isChatGPTLogin && !hasMeaningfulUsage) {
           this.services.sessionManager.markUntrackedChatGPTLoginUsage(this.id).catch((err) => {
             this.logger.warn(
@@ -146,11 +155,11 @@ class ChatSession {
         const pricingMetadata = (0, import_usage_metadata.getUsagePricingMetadata)({
           provider: modelInfo.provider,
           model: modelInfo.model,
-          tokenUsage: payload.tokenUsage
+          tokenUsage
         });
         this.services.sessionManager.accumulateTokenUsage(
           this.id,
-          payload.tokenUsage,
+          tokenUsage,
           payload.estimatedCost ?? pricingMetadata.estimatedCost,
           modelInfo
         ).catch((err) => {
@@ -168,12 +177,9 @@ class ChatSession {
   async initializeServices() {
     const runtimeConfig = this.services.stateManager.getRuntimeConfig(this.id);
     const llmConfig = runtimeConfig.llm;
-    await this.messageQueue.initialize();
-    this.historyProvider = (0, import_factory.createDatabaseHistoryProvider)(
-      this.services.storageManager.getDatabase(),
-      this.id,
-      this.logger
-    );
+    await this.steerQueue.initialize();
+    await this.followUpQueue.initialize();
+    this.conversationStore = this.services.conversationStore;
     this.llmService = await this.createSessionLLMService(llmConfig, runtimeConfig.usageScopeId);
     this.logger.debug(`ChatSession ${this.id}: Services initialized with storage`);
   }
@@ -183,13 +189,14 @@ class ChatSession {
       usageScopeId,
       compactionStrategy: this.services.compactionStrategy,
       ...workspace?.path !== void 0 && { cwd: workspace.path },
-      messageQueue: this.messageQueue
+      steerQueue: this.steerQueue,
+      followUpQueue: this.followUpQueue
     };
-    return (0, import_factory2.createLLMService)(
+    return (0, import_factory.createLLMService)(
       llmConfig,
       this.services.toolManager,
       this.services.systemPromptManager,
-      this.historyProvider,
+      this.conversationStore,
       this.eventBus,
       this.id,
       this.services.resourceManager,
@@ -224,8 +231,8 @@ class ChatSession {
       timestamp: timestamp + 1,
       content: [{ type: "text", text: errorContent }]
     };
-    await this.historyProvider.saveMessage(userMessage);
-    await this.historyProvider.saveMessage(assistantMessage);
+    await this.conversationStore.saveMessage({ sessionId: this.id, message: userMessage });
+    await this.conversationStore.saveMessage({ sessionId: this.id, message: assistantMessage });
     const llmConfig = this.services.stateManager.getLLMConfig(this.id);
     this.eventBus.emit("llm:response", {
       content: errorContent,
@@ -234,6 +241,83 @@ class ChatSession {
       ...assistantMessage.id && { messageId: assistantMessage.id }
     });
   }
+  normalizeContent(content) {
+    return typeof content === "string" ? [{ type: "text", text: content }] : content;
+  }
+  async prepareTurnInput(content, signal, runContext) {
+    const parts = this.normalizeContent(content);
+    const textParts = parts.filter(
+      (p) => p.type === "text"
+    );
+    const imageParts = parts.filter((p) => p.type === "image");
+    const fileParts = parts.filter((p) => p.type === "file");
+    this.logger.debug(
+      `Streaming session ${this.id} | textParts=${textParts.length} | images=${imageParts.length} | files=${fileParts.length}`
+    );
+    const textContent = textParts.map((p) => p.text).join("\n");
+    const firstImage = imageParts[0];
+    const firstFile = fileParts[0];
+    const beforeLLMPayload = {
+      text: textContent,
+      ...firstImage && {
+        imageData: {
+          image: typeof firstImage.image === "string" ? firstImage.image : "[binary]",
+          mimeType: firstImage.mimeType || "image/jpeg"
+        }
+      },
+      ...firstFile && {
+        fileData: {
+          data: typeof firstFile.data === "string" ? firstFile.data : "[binary]",
+          mimeType: firstFile.mimeType,
+          ...firstFile.filename && { filename: firstFile.filename }
+        }
+      },
+      sessionId: this.id
+    };
+    const modifiedBeforePayload = await this.services.hookManager.executeHooks(
+      "beforeLLMRequest",
+      beforeLLMPayload,
+      {
+        sessionManager: this.services.sessionManager,
+        mcpManager: this.services.mcpManager,
+        toolManager: this.services.toolManager,
+        stateManager: this.services.stateManager,
+        ...runContext !== void 0 && { runContext },
+        sessionId: this.id,
+        abortSignal: signal
+      }
+    );
+    if (modifiedBeforePayload.text === textContent || textParts.length === 0) {
+      return parts;
+    }
+    return [
+      { type: "text", text: modifiedBeforePayload.text },
+      ...parts.filter((p) => p.type !== "text")
+    ];
+  }
+  async applyBeforeResponseHooks(content, signal, runContext) {
+    const llmConfig = this.services.stateManager.getLLMConfig(this.id);
+    const beforeResponsePayload = {
+      content,
+      provider: llmConfig.provider,
+      model: llmConfig.model,
+      sessionId: this.id
+    };
+    const modifiedResponsePayload = await this.services.hookManager.executeHooks(
+      "beforeResponse",
+      beforeResponsePayload,
+      {
+        sessionManager: this.services.sessionManager,
+        mcpManager: this.services.mcpManager,
+        toolManager: this.services.toolManager,
+        stateManager: this.services.stateManager,
+        ...runContext !== void 0 && { runContext },
+        sessionId: this.id,
+        abortSignal: signal
+      }
+    );
+    return modifiedResponsePayload.content;
+  }
   /**
    * Stream a response for the given content.
    * Primary method for running conversations with multi-image support.
@@ -256,15 +340,7 @@ class ChatSession {
    * ```
    */
   async stream(content, options) {
-    const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
-    const textParts = parts.filter(
-      (p) => p.type === "text"
-    );
-    const imageParts = parts.filter((p) => p.type === "image");
-    const fileParts = parts.filter((p) => p.type === "file");
-    this.logger.debug(
-      `Streaming session ${this.id} | textParts=${textParts.length} | images=${imageParts.length} | files=${fileParts.length}`
-    );
+    const parts = this.normalizeContent(content);
     if (this.isBusy()) {
       throw import_errors2.SessionError.busy(this.id);
     }
@@ -272,70 +348,17 @@ class ChatSession {
     const signal = options?.signal ? this.combineSignals(options.signal, this.currentRunController.signal) : this.currentRunController.signal;
     const detachForwarders = this.attachRunEventForwarders(options?.runContext);
     try {
-      const textContent = textParts.map((p) => p.text).join("\n");
-      const firstImage = imageParts[0];
-      const firstFile = fileParts[0];
-      const beforeLLMPayload = {
-        text: textContent,
-        ...firstImage && {
-          imageData: {
-            image: typeof firstImage.image === "string" ? firstImage.image : "[binary]",
-            mimeType: firstImage.mimeType || "image/jpeg"
-          }
-        },
-        ...firstFile && {
-          fileData: {
-            data: typeof firstFile.data === "string" ? firstFile.data : "[binary]",
-            mimeType: firstFile.mimeType,
-            ...firstFile.filename && { filename: firstFile.filename }
-          }
-        },
-        sessionId: this.id
-      };
-      const modifiedBeforePayload = await this.services.hookManager.executeHooks(
-        "beforeLLMRequest",
-        beforeLLMPayload,
-        {
-          sessionManager: this.services.sessionManager,
-          mcpManager: this.services.mcpManager,
-          toolManager: this.services.toolManager,
-          stateManager: this.services.stateManager,
-          ...options?.runContext !== void 0 && { runContext: options.runContext },
-          sessionId: this.id,
-          abortSignal: signal
-        }
-      );
-      let modifiedParts = [...parts];
-      if (modifiedBeforePayload.text !== textContent && textParts.length > 0) {
-        modifiedParts = modifiedParts.filter((p) => p.type !== "text");
-        modifiedParts.unshift({ type: "text", text: modifiedBeforePayload.text });
-      }
+      const modifiedParts = await this.prepareTurnInput(content, signal, options?.runContext);
       const streamResult = await this.llmService.stream(modifiedParts, {
         signal,
         ...options?.runContext !== void 0 && { runContext: options.runContext }
       });
-      const llmConfig = this.services.stateManager.getLLMConfig(this.id);
-      const beforeResponsePayload = {
-        content: streamResult.text,
-        provider: llmConfig.provider,
-        model: llmConfig.model,
-        sessionId: this.id
-      };
-      const modifiedResponsePayload = await this.services.hookManager.executeHooks(
-        "beforeResponse",
-        beforeResponsePayload,
-        {
-          sessionManager: this.services.sessionManager,
-          mcpManager: this.services.mcpManager,
-          toolManager: this.services.toolManager,
-          stateManager: this.services.stateManager,
-          ...options?.runContext !== void 0 && { runContext: options.runContext },
-          sessionId: this.id,
-          abortSignal: signal
-        }
-      );
       return {
-        text: modifiedResponsePayload.content
+        text: await this.applyBeforeResponseHooks(
+          streamResult.text,
+          signal,
+          options?.runContext
+        )
       };
     } catch (error) {
       const aborted = error instanceof Error && error.name === "AbortError" || typeof error === "object" && error !== null && error.aborted === true;
@@ -389,6 +412,94 @@ class ChatSession {
       this.currentRunController = null;
     }
   }
+  async createTurnDriver(input) {
+    if (this.isBusy()) {
+      throw import_errors2.SessionError.busy(this.id);
+    }
+    this.currentRunController = new AbortController();
+    const signal = input.signal ? this.combineSignals(input.signal, this.currentRunController.signal) : this.currentRunController.signal;
+    const detachForwarders = this.attachRunEventForwarders(input.runContext);
+    try {
+      if (input.kind === "start") {
+        const modifiedParts = await this.prepareTurnInput(
+          input.content,
+          signal,
+          input.runContext
+        );
+        await this.llmService.getContextManager().addUserMessage(modifiedParts);
+      }
+      const driver = await this.llmService.createTurnDriver({
+        signal,
+        streaming: input.streaming ?? true,
+        ...input.runContext !== void 0 && { runContext: input.runContext },
+        ...input.kind === "resume" ? { state: input.state } : {}
+      });
+      return this.wrapTurnDriver(driver, signal, input.runContext, detachForwarders);
+    } catch (error) {
+      if (input.kind === "start" && error instanceof import_errors.DextoRuntimeError && error.code === import_error_codes.HookErrorCode.HOOK_BLOCKED_EXECUTION && error.scope === import_errors.ErrorScope.HOOK && error.type === import_errors.ErrorType.FORBIDDEN) {
+        const textContent = this.normalizeContent(input.content).filter((p) => p.type === "text").map((p) => p.text).join("\n");
+        await this.saveBlockedInteraction(textContent, error.message);
+      }
+      detachForwarders();
+      this.currentRunController = null;
+      throw error;
+    }
+  }
+  wrapTurnDriver(driver, signal, runContext, detachForwarders) {
+    let closed = false;
+    const close = () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      detachForwarders();
+      this.currentRunController = null;
+    };
+    return {
+      prepareNextModelStep: () => driver.prepareNextModelStep(),
+      runNextModelStep: () => driver.runNextModelStep(),
+      executeToolCalls: () => driver.executeToolCalls(),
+      decideNextStep: () => driver.decideNextStep(),
+      finish: async () => {
+        try {
+          const result = await driver.finish();
+          return {
+            ...result,
+            text: await this.applyBeforeResponseHooks(result.text, signal, runContext)
+          };
+        } finally {
+          driver.dispose();
+          close();
+        }
+      },
+      fail: async (error) => {
+        try {
+          return await driver.fail(error);
+        } finally {
+          driver.dispose();
+          close();
+        }
+      },
+      getState: () => driver.getState(),
+      checkpoint: () => {
+        try {
+          return driver.checkpoint();
+        } finally {
+          close();
+        }
+      },
+      dispose: () => {
+        if (closed) {
+          return;
+        }
+        try {
+          driver.dispose();
+        } finally {
+          close();
+        }
+      }
+    };
+  }
   /**
    * Combine multiple abort signals into one.
    */
@@ -424,7 +535,7 @@ class ChatSession {
    * ```
    */
   async getHistory() {
-    return await this.historyProvider.getHistory();
+    return await this.conversationStore.listMessages({ sessionId: this.id });
   }
   /**
    * Reset the conversation history for this session.
@@ -552,40 +663,85 @@ class ChatSession {
     return this.currentRunController !== null && !this.currentRunController.signal.aborted;
   }
   /**
-   * Queue a message for processing when the session is busy.
-   * The message will be injected into the conversation when the current turn completes.
+   * Queue a message as active-turn steer input.
+   * The message is injected at the next executor boundary while the current turn is active.
+   *
+   * @param message The user message to use as steer input
+   * @returns Queue position and message ID
+   */
+  async steer(message) {
+    return await this.llmService.getSteerQueue().enqueue(message);
+  }
+  /**
+   * Queue a follow-up message for processing after the current turn naturally completes.
    *
-   * @param message The user message to queue
+   * @param message The user message to queue as follow-up work
    * @returns Queue position and message ID
    */
-  async queueMessage(message) {
-    return await this.llmService.getMessageQueue().enqueue(message);
+  async followUp(message) {
+    return await this.llmService.getFollowUpQueue().enqueue(message);
+  }
+  /**
+   * Get all steer messages currently queued.
+   * @returns Array of steer messages
+   */
+  getSteerMessages() {
+    return this.llmService.getSteerQueue().getAll();
+  }
+  /**
+   * Get all follow-up messages currently queued.
+   * @returns Array of follow-up messages
+   */
+  getFollowUpMessages() {
+    return this.llmService.getFollowUpQueue().getAll();
   }
   /**
-   * Get all messages currently in the queue.
-   * @returns Array of queued messages
+   * Remove a steer message.
+   * @param id Message ID to remove
+   * @returns true if message was found and removed; false otherwise
    */
-  getQueuedMessages() {
-    return this.llmService.getMessageQueue().getAll();
+  async removeSteerMessage(id) {
+    return await this.llmService.getSteerQueue().remove(id);
   }
   /**
-   * Remove a queued message.
+   * Remove a follow-up message.
    * @param id Message ID to remove
    * @returns true if message was found and removed; false otherwise
    */
-  async removeQueuedMessage(id) {
-    return await this.llmService.getMessageQueue().remove(id);
+  async removeFollowUpMessage(id) {
+    return await this.llmService.getFollowUpQueue().remove(id);
   }
   /**
-   * Clear all queued messages.
+   * Clear all steer messages.
    * @returns Number of messages that were cleared
    */
-  async clearMessageQueue() {
-    const queue = this.llmService.getMessageQueue();
+  async clearSteerQueue() {
+    const queue = this.llmService.getSteerQueue();
     const count = queue.pendingCount();
     await queue.clear();
     return count;
   }
+  /**
+   * Clear all follow-up messages.
+   * @returns Number of messages that were cleared
+   */
+  async clearFollowUpQueue() {
+    const queue = this.llmService.getFollowUpQueue();
+    const count = queue.pendingCount();
+    await queue.clear();
+    return count;
+  }
+  /**
+   * Clear all pending steer and follow-up input for this session.
+   * @returns Number of messages that were cleared
+   */
+  async clearPendingInput() {
+    const [steerCount, followUpCount] = await Promise.all([
+      this.clearSteerQueue(),
+      this.clearFollowUpQueue()
+    ]);
+    return steerCount + followUpCount;
+  }
   /**
    * Cancel the currently running turn for this session, if any.
    * Returns true if a run was in progress and was signaled to abort.