@dexto/core 1.2.4 → 1.2.6

package/dist/session/chat-session.js

@@ -5,7 +5,7 @@ import {
   SessionEventBus,
   SessionEventNames
 } from "../events/index.js";
-import { logger } from "../logger/index.js";
+import { DextoLogComponent } from "../logger/v2/types.js";
 import { DextoRuntimeError, ErrorScope, ErrorType } from "../errors/index.js";
 import { PluginErrorCode } from "../plugins/error-codes.js";
 class ChatSession {
@@ -19,13 +19,15 @@ class ChatSession {
    *
    * @param services - The shared services from the agent (state manager, prompt, client managers, etc.)
    * @param id - Unique identifier for this session
+   * @param logger - Logger instance for dependency injection
    */
-  constructor(services, id) {
+  constructor(services, id, logger) {
     this.services = services;
     this.id = id;
+    this.logger = logger.createChild(DextoLogComponent.SESSION);
     this.eventBus = new SessionEventBus();
     this.setupEventForwarding();
-    logger.debug(`ChatSession ${this.id}: Created, awaiting initialization`);
+    this.logger.debug(`ChatSession ${this.id}: Created, awaiting initialization`);
   }
   /**
    * Session-scoped event emitter for handling conversation events.
@@ -34,9 +36,9 @@ class ChatSession {
    * to the global agent event bus.
    *
    * Events emitted include:
-   * - `llmservice:thinking` - AI model is processing
-   * - `llmservice:toolCall` - Tool execution requested
-   * - `llmservice:response` - Final response generated
+   * - `llm:thinking` - AI model is processing
+   * - `llm:tool-call` - Tool execution requested
+   * - `llm:response` - Final response generated
    */
   eventBus;
   /**
@@ -61,6 +63,7 @@ class ChatSession {
    * Calling cancel() aborts the in-flight LLM request and tool execution checks.
    */
   currentRunController = null;
+  logger;
   /**
    * Initialize the session services asynchronously.
    * This must be called after construction to set up the storage-backed services.
@@ -80,14 +83,14 @@ class ChatSession {
     SessionEventNames.forEach((eventName) => {
       const forwarder = (payload) => {
         const payloadWithSession = payload && typeof payload === "object" ? { ...payload, sessionId: this.id } : { sessionId: this.id };
-        logger.silly(
-          `Forwarding session event ${eventName} to agent bus with session context: ${JSON.stringify(payloadWithSession, null, 2)}`
-        );
         this.services.agentEventBus.emit(eventName, payloadWithSession);
       };
       this.forwarders.set(eventName, forwarder);
       this.eventBus.on(eventName, forwarder);
     });
+    this.logger.debug(
+      `[setupEventForwarding] Event forwarding setup complete for session=${this.id}`
+    );
   }
   /**
    * Initializes session-specific services.
@@ -96,7 +99,8 @@ class ChatSession {
     const llmConfig = this.services.stateManager.getLLMConfig(this.id);
     this.historyProvider = createDatabaseHistoryProvider(
       this.services.storageManager.getDatabase(),
-      this.id
+      this.id,
+      this.logger
     );
     this.llmService = createLLMService(
       llmConfig,
@@ -108,10 +112,12 @@ class ChatSession {
       this.eventBus,
       // Use session event bus
       this.id,
-      this.services.resourceManager
+      this.services.resourceManager,
       // Pass ResourceManager for blob storage
+      this.logger
+      // Pass logger for dependency injection
     );
-    logger.debug(`ChatSession ${this.id}: Services initialized with storage`);
+    this.logger.debug(`ChatSession ${this.id}: Services initialized with storage`);
   }
   /**
    * Saves a blocked interaction to history when a plugin blocks execution.
@@ -137,7 +143,7 @@ class ChatSession {
     await this.historyProvider.saveMessage(userMessage);
     await this.historyProvider.saveMessage(assistantMessage);
     const llmConfig = this.services.stateManager.getLLMConfig(this.id);
-    this.eventBus.emit("llmservice:response", {
+    this.eventBus.emit("llm:response", {
       content: errorContent,
       provider: llmConfig.provider,
       model: llmConfig.model,
@@ -168,7 +174,7 @@ class ChatSession {
    * ```
    */
   async run(input, imageDataInput, fileDataInput, stream) {
-    logger.debug(
+    this.logger.debug(
       `Running session ${this.id} | input.len=${input?.length ?? 0} | image=${imageDataInput ? imageDataInput.mimeType : "none"} | file=${fileDataInput ? `${fileDataInput.mimeType}:${fileDataInput.filename ?? "unknown"}` : "none"}`
     );
     this.currentRunController = new AbortController();
@@ -226,7 +232,7 @@ class ChatSession {
     } catch (error) {
       const aborted = error instanceof Error && error.name === "AbortError" || typeof error === "object" && error !== null && error.aborted === true;
       if (aborted) {
-        this.eventBus.emit("llmservice:error", {
+        this.eventBus.emit("llm:error", {
           error: new Error("Run cancelled"),
           context: "user_cancelled",
           recoverable: true
@@ -241,14 +247,20 @@ class ChatSession {
             imageDataInput,
             fileDataInput
           );
-          logger.debug(`ChatSession ${this.id}: Saved blocked interaction to history`);
+          this.logger.debug(
+            `ChatSession ${this.id}: Saved blocked interaction to history`
+          );
         } catch (saveError) {
-          logger.warn(
+          this.logger.warn(
             `Failed to save blocked interaction to history: ${saveError instanceof Error ? saveError.message : String(saveError)}`
           );
         }
         return error.message;
       }
+      const errortype = error instanceof Error ? "object" : "string";
+      this.logger.error(
+        `Error in ChatSession.run: errortype=${errortype}: ${error instanceof Error ? error.message : String(error)}`
+      );
       throw error;
     } finally {
       this.currentRunController = null;
@@ -284,7 +296,7 @@ class ChatSession {
    * This method:
    * 1. Clears all messages from the session's conversation history
    * 2. Removes persisted history from the storage provider
-   * 3. Emits a `dexto:conversationReset` event with session context
+   * 3. Emits a `session:reset` event with session context
    *
    * The system prompt and session configuration remain unchanged.
    * Only the conversation messages are cleared.
@@ -301,7 +313,7 @@ class ChatSession {
    */
   async reset() {
     await this.historyProvider.clearHistory();
-    this.services.agentEventBus.emit("dexto:conversationReset", {
+    this.services.agentEventBus.emit("session:reset", {
       sessionId: this.id
     });
   }
@@ -354,19 +366,20 @@ class ChatSession {
         this.eventBus,
         // Use session event bus
         this.id,
-        this.services.resourceManager
+        this.services.resourceManager,
+        this.logger
       );
       this.llmService = newLLMService;
-      logger.info(
+      this.logger.info(
         `ChatSession ${this.id}: LLM switched to ${newLLMConfig.provider}/${newLLMConfig.model}`
       );
-      this.eventBus.emit("llmservice:switched", {
+      this.eventBus.emit("llm:switched", {
         newConfig: newLLMConfig,
         router,
         historyRetained: true
       });
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `Error during ChatSession.switchLLM for session ${this.id}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -380,11 +393,11 @@ class ChatSession {
   async cleanup() {
     try {
       this.dispose();
-      logger.debug(
+      this.logger.debug(
         `ChatSession ${this.id}: Memory cleanup completed (chat history preserved)`
       );
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `Error during ChatSession cleanup for session ${this.id}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -398,12 +411,12 @@ class ChatSession {
    * Without this cleanup, sessions would remain in memory due to listener references.
    */
   dispose() {
-    logger.debug(`Disposing session ${this.id} - cleaning up event listeners`);
+    this.logger.debug(`Disposing session ${this.id} - cleaning up event listeners`);
     this.forwarders.forEach((forwarder, eventName) => {
       this.eventBus.off(eventName, forwarder);
     });
     this.forwarders.clear();
-    logger.debug(`Session ${this.id} disposed successfully`);
+    this.logger.debug(`Session ${this.id} disposed successfully`);
   }
   /**
    * Cancel the currently running turn for this session, if any.

package/dist/session/history/database.cjs

@@ -21,23 +21,25 @@ __export(database_exports, {
   DatabaseHistoryProvider: () => DatabaseHistoryProvider
 });
 module.exports = __toCommonJS(database_exports);
-var import_logger = require("../../logger/index.cjs");
+var import_types = require("../../logger/v2/types.cjs");
 var import_errors = require("../errors.js");
 class DatabaseHistoryProvider {
-  constructor(sessionId, database) {
+  constructor(sessionId, database, logger) {
     this.sessionId = sessionId;
     this.database = database;
+    this.logger = logger.createChild(import_types.DextoLogComponent.SESSION);
   }
+  logger;
   async getHistory() {
     const key = this.getMessagesKey();
     try {
       const messages = await this.database.getRange(key, 0, 1e3);
-      import_logger.logger.debug(
+      this.logger.debug(
         `DatabaseHistoryProvider: Retrieved ${messages.length} messages for session ${this.sessionId}`
       );
       return messages;
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `DatabaseHistoryProvider: Error retrieving messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
       return [];
@@ -55,12 +57,15 @@ class DatabaseHistoryProvider {
           contentPreview = `[${message.content.length} parts]`;
         }
       }
-      import_logger.logger.debug(`DatabaseHistoryProvider: Saved message for session ${this.sessionId}`, {
-        role: message.role,
-        content: contentPreview
-      });
+      this.logger.debug(
+        `DatabaseHistoryProvider: Saved message for session ${this.sessionId}`,
+        {
+          role: message.role,
+          content: contentPreview
+        }
+      );
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `DatabaseHistoryProvider: Error saving message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw import_errors.SessionError.storageFailed(
@@ -74,9 +79,11 @@ class DatabaseHistoryProvider {
     const key = this.getMessagesKey();
     try {
       await this.database.delete(key);
-      import_logger.logger.debug(`DatabaseHistoryProvider: Cleared history for session ${this.sessionId}`);
+      this.logger.debug(
+        `DatabaseHistoryProvider: Cleared history for session ${this.sessionId}`
+      );
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `DatabaseHistoryProvider: Error clearing session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw import_errors.SessionError.resetFailed(

package/dist/session/history/database.d.ts

@@ -1,3 +1,4 @@
+import type { IDextoLogger } from '../../logger/v2/types.js';
 import type { Database } from '../../storage/types.js';
 import type { InternalMessage } from '../../context/types.js';
 import type { IConversationHistoryProvider } from './types.js';
@@ -16,7 +17,8 @@ import type { IConversationHistoryProvider } from './types.js';
 export declare class DatabaseHistoryProvider implements IConversationHistoryProvider {
     private sessionId;
     private database;
-    constructor(sessionId: string, database: Database);
+    private logger;
+    constructor(sessionId: string, database: Database, logger: IDextoLogger);
     getHistory(): Promise<InternalMessage[]>;
     saveMessage(message: InternalMessage): Promise<void>;
     clearHistory(): Promise<void>;

package/dist/session/history/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/session/history/database.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,qBAAa,uBAAwB,YAAW,4BAA4B;IAEpE,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;gBADR,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ;IAGxB,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAmBxC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAkCpD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBnC,OAAO,CAAC,cAAc;CAGzB"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/session/history/database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,qBAAa,uBAAwB,YAAW,4BAA4B;IAIpE,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;IAJpB,OAAO,CAAC,MAAM,CAAe;gBAGjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAC1B,MAAM,EAAE,YAAY;IAKlB,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAmBxC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqCpD,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBnC,OAAO,CAAC,cAAc;CAGzB"}

package/dist/session/history/database.js

@@ -1,21 +1,23 @@
 import "../../chunk-C6A6W6XS.js";
-import { logger } from "../../logger/index.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
 import { SessionError } from "../errors.js";
 class DatabaseHistoryProvider {
-  constructor(sessionId, database) {
+  constructor(sessionId, database, logger) {
     this.sessionId = sessionId;
     this.database = database;
+    this.logger = logger.createChild(DextoLogComponent.SESSION);
   }
+  logger;
   async getHistory() {
     const key = this.getMessagesKey();
     try {
       const messages = await this.database.getRange(key, 0, 1e3);
-      logger.debug(
+      this.logger.debug(
         `DatabaseHistoryProvider: Retrieved ${messages.length} messages for session ${this.sessionId}`
       );
       return messages;
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `DatabaseHistoryProvider: Error retrieving messages for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
       return [];
@@ -33,12 +35,15 @@ class DatabaseHistoryProvider {
           contentPreview = `[${message.content.length} parts]`;
         }
       }
-      logger.debug(`DatabaseHistoryProvider: Saved message for session ${this.sessionId}`, {
-        role: message.role,
-        content: contentPreview
-      });
+      this.logger.debug(
+        `DatabaseHistoryProvider: Saved message for session ${this.sessionId}`,
+        {
+          role: message.role,
+          content: contentPreview
+        }
+      );
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `DatabaseHistoryProvider: Error saving message for session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw SessionError.storageFailed(
@@ -52,9 +57,11 @@ class DatabaseHistoryProvider {
     const key = this.getMessagesKey();
     try {
       await this.database.delete(key);
-      logger.debug(`DatabaseHistoryProvider: Cleared history for session ${this.sessionId}`);
+      this.logger.debug(
+        `DatabaseHistoryProvider: Cleared history for session ${this.sessionId}`
+      );
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `DatabaseHistoryProvider: Error clearing session ${this.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw SessionError.resetFailed(

package/dist/session/history/factory.cjs

@@ -22,8 +22,8 @@ __export(factory_exports, {
 });
 module.exports = __toCommonJS(factory_exports);
 var import_database = require("./database.js");
-function createDatabaseHistoryProvider(database, sessionId) {
-  return new import_database.DatabaseHistoryProvider(sessionId, database);
+function createDatabaseHistoryProvider(database, sessionId, logger) {
+  return new import_database.DatabaseHistoryProvider(sessionId, database, logger);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/session/history/factory.d.ts

@@ -1,7 +1,11 @@
 import type { IConversationHistoryProvider } from './types.js';
 import type { Database } from '../../storage/types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Create a history provider directly with database backend
+ * @param database Database instance
+ * @param sessionId Session ID
+ * @param logger Logger instance for logging
  */
-export declare function createDatabaseHistoryProvider(database: Database, sessionId: string): IConversationHistoryProvider;
+export declare function createDatabaseHistoryProvider(database: Database, sessionId: string, logger: IDextoLogger): IConversationHistoryProvider;
 //# sourceMappingURL=factory.d.ts.map

package/dist/session/history/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/session/history/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGvD;;GAEG;AACH,wBAAgB,6BAA6B,CACzC,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,GAClB,4BAA4B,CAE9B"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/session/history/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D;;;;;GAKG;AACH,wBAAgB,6BAA6B,CACzC,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,GACrB,4BAA4B,CAE9B"}

package/dist/session/history/factory.js

@@ -1,7 +1,7 @@
 import "../../chunk-C6A6W6XS.js";
 import { DatabaseHistoryProvider } from "./database.js";
-function createDatabaseHistoryProvider(database, sessionId) {
-  return new DatabaseHistoryProvider(sessionId, database);
+function createDatabaseHistoryProvider(database, sessionId, logger) {
+  return new DatabaseHistoryProvider(sessionId, database, logger);
 }
 export {
   createDatabaseHistoryProvider

package/dist/session/session-manager.cjs

@@ -23,13 +23,14 @@ __export(session_manager_exports, {
 module.exports = __toCommonJS(session_manager_exports);
 var import_crypto = require("crypto");
 var import_chat_session = require("./chat-session.js");
-var import_logger = require("../logger/index.js");
+var import_types = require("../logger/v2/types.js");
 var import_errors = require("./errors.js");
 class SessionManager {
-  constructor(services, config = {}) {
+  constructor(services, config = {}, logger) {
     this.services = services;
     this.maxSessions = config.maxSessions ?? 100;
     this.sessionTTL = config.sessionTTL ?? 36e5;
+    this.logger = logger.createChild(import_types.DextoLogComponent.SESSION);
   }
   sessions = /* @__PURE__ */ new Map();
   maxSessions;
@@ -39,6 +40,7 @@ class SessionManager {
   initializationPromise;
   // Add a Map to track ongoing session creation operations to prevent race conditions
   pendingCreations = /* @__PURE__ */ new Map();
+  logger;
   /**
    * Initialize the SessionManager with persistent storage.
    * This must be called before using any session operations.
@@ -51,12 +53,12 @@ class SessionManager {
     const cleanupIntervalMs = Math.min(this.sessionTTL / 4, 15 * 60 * 1e3);
     this.cleanupInterval = setInterval(
       () => this.cleanupExpiredSessions().catch(
-        (err) => import_logger.logger.error(`Periodic session cleanup failed: ${err}`)
+        (err) => this.logger.error(`Periodic session cleanup failed: ${err}`)
       ),
       cleanupIntervalMs
     );
     this.initialized = true;
-    import_logger.logger.debug(
+    this.logger.debug(
       `SessionManager initialized with periodic cleanup every ${Math.round(cleanupIntervalMs / 1e3 / 60)} minutes`
     );
   }
@@ -67,7 +69,7 @@ class SessionManager {
   async restoreSessionsFromStorage() {
     try {
       const sessionKeys = await this.services.storageManager.getDatabase().list("session:");
-      import_logger.logger.debug(`Found ${sessionKeys.length} persisted sessions to restore`);
+      this.logger.debug(`Found ${sessionKeys.length} persisted sessions to restore`);
       for (const sessionKey of sessionKeys) {
         const sessionId = sessionKey.replace("session:", "");
         const sessionData = await this.services.storageManager.getDatabase().get(sessionKey);
@@ -75,15 +77,15 @@ class SessionManager {
           const now = Date.now();
           const lastActivity = sessionData.lastActivity;
           if (now - lastActivity <= this.sessionTTL) {
-            import_logger.logger.debug(`Session ${sessionId} restored from storage`);
+            this.logger.debug(`Session ${sessionId} restored from storage`);
           } else {
             await this.services.storageManager.getDatabase().delete(sessionKey);
-            import_logger.logger.debug(`Expired session ${sessionId} cleaned up during restore`);
+            this.logger.debug(`Expired session ${sessionId} cleaned up during restore`);
           }
         }
       }
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to restore sessions from storage: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -135,10 +137,14 @@ class SessionManager {
     const existingMetadata = await this.services.storageManager.getDatabase().get(sessionKey);
     if (existingMetadata) {
       await this.updateSessionActivity(id);
-      const session2 = new import_chat_session.ChatSession({ ...this.services, sessionManager: this }, id);
+      const session2 = new import_chat_session.ChatSession(
+        { ...this.services, sessionManager: this },
+        id,
+        this.logger
+      );
       await session2.init();
       this.sessions.set(id, session2);
-      import_logger.logger.info(`Restored session from storage: ${id}`, null, "cyan");
+      this.logger.info(`Restored session from storage: ${id}`);
       return session2;
     }
     const activeSessionKeys = await this.services.storageManager.getDatabase().list("session:");
@@ -154,19 +160,21 @@ class SessionManager {
     try {
       await this.services.storageManager.getDatabase().set(sessionKey, sessionData);
     } catch (error) {
-      import_logger.logger.error(`Failed to store session metadata for ${id}:`, error);
+      this.logger.error(`Failed to store session metadata for ${id}:`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
       throw error;
     }
     let session;
     try {
-      session = new import_chat_session.ChatSession({ ...this.services, sessionManager: this }, id);
+      session = new import_chat_session.ChatSession({ ...this.services, sessionManager: this }, id, this.logger);
       await session.init();
       this.sessions.set(id, session);
       await this.services.storageManager.getCache().set(sessionKey, sessionData, this.sessionTTL / 1e3);
-      import_logger.logger.info(`Created new session: ${id}`, null, "green");
+      this.logger.info(`Created new session: ${id}`);
       return session;
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to initialize session ${id}: ${error instanceof Error ? error.message : String(error)}`
       );
       await this.services.storageManager.getDatabase().delete(sessionKey);
@@ -175,16 +183,6 @@ class SessionManager {
       throw import_errors.SessionError.initializationFailed(id, reason);
     }
   }
-  /**
-   * Gets or creates the default session.
-   * This is used for backward compatibility with single-session operations.
-   *
-   * @returns The default ChatSession (creates one if it doesn't exist)
-   */
-  async getDefaultSession() {
-    const defaultSessionId = "default";
-    return await this.createSession(defaultSessionId);
-  }
   /**
    * Retrieves an existing session by ID.
    *
@@ -206,7 +204,8 @@ class SessionManager {
       if (sessionData) {
         const session = new import_chat_session.ChatSession(
           { ...this.services, sessionManager: this },
-          sessionId
+          sessionId,
+          this.logger
         );
         await session.init();
         this.sessions.set(sessionId, session);
@@ -230,7 +229,9 @@ class SessionManager {
     }
     const sessionKey = `session:${sessionId}`;
     await this.services.storageManager.getCache().delete(sessionKey);
-    import_logger.logger.debug(`Ended session (removed from memory, chat history preserved): ${sessionId}`);
+    this.logger.debug(
+      `Ended session (removed from memory, chat history preserved): ${sessionId}`
+    );
   }
   /**
    * Deletes a session and its conversation history, removing everything from memory and storage.
@@ -249,7 +250,7 @@ class SessionManager {
     const sessionKey = `session:${sessionId}`;
     await this.services.storageManager.getDatabase().delete(sessionKey);
     await this.services.storageManager.getCache().delete(sessionKey);
-    import_logger.logger.debug(`Deleted session and conversation history: ${sessionId}`);
+    this.logger.debug(`Deleted session and conversation history: ${sessionId}`);
   }
   /**
    * Resets the conversation history for a session while keeping the session alive.
@@ -272,7 +273,7 @@ class SessionManager {
       await this.services.storageManager.getDatabase().set(sessionKey, sessionData);
       await this.services.storageManager.getCache().set(sessionKey, sessionData, this.sessionTTL / 1e3);
     }
-    import_logger.logger.debug(`Reset session conversation: ${sessionId}`);
+    this.logger.debug(`Reset session conversation: ${sessionId}`);
   }
   /**
    * Lists all active session IDs.
@@ -385,13 +386,13 @@ class SessionManager {
       if (session) {
         session.dispose();
         this.sessions.delete(sessionId);
-        import_logger.logger.debug(
+        this.logger.debug(
           `Removed expired session from memory: ${sessionId} (chat history preserved)`
         );
       }
     }
     if (expiredSessions.length > 0) {
-      import_logger.logger.debug(
+      this.logger.debug(
         `Memory cleanup: removed ${expiredSessions.length} inactive sessions, chat history preserved`
       );
     }
@@ -413,13 +414,13 @@ class SessionManager {
           await session.switchLLM(newLLMConfig);
         } catch (error) {
           failedSessions.push(sId);
-          import_logger.logger.warn(
+          this.logger.warn(
             `Error switching LLM for session ${sId}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
     }
-    this.services.agentEventBus.emit("dexto:llmSwitched", {
+    this.services.agentEventBus.emit("llm:switched", {
       newConfig: newLLMConfig,
       router: newLLMConfig.router,
       historyRetained: true,
@@ -441,7 +442,7 @@ class SessionManager {
       throw import_errors.SessionError.notFound(sessionId);
     }
     await session.switchLLM(newLLMConfig);
-    this.services.agentEventBus.emit("dexto:llmSwitched", {
+    this.services.agentEventBus.emit("llm:switched", {
       newConfig: newLLMConfig,
       router: newLLMConfig.router,
       historyRetained: true,
@@ -450,23 +451,6 @@ class SessionManager {
     const message = `Successfully switched to ${newLLMConfig.provider}/${newLLMConfig.model} using ${newLLMConfig.router} router for session ${sessionId}`;
     return { message, warnings: [] };
   }
-  /**
-   * Switch LLM for the default session.
-   * @param newLLMConfig The new LLM configuration to apply
-   * @returns Result object with success message and any warnings
-   */
-  async switchLLMForDefaultSession(newLLMConfig) {
-    const defaultSession = await this.getDefaultSession();
-    await defaultSession.switchLLM(newLLMConfig);
-    this.services.agentEventBus.emit("dexto:llmSwitched", {
-      newConfig: newLLMConfig,
-      router: newLLMConfig.router,
-      historyRetained: true,
-      sessionIds: [defaultSession.id]
-    });
-    const message = `Successfully switched to ${newLLMConfig.provider}/${newLLMConfig.model} using ${newLLMConfig.router} router`;
-    return { message, warnings: [] };
-  }
   /**
    * Get session statistics for monitoring and debugging.
    */
@@ -492,21 +476,21 @@ class SessionManager {
     if (this.cleanupInterval) {
       clearInterval(this.cleanupInterval);
       delete this.cleanupInterval;
-      import_logger.logger.debug("Periodic session cleanup stopped");
+      this.logger.debug("Periodic session cleanup stopped");
     }
     const sessionIds = Array.from(this.sessions.keys());
     for (const sessionId of sessionIds) {
       try {
         await this.endSession(sessionId);
       } catch (error) {
-        import_logger.logger.error(
+        this.logger.error(
           `Failed to cleanup session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
     this.sessions.clear();
     this.initialized = false;
-    import_logger.logger.debug("SessionManager cleanup completed");
+    this.logger.debug("SessionManager cleanup completed");
   }
 }
 // Annotate the CommonJS export names for ESM import in node: