@dexto/core 1.7.2 → 1.8.1

package/dist/session/chat-session.js

@@ -1,6 +1,5 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 import { randomUUID } from "crypto";
-import { createDatabaseHistoryProvider } from "./history/factory.js";
 import { createLLMService } from "../llm/services/factory.js";
 import {
   SessionEventBus,
@@ -10,7 +9,11 @@ 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 {
+  getUsagePricingMetadata,
+  hasMeaningfulTokenUsage,
+  normalizeTokenUsageForAccounting
+} from "../llm/usage-metadata.js";
 import { parseCodexBaseURL } from "../llm/providers/codex-base-url.js";
 import { SessionError } from "./errors.js";
 class ChatSession {
@@ -18,7 +21,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)
    *
@@ -31,11 +34,19 @@ class ChatSession {
     this.id = id;
     this.logger = logger.createChild(DextoLogComponent.SESSION);
     this.eventBus = new SessionEventBus();
-    this.messageQueue = new MessageQueueService(
+    this.steerQueue = new MessageQueueService(
       this.eventBus,
       this.logger,
       this.id,
-      this.services.messageQueueStore
+      this.services.steerQueueStore,
+      "steer"
+    );
+    this.followUpQueue = new MessageQueueService(
+      this.eventBus,
+      this.logger,
+      this.id,
+      this.services.followUpQueueStore,
+      "follow-up"
     );
     this.setupTokenAccumulation();
     this.logger.debug(`ChatSession ${this.id}: Created, awaiting initialization`);
@@ -53,10 +64,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.
    *
@@ -65,10 +76,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.
@@ -109,9 +121,10 @@ class ChatSession {
   setupTokenAccumulation() {
     this.tokenAccumulatorListener = (payload) => {
       if (payload.tokenUsage) {
+        const tokenUsage = normalizeTokenUsageForAccounting(payload.tokenUsage);
         const llmConfig = this.services.stateManager.getLLMConfig(this.id);
         const isChatGPTLogin = llmConfig.provider === "openai-compatible" && parseCodexBaseURL(llmConfig.baseURL)?.authMode === "chatgpt";
-        const hasMeaningfulUsage = hasMeaningfulTokenUsage(payload.tokenUsage);
+        const hasMeaningfulUsage = hasMeaningfulTokenUsage(tokenUsage);
         if (isChatGPTLogin && !hasMeaningfulUsage) {
           this.services.sessionManager.markUntrackedChatGPTLoginUsage(this.id).catch((err) => {
             this.logger.warn(
@@ -127,11 +140,11 @@ class ChatSession {
         const pricingMetadata = 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) => {
@@ -149,12 +162,9 @@ class ChatSession {
   async initializeServices() {
     const runtimeConfig = this.services.stateManager.getRuntimeConfig(this.id);
     const llmConfig = runtimeConfig.llm;
-    await this.messageQueue.initialize();
-    this.historyProvider = 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`);
   }
@@ -164,13 +174,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 createLLMService(
       llmConfig,
       this.services.toolManager,
       this.services.systemPromptManager,
-      this.historyProvider,
+      this.conversationStore,
       this.eventBus,
       this.id,
       this.services.resourceManager,
@@ -205,8 +216,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,
@@ -215,6 +226,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.
@@ -237,15 +325,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 SessionError.busy(this.id);
     }
@@ -253,70 +333,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;
@@ -370,6 +397,94 @@ class ChatSession {
       this.currentRunController = null;
     }
   }
+  async createTurnDriver(input) {
+    if (this.isBusy()) {
+      throw 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 DextoRuntimeError && error.code === HookErrorCode.HOOK_BLOCKED_EXECUTION && error.scope === ErrorScope.HOOK && error.type === 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.
    */
@@ -405,7 +520,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.
@@ -533,40 +648,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.

package/dist/session/error-codes.js

@@ -1,4 +1,4 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 var SessionErrorCode = /* @__PURE__ */ ((SessionErrorCode2) => {
   SessionErrorCode2["SESSION_NOT_FOUND"] = "session_not_found";
   SessionErrorCode2["SESSION_INITIALIZATION_FAILED"] = "session_initialization_failed";

package/dist/session/errors.js

@@ -1,4 +1,4 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { SessionErrorCode } from "./error-codes.js";

package/dist/session/index.cjs

@@ -19,11 +19,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var session_exports = {};
 __export(session_exports, {
   ChatSession: () => import_chat_session.ChatSession,
+  CoalescedMessageSchema: () => import_types.CoalescedMessageSchema,
   MessageQueueService: () => import_message_queue.MessageQueueService,
+  ModelStatisticsSchema: () => import_schemas.ModelStatisticsSchema,
+  QueuedMessageSchema: () => import_types.QueuedMessageSchema,
+  QueuedMessagesSchema: () => import_types.QueuedMessagesSchema,
   SessionConfigSchema: () => import_schemas.SessionConfigSchema,
+  SessionDataSchema: () => import_schemas.SessionDataSchema,
   SessionError: () => import_errors.SessionError,
   SessionErrorCode: () => import_error_codes.SessionErrorCode,
-  SessionManager: () => import_session_manager.SessionManager
+  SessionManager: () => import_session_manager.SessionManager,
+  SessionTokenUsageSchema: () => import_schemas.SessionTokenUsageSchema,
+  SessionUsageTrackingSchema: () => import_schemas.SessionUsageTrackingSchema,
+  parseSessionData: () => import_schemas.parseSessionData
 });
 module.exports = __toCommonJS(session_exports);
 var import_chat_session = require("./chat-session.js");
@@ -31,13 +39,22 @@ var import_session_manager = require("./session-manager.js");
 var import_error_codes = require("./error-codes.js");
 var import_errors = require("./errors.js");
 var import_message_queue = require("./message-queue.js");
+var import_types = require("./types.js");
 var import_schemas = require("./schemas.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChatSession,
+  CoalescedMessageSchema,
   MessageQueueService,
+  ModelStatisticsSchema,
+  QueuedMessageSchema,
+  QueuedMessagesSchema,
   SessionConfigSchema,
+  SessionDataSchema,
   SessionError,
   SessionErrorCode,
-  SessionManager
+  SessionManager,
+  SessionTokenUsageSchema,
+  SessionUsageTrackingSchema,
+  parseSessionData
 });

package/dist/session/index.d.ts

@@ -1,11 +1,12 @@
-export { ChatSession } from './chat-session.js';
+export { ChatSession, type ChatSessionTurnDriverInput } from './chat-session.js';
 export { SessionManager } from './session-manager.js';
-export type { SessionMetadata, SessionLoggerFactory } from './session-manager.js';
+export type { ModelStatistics, SessionData, SessionLoggerFactory, SessionMetadata, SessionTokenUsage, SessionUsageTracking, } from './session-manager.js';
 export { SessionErrorCode } from './error-codes.js';
 export { SessionError } from './errors.js';
 export { MessageQueueService } from './message-queue.js';
 export type { UserMessageInput } from './message-queue.js';
+export { CoalescedMessageSchema, QueuedMessageSchema, QueuedMessagesSchema } from './types.js';
 export type { QueuedMessage, CoalescedMessage } from './types.js';
-export { SessionConfigSchema } from './schemas.js';
+export { ModelStatisticsSchema, SessionConfigSchema, SessionDataSchema, SessionTokenUsageSchema, SessionUsageTrackingSchema, parseSessionData, } from './schemas.js';
 export type { SessionConfig, ValidatedSessionConfig } from './schemas.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EACR,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC/F,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EACH,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,0BAA0B,EAC1B,gBAAgB,GACnB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC"}

package/dist/session/index.js

@@ -1,15 +1,31 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 import { ChatSession } from "./chat-session.js";
 import { SessionManager } from "./session-manager.js";
 import { SessionErrorCode } from "./error-codes.js";
 import { SessionError } from "./errors.js";
 import { MessageQueueService } from "./message-queue.js";
-import { SessionConfigSchema } from "./schemas.js";
+import { CoalescedMessageSchema, QueuedMessageSchema, QueuedMessagesSchema } from "./types.js";
+import {
+  ModelStatisticsSchema,
+  SessionConfigSchema,
+  SessionDataSchema,
+  SessionTokenUsageSchema,
+  SessionUsageTrackingSchema,
+  parseSessionData
+} from "./schemas.js";
 export {
   ChatSession,
+  CoalescedMessageSchema,
   MessageQueueService,
+  ModelStatisticsSchema,
+  QueuedMessageSchema,
+  QueuedMessagesSchema,
   SessionConfigSchema,
+  SessionDataSchema,
   SessionError,
   SessionErrorCode,
-  SessionManager
+  SessionManager,
+  SessionTokenUsageSchema,
+  SessionUsageTrackingSchema,
+  parseSessionData
 };