indusagi-coding-agent 0.1.42 → 0.1.43

package/dist/runtime/agent-session.js

@@ -220,8 +220,10 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { isContextOverflow, modelsAreEqual, resetApiProviders, supportsXhigh } from "indusagi/ai";
+import { AgentEventObserveAdapter } from "../observe.js";
 import { getAgentDir, getDocsPath } from "../config.js";
 import { theme } from "../interfaces/terminal-ui/theme/theme.js";
+import { runObserveOperation } from "./observe.js";
 import { stripFrontmatter } from "../helpers/frontmatter.js";
 import { sleep } from "../helpers/sleep.js";
 import { executeBash as executeBashCommand, executeBashWithOperations } from "./bash-executor.js";
@@ -342,6 +344,7 @@ export class AgentSession {
         this._subagentStore = new SubagentStore({ cwd: this._cwd, agentDir: this._agentDir });
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._hookRunnerRef = config.hookRunnerRef;
+        this._observe = config.observe;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._baseToolsOverride = config.baseToolsOverride;
         this._wireAgentEventHandlers();
@@ -354,6 +357,27 @@ export class AgentSession {
     get modelRegistry() {
         return this._modelRegistry;
     }
+    async initializeObserve() {
+        if (!this._observe)
+            return;
+        await this._observe.initializeSession(this._getObserveSessionSnapshot());
+        if (!this._observeAgentEventsUnsubscribe) {
+            const adapter = new AgentEventObserveAdapter({
+                sink: this._observe.sink,
+                includeMessageText: this._observe.captureAgentEventText,
+            });
+            this._observeAgentEventsUnsubscribe = adapter.attach(this.agent);
+        }
+        await this._observe.log({
+            sessionId: this.sessionId,
+            name: "session.initialize",
+            summary: "observe session initialized",
+            attributes: {
+                sessionFile: this.sessionFile,
+                activeToolCount: this.getActiveToolNames().length,
+            },
+        });
+    }
     // =========================================================================
     // Event Subscription
     // =========================================================================
@@ -431,6 +455,42 @@ export class AgentSession {
             this._retryPromise = undefined;
         }
     }
+    _getObserveSessionSnapshot() {
+        return {
+            id: this.sessionId,
+            cwd: this._cwd,
+            sessionFile: this.sessionFile,
+            model: this.model ? { provider: this.model.provider, id: this.model.id } : undefined,
+            activeToolNames: this.getActiveToolNames(),
+        };
+    }
+    async _refreshObserveSession() {
+        await this._observe?.initializeSession(this._getObserveSessionSnapshot());
+    }
+    async _endObserveSession(sessionId, status = "ended") {
+        await this._observe?.endSession(sessionId, status);
+    }
+    async _logObserve(options) {
+        await this._observe?.log({
+            sessionId: this.sessionId,
+            ...options,
+        });
+    }
+    async _runObserveOperation(name, kind, fn, options = {}) {
+        return runObserveOperation(this._observe, {
+            sessionId: this.sessionId,
+            name,
+            kind,
+            input: options.input,
+            attributes: {
+                sessionFile: this.sessionFile,
+                modelId: this.model?.id,
+                provider: this.model?.provider,
+                ...options.attributes,
+            },
+            output: options.output,
+        }, fn);
+    }
     /** Extract text content from a message */
     _getUserMessageText(message) {
         if (message.role !== "user")
@@ -532,6 +592,8 @@ export class AgentSession {
      */
     dispose() {
         this._disconnectFromAgent();
+        this._observeAgentEventsUnsubscribe?.();
+        this._observeAgentEventsUnsubscribe = undefined;
         this._eventListeners = [];
     }
     // =========================================================================
@@ -786,8 +848,21 @@ export class AgentSession {
                 this.agent.setSystemPrompt(this._baseSystemPrompt);
             }
         }
+        await this._logObserve({
+            name: "session.prompt",
+            summary: "prompt submitted to agent",
+            attributes: {
+                textLength: expandedText.length,
+                imageCount: currentImages?.length ?? 0,
+                pendingNextTurnMessages: messages.length - 1,
+            },
+            data: {
+                imageCount: currentImages?.length ?? 0,
+            },
+        });
         await this.agent.prompt(messages);
         await this.waitForRetry();
+        await this._refreshObserveSession();
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -1044,38 +1119,55 @@ export class AgentSession {
      * @returns true if completed, false if cancelled by extension
      */
     async newSession(options) {
-        const previousSessionFile = this.sessionFile;
-        // Emit session_before_switch event with reason "new" (can be cancelled)
-        if (this._extensionRunner?.hasHandlers("session_before_switch")) {
-            const result = (await this._extensionRunner.emit({
-                type: "session_before_switch",
-                reason: "new",
-            }));
-            if (result?.cancel) {
-                return false;
+        return this._runObserveOperation("session.new", "session_switch", async () => {
+            const previousSessionFile = this.sessionFile;
+            const previousSessionId = this.sessionId;
+            // Emit session_before_switch event with reason "new" (can be cancelled)
+            if (this._extensionRunner?.hasHandlers("session_before_switch")) {
+                const result = (await this._extensionRunner.emit({
+                    type: "session_before_switch",
+                    reason: "new",
+                }));
+                if (result?.cancel) {
+                    return false;
+                }
             }
-        }
-        this._disconnectFromAgent();
-        await this.abort();
-        this.agent.reset();
-        this.sessionManager.newSession(options);
-        this._rebuildTodoStore();
-        this.agent.sessionId = this.sessionManager.getSessionId();
-        this._memoryThreadId = this.sessionManager.getSessionId();
-        this._steeringMessages = [];
-        this._followUpMessages = [];
-        this._pendingNextTurnMessages = [];
-        this._reconnectToAgent();
-        // Emit session_switch event with reason "new" to extensions
-        if (this._extensionRunner) {
-            await this._extensionRunner.emit({
-                type: "session_switch",
-                reason: "new",
-                previousSessionFile,
+            this._disconnectFromAgent();
+            await this.abort();
+            this.agent.reset();
+            this.sessionManager.newSession(options);
+            this._rebuildTodoStore();
+            this.agent.sessionId = this.sessionManager.getSessionId();
+            this._memoryThreadId = this.sessionManager.getSessionId();
+            this._steeringMessages = [];
+            this._followUpMessages = [];
+            this._pendingNextTurnMessages = [];
+            this._reconnectToAgent();
+            await this._endObserveSession(previousSessionId);
+            await this._refreshObserveSession();
+            await this._logObserve({
+                name: "session.new",
+                summary: "created new session",
+                attributes: {
+                    previousSessionId,
+                    previousSessionFile,
+                },
             });
-        }
-        // Emit session event to custom tools
-        return true;
+            // Emit session_switch event with reason "new" to extensions
+            if (this._extensionRunner) {
+                await this._extensionRunner.emit({
+                    type: "session_switch",
+                    reason: "new",
+                    previousSessionFile,
+                });
+            }
+            return true;
+        }, {
+            attributes: {
+                previousSessionFile: this.sessionFile,
+            },
+            output: (completed) => ({ completed }),
+        });
     }
     // =========================================================================
     // Model Management
@@ -1905,31 +1997,57 @@ export class AgentSession {
      * @param options.operations Custom BashOperations for remote execution
      */
     async executeBash(command, onChunk, options) {
-        this._bashAbortController = new AbortController();
-        // Apply command prefix if configured (e.g., "shopt -s expand_aliases" for alias support)
-        const prefix = this.settingsManager.getShellCommandPrefix();
-        const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
-        const hookEnv = this._hookRunner?.hasHandlers("shell.env")
-            ? (await this._hookRunner.trigger("shell.env", { cwd: process.cwd() }, { env: {} })).env
-            : undefined;
-        try {
-            const result = options?.operations
-                ? await executeBashWithOperations(resolvedCommand, process.cwd(), options.operations, {
-                    onChunk,
-                    signal: this._bashAbortController.signal,
-                    env: hookEnv,
-                })
-                : await executeBashCommand(resolvedCommand, {
-                    onChunk,
-                    signal: this._bashAbortController.signal,
-                    env: hookEnv,
+        return this._runObserveOperation("session.execute_bash", "command_execution", async () => {
+            this._bashAbortController = new AbortController();
+            // Apply command prefix if configured (e.g., "shopt -s expand_aliases" for alias support)
+            const prefix = this.settingsManager.getShellCommandPrefix();
+            const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
+            const hookEnv = this._hookRunner?.hasHandlers("shell.env")
+                ? (await this._hookRunner.trigger("shell.env", { cwd: process.cwd() }, { env: {} })).env
+                : undefined;
+            try {
+                const result = options?.operations
+                    ? await executeBashWithOperations(resolvedCommand, process.cwd(), options.operations, {
+                        onChunk,
+                        signal: this._bashAbortController.signal,
+                        env: hookEnv,
+                    })
+                    : await executeBashCommand(resolvedCommand, {
+                        onChunk,
+                        signal: this._bashAbortController.signal,
+                        env: hookEnv,
+                    });
+                this.recordBashResult(command, result, options);
+                await this._logObserve({
+                    name: "session.execute_bash",
+                    summary: "bash command completed",
+                    attributes: {
+                        commandLength: command.length,
+                        exitCode: result.exitCode,
+                        cancelled: result.cancelled,
+                        truncated: result.truncated,
+                        excludeFromContext: options?.excludeFromContext ?? false,
+                    },
                 });
-            this.recordBashResult(command, result, options);
-            return result;
-        }
-        finally {
-            this._bashAbortController = undefined;
-        }
+                return result;
+            }
+            finally {
+                this._bashAbortController = undefined;
+            }
+        }, {
+            input: {
+                commandLength: command.length,
+                excludeFromContext: options?.excludeFromContext ?? false,
+            },
+            attributes: {
+                hasCustomOperations: !!options?.operations,
+            },
+            output: (result) => ({
+                exitCode: result.exitCode,
+                cancelled: result.cancelled,
+                truncated: result.truncated,
+            }),
+        });
     }
     /**
      * Record a bash execution result in session history.
@@ -1998,56 +2116,72 @@ export class AgentSession {
      * @returns true if switch completed, false if cancelled by extension
      */
     async switchSession(sessionPath) {
-        const previousSessionFile = this.sessionManager.getSessionFile();
-        // Emit session_before_switch event (can be cancelled)
-        if (this._extensionRunner?.hasHandlers("session_before_switch")) {
-            const result = (await this._extensionRunner.emit({
-                type: "session_before_switch",
-                reason: "resume",
-                targetSessionFile: sessionPath,
-            }));
-            if (result?.cancel) {
-                return false;
+        return this._runObserveOperation("session.switch", "session_switch", async () => {
+            const previousSessionFile = this.sessionManager.getSessionFile();
+            const previousSessionId = this.sessionId;
+            // Emit session_before_switch event (can be cancelled)
+            if (this._extensionRunner?.hasHandlers("session_before_switch")) {
+                const result = (await this._extensionRunner.emit({
+                    type: "session_before_switch",
+                    reason: "resume",
+                    targetSessionFile: sessionPath,
+                }));
+                if (result?.cancel) {
+                    return false;
+                }
             }
-        }
-        this._disconnectFromAgent();
-        await this.abort();
-        this._steeringMessages = [];
-        this._followUpMessages = [];
-        this._pendingNextTurnMessages = [];
-        // Set new session
-        this.sessionManager.setSessionFile(sessionPath);
-        this._rebuildTodoStore();
-        this.agent.sessionId = this.sessionManager.getSessionId();
-        this._memoryThreadId = this.sessionManager.getSessionId();
-        // Reload messages
-        const sessionContext = this.sessionManager.buildSessionContext();
-        // Emit session_switch event to extensions
-        if (this._extensionRunner) {
-            await this._extensionRunner.emit({
-                type: "session_switch",
-                reason: "resume",
-                previousSessionFile,
-            });
-        }
-        // Emit session event to custom tools
-        this.agent.replaceMessages(sessionContext.messages);
-        // Restore model if saved
-        if (sessionContext.model) {
-            const previousModel = this.model;
-            const availableModels = await this._modelRegistry.getAvailable();
-            const match = availableModels.find((m) => m.provider === sessionContext.model.provider && m.id === sessionContext.model.modelId);
-            if (match) {
-                this.agent.setModel(match);
-                await this._emitModelSelect(match, previousModel, "restore");
+            this._disconnectFromAgent();
+            await this.abort();
+            this._steeringMessages = [];
+            this._followUpMessages = [];
+            this._pendingNextTurnMessages = [];
+            // Set new session
+            this.sessionManager.setSessionFile(sessionPath);
+            this._rebuildTodoStore();
+            this.agent.sessionId = this.sessionManager.getSessionId();
+            this._memoryThreadId = this.sessionManager.getSessionId();
+            // Reload messages
+            const sessionContext = this.sessionManager.buildSessionContext();
+            // Emit session_switch event to extensions
+            if (this._extensionRunner) {
+                await this._extensionRunner.emit({
+                    type: "session_switch",
+                    reason: "resume",
+                    previousSessionFile,
+                });
             }
-        }
-        // Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
-        if (sessionContext.thinkingLevel) {
-            this.setThinkingLevel(sessionContext.thinkingLevel);
-        }
-        this._reconnectToAgent();
-        return true;
+            this.agent.replaceMessages(sessionContext.messages);
+            // Restore model if saved
+            if (sessionContext.model) {
+                const previousModel = this.model;
+                const availableModels = await this._modelRegistry.getAvailable();
+                const match = availableModels.find((m) => m.provider === sessionContext.model.provider && m.id === sessionContext.model.modelId);
+                if (match) {
+                    this.agent.setModel(match);
+                    await this._emitModelSelect(match, previousModel, "restore");
+                }
+            }
+            // Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
+            if (sessionContext.thinkingLevel) {
+                this.setThinkingLevel(sessionContext.thinkingLevel);
+            }
+            this._reconnectToAgent();
+            await this._endObserveSession(previousSessionId);
+            await this._refreshObserveSession();
+            await this._logObserve({
+                name: "session.switch",
+                summary: "switched session",
+                attributes: {
+                    previousSessionId,
+                    previousSessionFile,
+                    targetSessionFile: sessionPath,
+                },
+            });
+            return true;
+        }, {
+            input: { targetSessionFile: sessionPath },
+            output: (completed) => ({ completed }),
+        });
     }
     /**
      * Create a fork from a specific entry.
@@ -2059,49 +2193,66 @@ export class AgentSession {
      *   - cancelled: True if an extension cancelled the fork
      */
     async fork(entryId) {
-        const previousSessionFile = this.sessionFile;
-        const selectedEntry = this.sessionManager.getEntry(entryId);
-        if (!selectedEntry || selectedEntry.type !== "message" || selectedEntry.message.role !== "user") {
-            throw new Error("Invalid entry ID for forking");
-        }
-        const selectedText = this._extractUserMessageText(selectedEntry.message.content);
-        let skipConversationRestore = false;
-        // Emit session_before_fork event (can be cancelled)
-        if (this._extensionRunner?.hasHandlers("session_before_fork")) {
-            const result = (await this._extensionRunner.emit({
-                type: "session_before_fork",
-                entryId,
-            }));
-            if (result?.cancel) {
-                return { selectedText, cancelled: true };
+        return this._runObserveOperation("session.fork", "session_fork", async () => {
+            const previousSessionFile = this.sessionFile;
+            const previousSessionId = this.sessionId;
+            const selectedEntry = this.sessionManager.getEntry(entryId);
+            if (!selectedEntry || selectedEntry.type !== "message" || selectedEntry.message.role !== "user") {
+                throw new Error("Invalid entry ID for forking");
             }
-            skipConversationRestore = result?.skipConversationRestore ?? false;
-        }
-        // Clear pending messages (bound to old session state)
-        this._pendingNextTurnMessages = [];
-        if (!selectedEntry.parentId) {
-            this.sessionManager.newSession();
-        }
-        else {
-            this.sessionManager.createBranchedSession(selectedEntry.parentId);
-        }
-        this.agent.sessionId = this.sessionManager.getSessionId();
-        this._memoryThreadId = this.sessionManager.getSessionId();
-        this._rebuildTodoStore();
-        // Reload messages from entries (works for both file and in-memory mode)
-        const sessionContext = this.sessionManager.buildSessionContext();
-        // Emit session_fork event to extensions (after fork completes)
-        if (this._extensionRunner) {
-            await this._extensionRunner.emit({
-                type: "session_fork",
-                previousSessionFile,
+            const selectedText = this._extractUserMessageText(selectedEntry.message.content);
+            let skipConversationRestore = false;
+            // Emit session_before_fork event (can be cancelled)
+            if (this._extensionRunner?.hasHandlers("session_before_fork")) {
+                const result = (await this._extensionRunner.emit({
+                    type: "session_before_fork",
+                    entryId,
+                }));
+                if (result?.cancel) {
+                    return { selectedText, cancelled: true };
+                }
+                skipConversationRestore = result?.skipConversationRestore ?? false;
+            }
+            // Clear pending messages (bound to old session state)
+            this._pendingNextTurnMessages = [];
+            if (!selectedEntry.parentId) {
+                this.sessionManager.newSession();
+            }
+            else {
+                this.sessionManager.createBranchedSession(selectedEntry.parentId);
+            }
+            this.agent.sessionId = this.sessionManager.getSessionId();
+            this._memoryThreadId = this.sessionManager.getSessionId();
+            this._rebuildTodoStore();
+            // Reload messages from entries (works for both file and in-memory mode)
+            const sessionContext = this.sessionManager.buildSessionContext();
+            // Emit session_fork event to extensions (after fork completes)
+            if (this._extensionRunner) {
+                await this._extensionRunner.emit({
+                    type: "session_fork",
+                    previousSessionFile,
+                });
+            }
+            if (!skipConversationRestore) {
+                this.agent.replaceMessages(sessionContext.messages);
+            }
+            await this._endObserveSession(previousSessionId);
+            await this._refreshObserveSession();
+            await this._logObserve({
+                name: "session.fork",
+                summary: "forked session branch",
+                attributes: {
+                    entryId,
+                    previousSessionId,
+                    previousSessionFile,
+                    skipConversationRestore,
+                },
             });
-        }
-        // Emit session event to custom tools (with reason "fork")
-        if (!skipConversationRestore) {
-            this.agent.replaceMessages(sessionContext.messages);
-        }
-        return { selectedText, cancelled: false };
+            return { selectedText, cancelled: false };
+        }, {
+            input: { entryId },
+            output: (result) => ({ cancelled: result.cancelled, selectedTextLength: result.selectedText.length }),
+        });
     }
     // =========================================================================
     // Tree Navigation
@@ -2451,13 +2602,22 @@ export class AgentSession {
         }
         // Rebuild active tools to include MCP tools
         const currentActive = this.getActiveToolNames();
-        const mcpToolNames = tools.map(t => t.name);
+        const mcpToolNames = tools.map((t) => t.name);
         this.setActiveToolsByName([...currentActive, ...mcpToolNames]);
         // Rebuild runtime to include MCP tools in agent
         this._rebuildRuntimeState({
             activeToolNames: [...currentActive, ...mcpToolNames],
             includeAllExtensionTools: true,
         });
+        void this._refreshObserveSession();
+        void this._logObserve({
+            name: "mcp.register_tools",
+            summary: "registered MCP tools",
+            attributes: {
+                toolCount: tools.length,
+                toolNames: tools.map((tool) => tool.name),
+            },
+        });
     }
     /**
      * Get MCP server status.
@@ -2499,16 +2659,22 @@ export class AgentSession {
      * @returns Promise resolving to the number of tools loaded
      */
     async reconnectMCP(configPath) {
-        // First disconnect existing connections
-        await this.disconnectMCP();
-        // Load new tools
-        const { createMCPTools } = await import("./tooling/index.js");
-        const result = await createMCPTools(configPath);
-        // Register tools
-        if (result.tools.length > 0) {
-            this.registerMCPTools(result.tools, result.pool);
-        }
-        return result.tools.length;
+        return this._runObserveOperation("mcp.reconnect", "mcp_call", async () => {
+            // First disconnect existing connections
+            await this.disconnectMCP();
+            // Load new tools
+            const { createMCPTools } = await import("./tooling/index.js");
+            const result = await createMCPTools(configPath);
+            // Register tools
+            if (result.tools.length > 0) {
+                this.registerMCPTools(result.tools, result.pool);
+            }
+            await this._refreshObserveSession();
+            return result.tools.length;
+        }, {
+            input: { configPath },
+            output: (toolCount) => ({ toolCount }),
+        });
     }
     // =========================================================================
     // Memory System
@@ -2529,73 +2695,97 @@ export class AgentSession {
         }
         // Rebuild active tools to include memory tools
         const currentActive = this.getActiveToolNames();
-        const memoryToolNames = tools.map(t => t.name);
+        const memoryToolNames = tools.map((t) => t.name);
         this.setActiveToolsByName([...currentActive, ...memoryToolNames]);
         // Rebuild runtime to include memory tools in agent
         this._rebuildRuntimeState({
             activeToolNames: [...currentActive, ...memoryToolNames],
             includeAllExtensionTools: true,
         });
+        void this._refreshObserveSession();
+        void this._logObserve({
+            name: "memory.register_tools",
+            summary: "registered memory tools",
+            attributes: {
+                toolCount: tools.length,
+                toolNames: tools.map((tool) => tool.name),
+            },
+        });
     }
     /**
      * Enable memory for the current and future sessions.
      * Optionally persists an OpenAI API key before initializing memory.
      */
     async enableMemory(options) {
-        const persistSettings = options?.persistSettings ?? true;
-        if (this._memory) {
-            await this.disableMemory({ persistSettings: false });
-        }
-        if (options?.apiKey) {
-            this._modelRegistry.authStorage.set("openai", "default", {
-                type: "api_key",
-                key: options.apiKey,
-                accountName: "Default",
+        await this._runObserveOperation("memory.enable", "custom", async () => {
+            const persistSettings = options?.persistSettings ?? true;
+            if (this._memory) {
+                await this.disableMemory({ persistSettings: false });
+            }
+            if (options?.apiKey) {
+                this._modelRegistry.authStorage.set("openai", "default", {
+                    type: "api_key",
+                    key: options.apiKey,
+                    accountName: "Default",
+                });
+            }
+            const openaiKey = options?.apiKey ?? (await this._modelRegistry.getApiKeyForProvider("openai"));
+            if (!openaiKey) {
+                throw new Error("OpenAI API key not found. Run /memory setup <OPENAI_API_KEY> first.");
+            }
+            const memory = await createMemory({
+                apiKey: openaiKey,
+                lastMessages: this.settingsManager.getMemoryLastMessages(),
+                workingMemory: this.settingsManager.getMemoryWorkingMemoryEnabled()
+                    ? { enabled: true, scope: "resource", template: DEFAULT_WORKING_MEMORY_TEMPLATE }
+                    : undefined,
+                semanticRecall: this.settingsManager.getMemorySemanticRecallEnabled()
+                    ? { topK: 5, messageRange: 2 }
+                    : undefined,
+                observationalMemory: this.settingsManager.getMemoryObservationalMemoryEnabled()
+                    ? { enabled: true, scope: "thread" }
+                    : undefined,
             });
-        }
-        const openaiKey = options?.apiKey ?? (await this._modelRegistry.getApiKeyForProvider("openai"));
-        if (!openaiKey) {
-            throw new Error("OpenAI API key not found. Run /memory setup <OPENAI_API_KEY> first.");
-        }
-        const memory = await createMemory({
-            apiKey: openaiKey,
-            lastMessages: this.settingsManager.getMemoryLastMessages(),
-            workingMemory: this.settingsManager.getMemoryWorkingMemoryEnabled()
-                ? { enabled: true, scope: "resource", template: DEFAULT_WORKING_MEMORY_TEMPLATE }
-                : undefined,
-            semanticRecall: this.settingsManager.getMemorySemanticRecallEnabled()
-                ? { topK: 5, messageRange: 2 }
-                : undefined,
-            observationalMemory: this.settingsManager.getMemoryObservationalMemoryEnabled()
-                ? { enabled: true, scope: "thread" }
-                : undefined,
-        });
-        const memoryTools = createMemoryTools(memory, {
-            threadId: this.sessionManager.getSessionId(),
-            resourceId: this._memoryResourceId,
+            const memoryTools = createMemoryTools(memory, {
+                threadId: this.sessionManager.getSessionId(),
+                resourceId: this._memoryResourceId,
+            });
+            this.registerMemoryTools(memoryTools, memory);
+            if (persistSettings) {
+                this.settingsManager.setMemorySettings({ enabled: true, autoConnect: true });
+            }
+            await this._refreshObserveSession();
+        }, {
+            attributes: {
+                persistSettings: options?.persistSettings ?? true,
+                hasApiKeyOverride: !!options?.apiKey,
+            },
         });
-        this.registerMemoryTools(memoryTools, memory);
-        if (persistSettings) {
-            this.settingsManager.setMemorySettings({ enabled: true, autoConnect: true });
-        }
     }
     /**
      * Disable memory for the current and future sessions.
      */
     async disableMemory(options) {
-        const persistSettings = options?.persistSettings ?? true;
-        const memoryToolNames = new Set(this._memoryTools.map((tool) => tool.name));
-        const activeWithoutMemory = this.getActiveToolNames().filter((name) => !memoryToolNames.has(name));
-        this._memory = undefined;
-        this._memoryTools = [];
-        this._memoryThreadId = "";
-        this._rebuildRuntimeState({
-            activeToolNames: activeWithoutMemory,
-            includeAllExtensionTools: true,
+        await this._runObserveOperation("memory.disable", "custom", async () => {
+            const persistSettings = options?.persistSettings ?? true;
+            const memoryToolNames = new Set(this._memoryTools.map((tool) => tool.name));
+            const activeWithoutMemory = this.getActiveToolNames().filter((name) => !memoryToolNames.has(name));
+            this._memory = undefined;
+            this._memoryTools = [];
+            this._memoryThreadId = "";
+            this._rebuildRuntimeState({
+                activeToolNames: activeWithoutMemory,
+                includeAllExtensionTools: true,
+            });
+            if (persistSettings) {
+                this.settingsManager.setMemorySettings({ enabled: false, autoConnect: false });
+            }
+            await this._refreshObserveSession();
+        }, {
+            attributes: {
+                persistSettings: options?.persistSettings ?? true,
+            },
         });
-        if (persistSettings) {
-            this.settingsManager.setMemorySettings({ enabled: false, autoConnect: false });
-        }
     }
     /**
      * Get the memory instance.