wave-agent-sdk 0.0.8 → 0.0.10

package/dist/agent.js

@@ -4,19 +4,58 @@ import { ToolManager } from "./managers/toolManager.js";
 import { SubagentManager, } from "./managers/subagentManager.js";
 import * as memory from "./services/memory.js";
 import { McpManager } from "./managers/mcpManager.js";
+import { LspManager } from "./managers/lspManager.js";
 import { BashManager } from "./managers/bashManager.js";
 import { BackgroundBashManager, } from "./managers/backgroundBashManager.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
+import { PermissionManager } from "./managers/permissionManager.js";
 import { HookManager } from "./managers/hookManager.js";
-import { MemoryStoreService } from "./services/memoryStore.js";
-import { initializeMemoryStore } from "./services/memory.js";
 import { LiveConfigManager } from "./managers/liveConfigManager.js";
-import { configResolver } from "./utils/configResolver.js";
 import { configValidator } from "./utils/configValidator.js";
 import { SkillManager } from "./managers/skillManager.js";
-import { loadSessionFromJsonl } from "./services/session.js";
+import { loadSessionFromJsonl, handleSessionRestoration, } from "./services/session.js";
 import { setGlobalLogger } from "./utils/globalLogger.js";
+import { ConfigurationService } from "./services/configurationService.js";
+import * as fs from "fs/promises";
+import path from "path";
+import os from "os";
 export class Agent {
+    // Dynamic configuration getter methods
+    getGatewayConfig() {
+        return this.configurationService.resolveGatewayConfig(this.options.apiKey, this.options.baseURL, this.options.defaultHeaders, this.options.fetchOptions, this.options.fetch);
+    }
+    getModelConfig() {
+        return this.configurationService.resolveModelConfig(this.options.agentModel, this.options.fastModel);
+    }
+    getTokenLimit() {
+        return this.configurationService.resolveTokenLimit(this.options.tokenLimit);
+    }
+    /**
+     * Update agent configuration dynamically
+     *
+     * @param config - Configuration updates for gateway, model, and token limit
+     */
+    updateConfig(config) {
+        if (config.gateway) {
+            this.options.apiKey = config.gateway.apiKey ?? this.options.apiKey;
+            this.options.baseURL = config.gateway.baseURL ?? this.options.baseURL;
+            this.options.defaultHeaders =
+                config.gateway.defaultHeaders ?? this.options.defaultHeaders;
+            this.options.fetchOptions =
+                config.gateway.fetchOptions ?? this.options.fetchOptions;
+            this.options.fetch = config.gateway.fetch ?? this.options.fetch;
+        }
+        if (config.model) {
+            this.options.agentModel =
+                config.model.agentModel ?? this.options.agentModel;
+            this.options.fastModel = config.model.fastModel ?? this.options.fastModel;
+        }
+        if (config.tokenLimit !== undefined) {
+            this.options.tokenLimit = config.tokenLimit;
+        }
+        // Re-validate configuration after update
+        this.resolveAndValidateConfig();
+    }
     /**
      * Agent constructor - handles configuration resolution and validation
      *
@@ -29,82 +68,92 @@ export class Agent {
     constructor(options) {
         this.bashManager = null;
         this._usages = []; // Usage tracking array
-        const { callbacks = {}, logger, workdir, systemPrompt } = options;
-        // Set working directory first so it can be used for configuration resolution
+        // Memory content storage
+        this._projectMemoryContent = "";
+        this._userMemoryContent = "";
+        const { callbacks = {}, logger, workdir, systemPrompt, stream = true, } = options;
+        // Set working directory early as we need it for loading configuration
         this.workdir = workdir || process.cwd();
-        // Store original constructor values for live config updates
-        this.constructorApiKey = options.apiKey;
-        this.constructorBaseURL = options.baseURL;
-        this.constructorAgentModel = options.agentModel;
-        this.constructorFastModel = options.fastModel;
-        this.constructorTokenLimit = options.tokenLimit;
-        // Resolve configuration from constructor args and environment variables with live config support
-        const gatewayConfig = configResolver.resolveGatewayConfig(options.apiKey, options.baseURL, this.workdir);
-        const modelConfig = configResolver.resolveModelConfig(options.agentModel, options.fastModel, this.workdir);
-        const tokenLimit = configResolver.resolveTokenLimit(options.tokenLimit, this.workdir);
-        // Validate resolved configuration
-        configValidator.validateGatewayConfig(gatewayConfig);
-        configValidator.validateTokenLimit(tokenLimit);
-        configValidator.validateModelConfig(modelConfig.agentModel, modelConfig.fastModel);
+        // Initialize configuration service
+        this.configurationService = new ConfigurationService();
         this.logger = logger; // Save the passed logger
         this.systemPrompt = systemPrompt; // Save custom system prompt
-        // Set global logger for SDK-wide access
-        setGlobalLogger(logger || null);
-        // Store resolved configuration
-        this.gatewayConfig = gatewayConfig;
-        this.modelConfig = modelConfig;
-        this.tokenLimit = tokenLimit;
+        this.stream = stream; // Save streaming mode flag
+        // Store options for dynamic configuration resolution
+        this.options = options;
         this.backgroundBashManager = new BackgroundBashManager({
             callbacks,
             workdir: this.workdir,
         });
         this.mcpManager = new McpManager({ callbacks, logger: this.logger }); // Initialize MCP manager
-        this.toolManager = new ToolManager({
-            mcpManager: this.mcpManager,
-            logger: this.logger,
-        }); // Initialize tool registry, pass MCP manager
-        this.memoryStore = new MemoryStoreService(this.logger); // Initialize memory store service
-        initializeMemoryStore(this.memoryStore); // Initialize global memory store reference
+        this.lspManager =
+            options.lspManager || new LspManager({ logger: this.logger }); // Initialize LSP manager
+        // Initialize permission manager
+        this.permissionManager = new PermissionManager({ logger: this.logger });
+        this.permissionManager.setOnConfiguredDefaultModeChange((mode) => {
+            this.options.callbacks?.onPermissionModeChange?.(mode);
+        });
+        // Initialize configuration service and hooks manager
         this.hookManager = new HookManager(this.workdir, undefined, this.logger); // Initialize hooks manager
-        this.liveConfigManager = new LiveConfigManager({
+        // Initialize MessageManager
+        this.messageManager = new MessageManager({
+            callbacks,
             workdir: this.workdir,
             logger: this.logger,
-            onConfigurationChanged: () => {
-                // Update Agent configuration (AIManager, SubagentManager)
-                this.updateConfiguration();
-                // Reload hook configuration
+        });
+        // Create a wrapper for canUseTool that triggers notification hooks
+        const canUseToolWithNotification = options.canUseTool
+            ? async (context) => {
                 try {
-                    this.hookManager.loadConfigurationFromSettings();
-                    this.logger?.info("Live Config: Hook configuration reloaded successfully");
+                    // Trigger notification hooks before calling the original callback
+                    const notificationMessage = `Claude needs your permission to use ${context.toolName}`;
+                    await this.hookManager.executeHooks("Notification", {
+                        event: "Notification",
+                        projectDir: this.workdir,
+                        timestamp: new Date(),
+                        sessionId: this.sessionId,
+                        transcriptPath: this.messageManager.getTranscriptPath(),
+                        cwd: this.workdir,
+                        message: notificationMessage,
+                        notificationType: "permission_prompt",
+                        env: this.configurationService.getEnvironmentVars(), // Include configuration environment variables
+                    });
                 }
                 catch (error) {
-                    this.logger?.error(`Live Config: Failed to reload hook configuration: ${error.message}`);
+                    this.logger?.warn("Failed to execute notification hooks", {
+                        toolName: context.toolName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    // Continue with permission check even if hooks fail
                 }
-            },
-            onMemoryStoreFileChanged: async (filePath, changeType) => {
-                try {
-                    if (changeType === "unlink") {
-                        // Handle file deletion gracefully
-                        this.memoryStore.removeContent(filePath);
-                        this.logger?.info("Live Config: Removed AGENTS.md from memory store due to file deletion");
-                    }
-                    else {
-                        // Update memory store content for add/change
-                        await this.memoryStore.updateContent(filePath);
-                        this.logger?.info("Live Config: Updated AGENTS.md content in memory store");
-                    }
+                // Call the original callback
+                const decision = await options.canUseTool(context);
+                // Handle state changes from decision
+                if (decision.newPermissionMode) {
+                    this.setPermissionMode(decision.newPermissionMode);
                 }
-                catch (error) {
-                    this.logger?.error(`Live Config: Failed to update memory store: ${error.message}`);
+                if (decision.newPermissionRule) {
+                    await this.addPermissionRule(decision.newPermissionRule);
                 }
-            },
-        }); // Initialize live configuration manager
-        // Initialize MessageManager
-        this.messageManager = new MessageManager({
-            callbacks,
+                return decision;
+            }
+            : undefined;
+        // Initialize tool manager with permission context
+        this.toolManager = new ToolManager({
+            mcpManager: this.mcpManager,
+            lspManager: this.lspManager,
+            logger: this.logger,
+            permissionManager: this.permissionManager,
+            permissionMode: options.permissionMode, // Let PermissionManager handle defaultMode resolution
+            canUseToolCallback: canUseToolWithNotification,
+        }); // Initialize tool registry with permission support
+        this.liveConfigManager = new LiveConfigManager({
             workdir: this.workdir,
             logger: this.logger,
-        });
+            hookManager: this.hookManager,
+            permissionManager: this.permissionManager,
+            configurationService: this.configurationService,
+        }); // Initialize live configuration manager
         // Initialize subagent manager with all dependencies in constructor
         // IMPORTANT: Must be initialized AFTER MessageManager
         this.subagentManager = new SubagentManager({
@@ -115,13 +164,14 @@ export class Agent {
                 onSubagentUserMessageAdded: callbacks.onSubagentUserMessageAdded,
                 onSubagentAssistantMessageAdded: callbacks.onSubagentAssistantMessageAdded,
                 onSubagentAssistantContentUpdated: callbacks.onSubagentAssistantContentUpdated,
+                onSubagentAssistantReasoningUpdated: callbacks.onSubagentAssistantReasoningUpdated,
                 onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
                 onSubagentMessagesChange: callbacks.onSubagentMessagesChange,
             }, // Pass subagent callbacks for forwarding
             logger: this.logger,
-            gatewayConfig,
-            modelConfig,
-            tokenLimit,
+            getGatewayConfig: () => this.getGatewayConfig(),
+            getModelConfig: () => this.getModelConfig(),
+            getTokenLimit: () => this.getTokenLimit(),
             hookManager: this.hookManager,
             onUsageAdded: (usage) => this.addUsage(usage),
         });
@@ -140,9 +190,11 @@ export class Agent {
             },
             workdir: this.workdir,
             systemPrompt: this.systemPrompt,
-            gatewayConfig: this.gatewayConfig,
-            modelConfig: this.modelConfig,
-            tokenLimit: this.tokenLimit,
+            stream: this.stream, // Pass streaming mode flag
+            getGatewayConfig: () => this.getGatewayConfig(),
+            getModelConfig: () => this.getModelConfig(),
+            getTokenLimit: () => this.getTokenLimit(),
+            getEnvironmentVars: () => this.configurationService.getEnvironmentVars(), // Provide access to configuration environment variables
         });
         // Initialize command manager
         this.slashCommandManager = new SlashCommandManager({
@@ -174,9 +226,9 @@ export class Agent {
      * Rebuild usage array from messages containing usage metadata
      * Called during session restoration to reconstruct usage tracking
      */
-    rebuildUsageFromMessages() {
+    rebuildUsageFromMessages(messages) {
         this._usages = [];
-        this.messages.forEach((message) => {
+        messages.forEach((message) => {
             if (message.role === "assistant" && message.usage) {
                 this._usages.push(message.usage);
             }
@@ -202,9 +254,27 @@ export class Agent {
     get workingDirectory() {
         return this.workdir;
     }
-    /** Get merged environment variables from Wave configuration */
-    get environmentVars() {
-        return this.hookManager.getEnvironmentVars();
+    /** Get project memory content */
+    get projectMemory() {
+        return this._projectMemoryContent;
+    }
+    /** Get user memory content */
+    get userMemory() {
+        return this._userMemoryContent;
+    }
+    /** Get combined memory content (project + user) */
+    get combinedMemory() {
+        let combined = "";
+        if (this._projectMemoryContent.trim()) {
+            combined += this._projectMemoryContent;
+        }
+        if (this._userMemoryContent.trim()) {
+            if (combined) {
+                combined += "\n\n";
+            }
+            combined += this._userMemoryContent;
+        }
+        return combined;
     }
     /** Get AI loading status */
     get isLoading() {
@@ -244,6 +314,9 @@ export class Agent {
      * @param options - Configuration options for the Agent instance
      * @param options.apiKey - API key for the AI service (or set WAVE_API_KEY env var)
      * @param options.baseURL - Base URL for the AI service (or set WAVE_BASE_URL env var)
+     * @param options.defaultHeaders - Optional HTTP headers to pass to the AI service
+     * @param options.fetchOptions - Optional fetch options to pass to the AI service
+     * @param options.fetch - Optional custom fetch implementation
      * @param options.callbacks - Optional callbacks for various Agent events
      * @param options.restoreSessionId - Optional session ID to restore from
      * @param options.continueLastSession - Whether to continue the last session automatically
@@ -263,7 +336,7 @@ export class Agent {
      * ```
      */
     static async create(options) {
-        // Create Agent instance - configuration resolution and validation now happens in constructor
+        // Create Agent instance
         const instance = new Agent(options);
         await instance.initialize({
             restoreSessionId: options.restoreSessionId,
@@ -272,12 +345,31 @@ export class Agent {
         });
         return instance;
     }
+    /**
+     * Resolve and validate configuration from constructor args, environment variables,
+     * and loaded settings.json.
+     *
+     * This is called during initialization after settings.json has been loaded.
+     */
+    resolveAndValidateConfig() {
+        // Resolve configuration from constructor args and environment variables (including settings.json)
+        const gatewayConfig = this.getGatewayConfig();
+        const modelConfig = this.getModelConfig();
+        const tokenLimit = this.getTokenLimit();
+        // Validate resolved configuration
+        configValidator.validateGatewayConfig(gatewayConfig);
+        configValidator.validateTokenLimit(tokenLimit);
+        configValidator.validateModelConfig(modelConfig.agentModel, modelConfig.fastModel);
+    }
     /** Private initialization method, handles async initialization logic */
     async initialize(options) {
         // Initialize managers first
         try {
             // Initialize SkillManager
-            const skillManager = new SkillManager({ logger: this.logger });
+            const skillManager = new SkillManager({
+                logger: this.logger,
+                workdir: this.workdir,
+            });
             await skillManager.initialize();
             // Initialize SubagentManager (load and cache configurations)
             await this.subagentManager.initialize();
@@ -294,6 +386,9 @@ export class Agent {
         // Initialize MCP servers with auto-connect
         try {
             await this.mcpManager.initialize(this.workdir, true);
+            if (this.lspManager instanceof LspManager) {
+                await this.lspManager.initialize(this.workdir);
+            }
         }
         catch (error) {
             this.logger?.error("Failed to initialize MCP servers:", error);
@@ -301,54 +396,108 @@ export class Agent {
         }
         // Initialize hooks configuration
         try {
-            // Load hooks configuration from user and project settings
+            // Load hooks configuration using ConfigurationService
             this.logger?.debug("Loading hooks configuration...");
-            this.hookManager.loadConfigurationFromSettings();
+            const configResult = await this.configurationService.loadMergedConfiguration(this.workdir);
+            this.hookManager.loadConfigurationFromWaveConfig(configResult.configuration);
             this.logger?.debug("Hooks system initialized successfully");
         }
         catch (error) {
             this.logger?.error("Failed to initialize hooks system:", error);
             // Don't throw error to prevent app startup failure
         }
+        // Resolve and validate configuration after loading settings.json
+        this.resolveAndValidateConfig();
+        // Set global logger for SDK-wide access after validation
+        setGlobalLogger(this.logger || null);
         // Initialize live configuration reload
         try {
             this.logger?.debug("Initializing live configuration reload...");
             await this.liveConfigManager.initialize();
             this.logger?.debug("Live configuration reload initialized successfully");
+            // Update permission manager with configuration-based defaultMode
+            const currentConfig = this.liveConfigManager.getCurrentConfiguration();
+            if (currentConfig?.defaultMode) {
+                this.logger?.debug("Applying configured defaultMode to PermissionManager", {
+                    defaultMode: currentConfig.defaultMode,
+                });
+                this.permissionManager.updateConfiguredDefaultMode(currentConfig.defaultMode);
+            }
+            // Update permission manager with configuration-based allowed rules
+            if (currentConfig?.permissions?.allow) {
+                this.logger?.debug("Applying configured allowed rules to PermissionManager", {
+                    count: currentConfig.permissions.allow.length,
+                });
+                this.permissionManager.updateAllowedRules(currentConfig.permissions.allow);
+            }
         }
         catch (error) {
             this.logger?.error("Failed to initialize live configuration reload:", error);
             // Don't throw error to prevent app startup failure - continue without live reload
         }
+        // Load memory files during initialization
+        try {
+            this.logger?.debug("Loading memory files...");
+            // Load project memory from AGENTS.md (bypass memory store for direct file access)
+            try {
+                const projectMemoryPath = path.join(this.workdir, "AGENTS.md");
+                this._projectMemoryContent = await fs.readFile(projectMemoryPath, "utf-8");
+                this.logger?.debug("Project memory loaded successfully");
+            }
+            catch (error) {
+                this._projectMemoryContent = "";
+                this.logger?.debug("Project memory file not found or unreadable, using empty content:", error instanceof Error ? error.message : String(error));
+            }
+            // Load user memory (bypass memory store for direct file access)
+            try {
+                const userMemoryPath = path.join(os.homedir(), ".wave", "AGENTS.md");
+                this._userMemoryContent = await fs.readFile(userMemoryPath, "utf-8");
+                this.logger?.debug("User memory loaded successfully");
+            }
+            catch (error) {
+                this._userMemoryContent = "";
+                this.logger?.debug("User memory file not found or unreadable, using empty content:", error instanceof Error ? error.message : String(error));
+            }
+            this.logger?.debug("Memory initialization completed");
+        }
+        catch (error) {
+            // Ensure memory is always initialized even if loading fails
+            this._projectMemoryContent = "";
+            this._userMemoryContent = "";
+            this.logger?.error("Failed to load memory files:", error);
+            // Don't throw error to prevent app startup failure
+        }
         // Handle session restoration or set provided messages
         if (options?.messages) {
             // If messages are provided, use them directly (useful for testing)
             this.messageManager.setMessages(options.messages);
             // Rebuild usage array from restored messages
-            this.rebuildUsageFromMessages();
+            this.rebuildUsageFromMessages(options.messages);
         }
         else {
             // Otherwise, handle session restoration
-            await this.messageManager.handleSessionRestoration(options?.restoreSessionId, options?.continueLastSession);
+            const sessionToRestore = await handleSessionRestoration(options?.restoreSessionId, options?.continueLastSession, this.messageManager.getWorkdir());
             // Rebuild usage array from restored messages
-            this.rebuildUsageFromMessages();
+            this.rebuildUsageFromMessages(sessionToRestore?.messages || []);
             // After main session is restored, restore any associated subagent sessions
-            await this.restoreSubagentSessions();
+            await this.restoreSubagentSessions(sessionToRestore?.messages || []);
+            if (sessionToRestore)
+                this.messageManager.initializeFromSession(sessionToRestore);
         }
     }
     /**
      * Restore subagent sessions associated with the current main session
      * This method is called after the main session is restored to load any subagent sessions
      */
-    async restoreSubagentSessions() {
+    async restoreSubagentSessions(messages) {
         try {
             // Only attempt to restore subagent sessions if we have messages (session was restored)
-            if (this.messages.length === 0) {
+            if (messages.length === 0) {
                 return;
             }
             // Extract sessionId -> subagentId mapping from SubagentBlocks
             const subagentBlockMap = new Map(); // sessionId -> { subagentId, configuration }
-            for (const message of this.messages) {
+            for (const message of messages) {
                 if (message.role === "assistant" && message.blocks) {
                     for (const block of message.blocks) {
                         if (block.type === "subagent" &&
@@ -370,7 +519,7 @@ export class Agent {
             const subagentSessions = [];
             for (const [sessionId, blockData] of subagentBlockMap) {
                 try {
-                    const sessionData = await loadSessionFromJsonl(sessionId, this.messageManager.getWorkdir());
+                    const sessionData = await loadSessionFromJsonl(sessionId, this.messageManager.getWorkdir(), "subagent");
                     if (sessionData) {
                         subagentSessions.push({
                             sessionData,
@@ -395,6 +544,37 @@ export class Agent {
             // Don't throw error to prevent app startup failure
         }
     }
+    /**
+     * Restore a session by ID, switching to the target session without destroying the Agent instance
+     * @param sessionId - The ID of the session to restore
+     */
+    async restoreSession(sessionId) {
+        // 1. Validation
+        if (!sessionId || sessionId === this.sessionId) {
+            return; // No-op if session ID is invalid or already current
+        }
+        // 2. Auto-save current session
+        try {
+            await this.messageManager.saveSession();
+        }
+        catch (error) {
+            this.logger?.warn("Failed to save current session before restore:", error);
+            // Continue with restoration even if save fails
+        }
+        // 3. Load target session
+        const sessionData = await loadSessionFromJsonl(sessionId, this.messageManager.getWorkdir());
+        if (!sessionData) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // 4. Clean current state
+        this.abortMessage(); // Abort any running operations
+        this.subagentManager.cleanup(); // Clean up active subagents
+        // 5. Rebuild usage and restore subagents (in correct order)
+        this.rebuildUsageFromMessages(sessionData.messages);
+        await this.restoreSubagentSessions(sessionData.messages);
+        // 6. Initialize session state last
+        this.messageManager.initializeFromSession(sessionData);
+    }
     abortAIMessage() {
         this.aiManager.abortAIMessage();
     }
@@ -436,6 +616,10 @@ export class Agent {
         this.backgroundBashManager.cleanup();
         // Cleanup MCP connections
         await this.mcpManager.cleanup();
+        // Cleanup LSP connections
+        if (this.lspManager instanceof LspManager) {
+            await this.lspManager.cleanup();
+        }
         // Cleanup subagent manager
         this.subagentManager.cleanup();
         // Cleanup live configuration reload
@@ -446,14 +630,33 @@ export class Agent {
             this.logger?.error("Error shutting down live configuration reload:", error);
         }
         // Cleanup memory store
-        try {
-            this.memoryStore.clear();
-            this.logger?.debug("Memory store cleared successfully");
-        }
-        catch (error) {
-            this.logger?.error("Error clearing memory store:", error);
-        }
     }
+    /**
+     * Send a message to the AI agent with optional images
+     *
+     * @param content - The text content of the message to send
+     * @param images - Optional array of images to include with the message
+     * @param images[].path - File path to the image or base64 encoded image data
+     * @param images[].mimeType - MIME type of the image (e.g., 'image/png', 'image/jpeg')
+     * @returns Promise that resolves when the message has been processed
+     *
+     * @example
+     * ```typescript
+     * // Send a text message
+     * await agent.sendMessage("Hello, how are you?");
+     *
+     * // Send a message with images using file paths
+     * await agent.sendMessage("What do you see in these images?", [
+     *   { path: "/path/to/image.png", mimeType: "image/png" },
+     *   { path: "/path/to/photo.jpg", mimeType: "image/jpeg" }
+     * ]);
+     *
+     * // Send a message with base64 encoded image
+     * await agent.sendMessage("Analyze this image", [
+     *   { path: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...", mimeType: "image/png" }
+     * ]);
+     * ```
+     */
     async sendMessage(content, images) {
         try {
             // Handle slash command - check if it's a slash command (starts with /)
@@ -496,6 +699,7 @@ export class Agent {
                         transcriptPath: this.messageManager.getTranscriptPath(),
                         cwd: this.workdir,
                         userPrompt: content,
+                        env: this.configurationService.getEnvironmentVars(), // Include configuration environment variables
                     });
                     // Process hook results and determine if we should continue
                     const processResult = this.hookManager.processHookResults("UserPromptSubmit", hookResults, this.messageManager);
@@ -521,23 +725,33 @@ export class Agent {
     /** Save memory to project or user memory file */
     async saveMemory(message, type) {
         try {
+            // Ensure the message starts with # for memory functions
+            const formattedMessage = message.startsWith("#")
+                ? message
+                : `#${message}`;
             if (type === "project") {
-                await memory.addMemory(message, this.workdir);
+                await memory.addMemory(formattedMessage, this.workdir);
+                // Update internal state after successful save
+                this._projectMemoryContent = await memory.readMemoryFile(this.workdir);
             }
             else {
-                await memory.addUserMemory(message);
+                await memory.addUserMemory(formattedMessage);
+                // Update internal state after successful save
+                this._userMemoryContent = await memory.getUserMemoryContent();
             }
             // Add successful MemoryBlock to the last assistant message
             const memoryText = message.substring(1).trim();
             const typeLabel = type === "project" ? "Project Memory" : "User Memory";
-            const storagePath = type === "project" ? "AGENTS.md" : "user-memory.md";
+            const storagePath = "AGENTS.md";
             this.messageManager.addMemoryBlock(`${typeLabel}: ${memoryText}`, true, type, storagePath);
         }
         catch (error) {
             // Add failed MemoryBlock to the last assistant message
+            const memoryText = message.substring(1).trim();
             const typeLabel = type === "project" ? "Project Memory" : "User Memory";
-            const storagePath = type === "project" ? "AGENTS.md" : "user-memory.md";
-            this.messageManager.addMemoryBlock(`${typeLabel} add failed: ${error instanceof Error ? error.message : String(error)}`, false, type, storagePath);
+            const storagePath = "AGENTS.md";
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.messageManager.addMemoryBlock(`${typeLabel}: ${memoryText} - Error: ${errorMessage}`, false, type, storagePath);
         }
     }
     // ========== MCP Management Methods ==========
@@ -574,51 +788,40 @@ export class Agent {
     getCustomCommands() {
         return this.slashCommandManager.getCustomCommands();
     }
-    // ========== Live Configuration Management ==========
     /**
-     * Update Agent configuration from live settings.json changes
-     * This method refreshes all configuration-dependent components with new values
-     * Note: Constructor values still take precedence over live configuration
+     * Get the current permission mode
      */
-    updateConfiguration() {
-        try {
-            this.logger?.info("Live Config: Updating Agent configuration from live settings");
-            // Re-resolve configuration with current workdir, preserving constructor overrides
-            // We need to track what was explicitly provided in constructor vs. what should use live config
-            const newGatewayConfig = configResolver.resolveGatewayConfig(this.constructorApiKey, // Preserve constructor override if provided
-            this.constructorBaseURL, // Preserve constructor override if provided
-            this.workdir);
-            const newModelConfig = configResolver.resolveModelConfig(this.constructorAgentModel, // Preserve constructor override if provided
-            this.constructorFastModel, // Preserve constructor override if provided
-            this.workdir);
-            const newTokenLimit = configResolver.resolveTokenLimit(this.constructorTokenLimit, this.workdir);
-            // Validate new configuration
-            configValidator.validateGatewayConfig(newGatewayConfig);
-            configValidator.validateTokenLimit(newTokenLimit);
-            configValidator.validateModelConfig(newModelConfig.agentModel, newModelConfig.fastModel);
-            // Update stored configuration
-            this.gatewayConfig = newGatewayConfig;
-            this.modelConfig = newModelConfig;
-            this.tokenLimit = newTokenLimit;
-            // Update AIManager with new configuration
-            this.aiManager.updateConfiguration(newGatewayConfig, newModelConfig, newTokenLimit);
-            // Update SubagentManager with new configuration
-            this.subagentManager.updateConfiguration(newGatewayConfig, newModelConfig, newTokenLimit);
-            this.logger?.info(`Live Config: Agent configuration updated successfully - model: ${newModelConfig.agentModel}, tokenLimit: ${newTokenLimit}`);
-        }
-        catch (error) {
-            this.logger?.error(`Live Config: Failed to update Agent configuration: ${error.message}`);
-            // Don't throw - continue with previous configuration
-        }
+    getPermissionMode() {
+        return this.toolManager.getPermissionMode();
     }
     /**
-     * Get current Agent configuration for debugging
+     * Set the permission mode
+     * @param mode - The new permission mode
      */
-    getCurrentConfiguration() {
-        return {
-            gatewayConfig: { ...this.gatewayConfig },
-            modelConfig: { ...this.modelConfig },
-            tokenLimit: this.tokenLimit,
-        };
+    setPermissionMode(mode) {
+        this.toolManager.setPermissionMode(mode);
+        this.options.callbacks?.onPermissionModeChange?.(mode);
+    }
+    /**
+     * Add a persistent permission rule
+     * @param rule - The rule to add (e.g., "Bash(ls)")
+     */
+    async addPermissionRule(rule) {
+        // 1. Update PermissionManager state
+        const currentRules = this.permissionManager.getAllowedRules();
+        if (!currentRules.includes(rule)) {
+            this.permissionManager.updateAllowedRules([...currentRules, rule]);
+            // 2. Persist to settings.local.json
+            try {
+                await this.configurationService.addAllowedRule(this.workdir, rule);
+                this.logger?.debug("Persistent permission rule added", { rule });
+            }
+            catch (error) {
+                this.logger?.error("Failed to persist permission rule", {
+                    rule,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
     }
 }