@dexto/core 1.6.25 → 1.6.27

package/dist/session/chat-session.js

@@ -4,21 +4,23 @@ import { createDatabaseHistoryProvider } from "./history/factory.js";
 import { createLLMService } from "../llm/services/factory.js";
 import {
   SessionEventBus,
-  SessionEventNames
+  forwardSessionEventsToAgentBus
 } from "../events/index.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { DextoRuntimeError, ErrorScope, ErrorType } from "../errors/index.js";
 import { HookErrorCode } from "../hooks/error-codes.js";
+import { MessageQueueService } from "./message-queue.js";
 import { getUsagePricingMetadata, hasMeaningfulTokenUsage } from "../llm/usage-metadata.js";
 import { parseCodexBaseURL } from "../llm/providers/codex-base-url.js";
+import { SessionError } from "./errors.js";
 class ChatSession {
   /**
    * Creates a new ChatSession instance.
    *
    * Each session creates its own isolated services:
    * - ConversationHistoryProvider (with session-specific storage, shared across LLM switches)
-   * - LLMService (creates its own properly-typed ContextManager internally)
-   * - SessionEventBus (session-local event handling with forwarding)
+   * - LLM service (creates its own properly-typed ContextManager internally)
+   * - SessionEventBus (session-local event handling)
    *
    * @param services - The shared services from the agent (state manager, prompt, client managers, etc.)
    * @param id - Unique identifier for this session
@@ -29,7 +31,13 @@ class ChatSession {
     this.id = id;
     this.logger = logger.createChild(DextoLogComponent.SESSION);
     this.eventBus = new SessionEventBus();
-    this.setupEventForwarding();
+    this.messageQueue = new MessageQueueService(
+      this.eventBus,
+      this.logger,
+      this.id,
+      this.services.messageQueueStore
+    );
+    this.setupTokenAccumulation();
     this.logger.debug(`ChatSession ${this.id}: Created, awaiting initialization`);
   }
   /**
@@ -52,15 +60,16 @@ class ChatSession {
   /**
    * Handles AI model interactions, tool execution, and response generation for this session.
    *
-   * Each session has its own LLMService instance that uses the session's
+   * Each session has its own LLM runtime instance that uses the session's
    * ContextManager and event bus.
    */
   llmService;
   /**
-   * Map of event forwarder functions for cleanup.
-   * Stores the bound functions so they can be removed from the event bus.
+   * Durable queued follow-up messages for this session.
+   * Reused across LLM switches so mid-task follow-ups survive service recreation.
    */
-  forwarders = /* @__PURE__ */ new Map();
+  messageQueue;
+  activeForwarderCleanup = null;
   /**
    * Token accumulator listener for cleanup.
    */
@@ -78,27 +87,20 @@ class ChatSession {
   async init() {
     await this.initializeServices();
   }
-  /**
-   * Sets up event forwarding from session bus to global agent bus.
-   *
-   * All session events are automatically forwarded to the global bus with the same
-   * event names, but with session context added to the payload. This allows the app
-   * layer to continue listening to standard events while having access to session
-   * information when needed.
-   */
-  setupEventForwarding() {
-    SessionEventNames.forEach((eventName) => {
-      const forwarder = (payload) => {
-        const payloadWithSession = payload && typeof payload === "object" ? { ...payload, sessionId: this.id } : { sessionId: this.id };
-        this.services.agentEventBus.emit(eventName, payloadWithSession);
-      };
-      this.forwarders.set(eventName, forwarder);
-      this.eventBus.on(eventName, forwarder);
+  attachRunEventForwarders(runContext) {
+    const cleanup = forwardSessionEventsToAgentBus({
+      sessionEventBus: this.eventBus,
+      agentEventBus: this.services.agentEventBus,
+      sessionId: this.id,
+      ...runContext?.hostRuntime !== void 0 ? { hostRuntime: runContext.hostRuntime } : {}
     });
-    this.setupTokenAccumulation();
-    this.logger.debug(
-      `[setupEventForwarding] Event forwarding setup complete for session=${this.id}`
-    );
+    this.activeForwarderCleanup = cleanup;
+    return () => {
+      if (this.activeForwarderCleanup === cleanup) {
+        this.activeForwarderCleanup = null;
+      }
+      cleanup();
+    };
   }
   /**
    * Sets up token usage accumulation by listening to llm:response events.
@@ -147,33 +149,35 @@ class ChatSession {
   async initializeServices() {
     const runtimeConfig = this.services.stateManager.getRuntimeConfig(this.id);
     const llmConfig = runtimeConfig.llm;
-    const workspace = await this.services.workspaceManager?.getWorkspace();
+    await this.messageQueue.initialize();
     this.historyProvider = createDatabaseHistoryProvider(
       this.services.storageManager.getDatabase(),
       this.id,
       this.logger
     );
-    const compactionStrategy = this.services.compactionStrategy;
-    this.llmService = createLLMService(
+    this.llmService = await this.createSessionLLMService(llmConfig, runtimeConfig.usageScopeId);
+    this.logger.debug(`ChatSession ${this.id}: Services initialized with storage`);
+  }
+  async createSessionLLMService(llmConfig, usageScopeId) {
+    const workspace = await this.services.workspaceManager?.getWorkspace();
+    const options = {
+      usageScopeId,
+      compactionStrategy: this.services.compactionStrategy,
+      ...workspace?.path !== void 0 && { cwd: workspace.path },
+      messageQueue: this.messageQueue
+    };
+    return createLLMService(
       llmConfig,
       this.services.toolManager,
       this.services.systemPromptManager,
       this.historyProvider,
-      // Pass history provider for service to use
       this.eventBus,
-      // Use session event bus
       this.id,
       this.services.resourceManager,
-      // Pass ResourceManager for blob storage
       this.logger,
-      // Pass logger for dependency injection
-      {
-        usageScopeId: runtimeConfig.usageScopeId,
-        compactionStrategy,
-        cwd: workspace?.path
-      }
+      options,
+      this.services.languageModelFactory
     );
-    this.logger.debug(`ChatSession ${this.id}: Services initialized with storage`);
   }
   /**
    * Saves a blocked interaction to history when a plugin blocks execution.
@@ -242,8 +246,12 @@ class ChatSession {
     this.logger.debug(
       `Streaming session ${this.id} | textParts=${textParts.length} | images=${imageParts.length} | files=${fileParts.length}`
     );
+    if (this.isBusy()) {
+      throw SessionError.busy(this.id);
+    }
     this.currentRunController = new AbortController();
     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];
@@ -273,6 +281,7 @@ class ChatSession {
           mcpManager: this.services.mcpManager,
           toolManager: this.services.toolManager,
           stateManager: this.services.stateManager,
+          ...options?.runContext !== void 0 && { runContext: options.runContext },
           sessionId: this.id,
           abortSignal: signal
         }
@@ -282,7 +291,10 @@ class ChatSession {
         modifiedParts = modifiedParts.filter((p) => p.type !== "text");
         modifiedParts.unshift({ type: "text", text: modifiedBeforePayload.text });
       }
-      const streamResult = await this.llmService.stream(modifiedParts, { signal });
+      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,
@@ -298,6 +310,7 @@ class ChatSession {
           mcpManager: this.services.mcpManager,
           toolManager: this.services.toolManager,
           stateManager: this.services.stateManager,
+          ...options?.runContext !== void 0 && { runContext: options.runContext },
           sessionId: this.id,
           abortSignal: signal
         }
@@ -353,6 +366,7 @@ class ChatSession {
       );
       throw error;
     } finally {
+      detachForwarders();
       this.currentRunController = null;
     }
   }
@@ -429,9 +443,9 @@ class ChatSession {
     return this.llmService.getContextManager();
   }
   /**
-   * Gets the session's LLMService instance.
+   * Gets the session's LLM service instance.
    *
-   * @returns The LLMService for this session
+   * @returns The session LLM service for this session
    */
   getLLMService() {
     return this.llmService;
@@ -458,26 +472,10 @@ class ChatSession {
   async switchLLM(newLLMConfig) {
     try {
       const runtimeConfig = this.services.stateManager.getRuntimeConfig(this.id);
-      const workspace = await this.services.workspaceManager?.getWorkspace();
-      const compactionStrategy = this.services.compactionStrategy;
-      const newLLMService = createLLMService(
+      this.llmService = await this.createSessionLLMService(
         newLLMConfig,
-        this.services.toolManager,
-        this.services.systemPromptManager,
-        this.historyProvider,
-        // Pass the SAME history provider - preserves conversation!
-        this.eventBus,
-        // Use session event bus
-        this.id,
-        this.services.resourceManager,
-        this.logger,
-        {
-          usageScopeId: runtimeConfig.usageScopeId,
-          compactionStrategy,
-          cwd: workspace?.path
-        }
+        runtimeConfig.usageScopeId
       );
-      this.llmService = newLLMService;
       this.logger.info(
         `ChatSession ${this.id}: LLM switched to ${newLLMConfig.provider}/${newLLMConfig.model}`
       );
@@ -519,10 +517,8 @@ class ChatSession {
    */
   dispose() {
     this.logger.debug(`Disposing session ${this.id} - cleaning up event listeners`);
-    this.forwarders.forEach((forwarder, eventName) => {
-      this.eventBus.off(eventName, forwarder);
-    });
-    this.forwarders.clear();
+    this.activeForwarderCleanup?.();
+    this.activeForwarderCleanup = null;
     if (this.tokenAccumulatorListener) {
       this.eventBus.off("llm:response", this.tokenAccumulatorListener);
       this.tokenAccumulatorListener = null;
@@ -543,8 +539,8 @@ class ChatSession {
    * @param message The user message to queue
    * @returns Queue position and message ID
    */
-  queueMessage(message) {
-    return this.llmService.getMessageQueue().enqueue(message);
+  async queueMessage(message) {
+    return await this.llmService.getMessageQueue().enqueue(message);
   }
   /**
    * Get all messages currently in the queue.
@@ -558,17 +554,17 @@ class ChatSession {
    * @param id Message ID to remove
    * @returns true if message was found and removed; false otherwise
    */
-  removeQueuedMessage(id) {
-    return this.llmService.getMessageQueue().remove(id);
+  async removeQueuedMessage(id) {
+    return await this.llmService.getMessageQueue().remove(id);
   }
   /**
    * Clear all queued messages.
    * @returns Number of messages that were cleared
    */
-  clearMessageQueue() {
+  async clearMessageQueue() {
     const queue = this.llmService.getMessageQueue();
     const count = queue.pendingCount();
-    queue.clear();
+    await queue.clear();
     return count;
   }
   /**

package/dist/session/error-codes.cjs

@@ -27,6 +27,7 @@ var SessionErrorCode = /* @__PURE__ */ ((SessionErrorCode2) => {
   SessionErrorCode2["SESSION_MAX_SESSIONS_EXCEEDED"] = "session_max_sessions_exceeded";
   SessionErrorCode2["SESSION_STORAGE_FAILED"] = "session_storage_failed";
   SessionErrorCode2["SESSION_RESET_FAILED"] = "session_reset_failed";
+  SessionErrorCode2["SESSION_BUSY"] = "session_busy";
   return SessionErrorCode2;
 })(SessionErrorCode || {});
 // Annotate the CommonJS export names for ESM import in node:

package/dist/session/error-codes.d.ts

@@ -7,6 +7,7 @@ export declare enum SessionErrorCode {
     SESSION_INITIALIZATION_FAILED = "session_initialization_failed",
     SESSION_MAX_SESSIONS_EXCEEDED = "session_max_sessions_exceeded",
     SESSION_STORAGE_FAILED = "session_storage_failed",
-    SESSION_RESET_FAILED = "session_reset_failed"
+    SESSION_RESET_FAILED = "session_reset_failed",
+    SESSION_BUSY = "session_busy"
 }
 //# sourceMappingURL=error-codes.d.ts.map

package/dist/session/error-codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/session/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,gBAAgB;IAExB,iBAAiB,sBAAsB;IACvC,6BAA6B,kCAAkC;IAC/D,6BAA6B,kCAAkC;IAG/D,sBAAsB,2BAA2B;IAGjD,oBAAoB,yBAAyB;CAChD"}
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/session/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,gBAAgB;IAExB,iBAAiB,sBAAsB;IACvC,6BAA6B,kCAAkC;IAC/D,6BAA6B,kCAAkC;IAG/D,sBAAsB,2BAA2B;IAGjD,oBAAoB,yBAAyB;IAC7C,YAAY,iBAAiB;CAChC"}

package/dist/session/error-codes.js

@@ -5,6 +5,7 @@ var SessionErrorCode = /* @__PURE__ */ ((SessionErrorCode2) => {
   SessionErrorCode2["SESSION_MAX_SESSIONS_EXCEEDED"] = "session_max_sessions_exceeded";
   SessionErrorCode2["SESSION_STORAGE_FAILED"] = "session_storage_failed";
   SessionErrorCode2["SESSION_RESET_FAILED"] = "session_reset_failed";
+  SessionErrorCode2["SESSION_BUSY"] = "session_busy";
   return SessionErrorCode2;
 })(SessionErrorCode || {});
 export {

package/dist/session/errors.cjs

@@ -86,6 +86,19 @@ class SessionError {
       { sessionId, reason }
     );
   }
+  /**
+   * Session already processing a run
+   */
+  static busy(sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.SessionErrorCode.SESSION_BUSY,
+      import_types.ErrorScope.SESSION,
+      import_types.ErrorType.CONFLICT,
+      `Session '${sessionId}' is already processing a message`,
+      { sessionId },
+      "Wait for the current run to finish before starting another one"
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/session/errors.d.ts

@@ -39,5 +39,11 @@ export declare class SessionError {
         sessionId: string;
         reason: string;
     }>;
+    /**
+     * Session already processing a run
+     */
+    static busy(sessionId: string): DextoRuntimeError<{
+        sessionId: string;
+    }>;
 }
 //# sourceMappingURL=errors.d.ts.map

package/dist/session/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/session/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInE;;;GAGG;AACH,qBAAa,YAAY;IACrB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM;;;IAUjC;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAU7D;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;;;;IAWpE;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;;IAUzE;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;CASvD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/session/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInE;;;GAGG;AACH,qBAAa,YAAY;IACrB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM;;;IAUjC;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAU7D;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;;;;IAWpE;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;;IAUzE;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAUpD;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM;;;CAUhC"}

package/dist/session/errors.js

@@ -64,6 +64,19 @@ class SessionError {
       { sessionId, reason }
     );
   }
+  /**
+   * Session already processing a run
+   */
+  static busy(sessionId) {
+    return new DextoRuntimeError(
+      SessionErrorCode.SESSION_BUSY,
+      ErrorScope.SESSION,
+      ErrorType.CONFLICT,
+      `Session '${sessionId}' is already processing a message`,
+      { sessionId },
+      "Wait for the current run to finish before starting another one"
+    );
+  }
 }
 export {
   SessionError

package/dist/session/message-queue-store.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var message_queue_store_exports = {};
+__export(message_queue_store_exports, {
+  MessageQueueStore: () => MessageQueueStore
+});
+module.exports = __toCommonJS(message_queue_store_exports);
+class MessageQueueStore {
+  constructor(storageManager, logger, options = {}) {
+    this.storageManager = storageManager;
+    this.logger = logger;
+    const cacheTtlMs = options.cacheTtlMs ?? 36e5;
+    this.cacheTtlSeconds = Math.max(1, Math.floor(cacheTtlMs / 1e3));
+  }
+  cacheTtlSeconds;
+  buildKey(sessionId) {
+    return `session-message-queue:${sessionId}`;
+  }
+  async load(sessionId) {
+    const key = this.buildKey(sessionId);
+    const cached = await this.storageManager.getCache().get(key);
+    if (Array.isArray(cached)) {
+      return structuredClone(cached);
+    }
+    const stored = await this.storageManager.getDatabase().get(key);
+    if (!Array.isArray(stored)) {
+      if (stored !== void 0) {
+        this.logger.warn("Invalid persisted message queue encountered; ignoring state", {
+          key
+        });
+      }
+      return [];
+    }
+    const cloned = structuredClone(stored);
+    await this.storageManager.getCache().set(key, cloned, this.cacheTtlSeconds);
+    return cloned;
+  }
+  async save(sessionId, queue) {
+    const key = this.buildKey(sessionId);
+    if (queue.length === 0) {
+      await this.delete(sessionId);
+      return;
+    }
+    const cloned = structuredClone(queue);
+    await this.storageManager.getDatabase().set(key, cloned);
+    await this.storageManager.getCache().set(key, cloned, this.cacheTtlSeconds);
+  }
+  async delete(sessionId) {
+    const key = this.buildKey(sessionId);
+    await Promise.all([
+      this.storageManager.getDatabase().delete(key),
+      this.storageManager.getCache().delete(key)
+    ]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MessageQueueStore
+});

package/dist/session/message-queue-store.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '../logger/v2/types.js';
+import type { StorageManager } from '../storage/index.js';
+import type { QueuedMessage } from './types.js';
+export declare class MessageQueueStore {
+    private readonly storageManager;
+    private readonly logger;
+    private readonly cacheTtlSeconds;
+    constructor(storageManager: StorageManager, logger: Logger, options?: {
+        cacheTtlMs?: number;
+    });
+    private buildKey;
+    load(sessionId: string): Promise<QueuedMessage[]>;
+    save(sessionId: string, queue: QueuedMessage[]): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+}
+//# sourceMappingURL=message-queue-store.d.ts.map

package/dist/session/message-queue-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-queue-store.d.ts","sourceRoot":"","sources":["../../src/session/message-queue-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,iBAAiB;IAItB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ3B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAGpB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,MAAM,EAC/B,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;IAMzC,OAAO,CAAC,QAAQ;IAIV,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAsBjD,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9D,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAOjD"}

package/dist/session/message-queue-store.js

@@ -0,0 +1,52 @@
+import "../chunk-PTJYTZNU.js";
+class MessageQueueStore {
+  constructor(storageManager, logger, options = {}) {
+    this.storageManager = storageManager;
+    this.logger = logger;
+    const cacheTtlMs = options.cacheTtlMs ?? 36e5;
+    this.cacheTtlSeconds = Math.max(1, Math.floor(cacheTtlMs / 1e3));
+  }
+  cacheTtlSeconds;
+  buildKey(sessionId) {
+    return `session-message-queue:${sessionId}`;
+  }
+  async load(sessionId) {
+    const key = this.buildKey(sessionId);
+    const cached = await this.storageManager.getCache().get(key);
+    if (Array.isArray(cached)) {
+      return structuredClone(cached);
+    }
+    const stored = await this.storageManager.getDatabase().get(key);
+    if (!Array.isArray(stored)) {
+      if (stored !== void 0) {
+        this.logger.warn("Invalid persisted message queue encountered; ignoring state", {
+          key
+        });
+      }
+      return [];
+    }
+    const cloned = structuredClone(stored);
+    await this.storageManager.getCache().set(key, cloned, this.cacheTtlSeconds);
+    return cloned;
+  }
+  async save(sessionId, queue) {
+    const key = this.buildKey(sessionId);
+    if (queue.length === 0) {
+      await this.delete(sessionId);
+      return;
+    }
+    const cloned = structuredClone(queue);
+    await this.storageManager.getDatabase().set(key, cloned);
+    await this.storageManager.getCache().set(key, cloned, this.cacheTtlSeconds);
+  }
+  async delete(sessionId) {
+    const key = this.buildKey(sessionId);
+    await Promise.all([
+      this.storageManager.getDatabase().delete(key),
+      this.storageManager.getCache().delete(key)
+    ]);
+  }
+}
+export {
+  MessageQueueStore
+};