wave-agent-sdk 0.0.7 → 0.0.8

package/src/agent.ts

@@ -4,7 +4,10 @@ import {
 } from "./managers/messageManager.js";
 import { AIManager } from "./managers/aiManager.js";
 import { ToolManager } from "./managers/toolManager.js";
-import { SubagentManager } from "./managers/subagentManager.js";
+import {
+  SubagentManager,
+  type SubagentManagerCallbacks,
+} from "./managers/subagentManager.js";
 import * as memory from "./services/memory.js";
 import { McpManager, type McpManagerCallbacks } from "./managers/mcpManager.js";
 import { BashManager } from "./managers/bashManager.js";
@@ -23,9 +26,15 @@ import type {
   Usage,
 } from "./types/index.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 type { SubagentConfiguration } from "./utils/subagentParser.js";
+import { setGlobalLogger } from "./utils/globalLogger.js";
 
 /**
  * Configuration options for Agent instances
@@ -52,20 +61,13 @@ export interface AgentOptions {
   workdir?: string;
   /**Optional custom system prompt - if provided, replaces default system prompt */
   systemPrompt?: string;
-
-  // New: Session directory configuration
-  /**
-   * Optional custom directory for session file storage
-   * @default join(homedir(), ".wave", "sessions")
-   * @example "/path/to/custom/sessions"
-   */
-  sessionDir?: string;
 }
 
 export interface AgentCallbacks
   extends MessageManagerCallbacks,
     BackgroundBashManagerCallbacks,
-    McpManagerCallbacks {}
+    McpManagerCallbacks,
+    SubagentManagerCallbacks {}
 
 export class Agent {
   private messageManager: MessageManager;
@@ -79,6 +81,8 @@ export class Agent {
   private subagentManager: SubagentManager; // Add subagent manager instance
   private slashCommandManager: SlashCommandManager; // Add slash command manager instance
   private hookManager: HookManager; // Add hooks manager instance
+  private memoryStore: MemoryStoreService; // Add memory store service
+  private liveConfigManager: LiveConfigManager; // Add live configuration manager
   private workdir: string; // Working directory
   private systemPrompt?: string; // Custom system prompt
   private _usages: Usage[] = []; // Usage tracking array
@@ -88,6 +92,13 @@ export class Agent {
   private modelConfig: ModelConfig;
   private tokenLimit: number;
 
+  // Original constructor values for preserving overrides during live updates
+  private readonly constructorApiKey?: string;
+  private readonly constructorBaseURL?: string;
+  private readonly constructorAgentModel?: string;
+  private readonly constructorFastModel?: string;
+  private readonly constructorTokenLimit?: number;
+
   /**
    * Agent constructor - handles configuration resolution and validation
    *
@@ -96,27 +107,35 @@ export class Agent {
    * Agent.create() to maintain API consistency.
    *
    * @param options - Configuration options for the Agent instance
-   * @param options.sessionDir - Optional custom directory for session storage
    */
   private constructor(options: AgentOptions) {
-    const {
-      callbacks = {},
-      logger,
-      workdir,
-      systemPrompt,
-      sessionDir,
-    } = options;
-
-    // Resolve configuration from constructor args and environment variables
+    const { callbacks = {}, logger, workdir, systemPrompt } = options;
+
+    // Set working directory first so it can be used for configuration resolution
+    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,
     );
-    const tokenLimit = configResolver.resolveTokenLimit(options.tokenLimit);
 
     // Validate resolved configuration
     configValidator.validateGatewayConfig(gatewayConfig);
@@ -127,9 +146,11 @@ export class Agent {
     );
 
     this.logger = logger; // Save the passed logger
-    this.workdir = workdir || process.cwd(); // Set working directory, default to current working directory
     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;
@@ -145,14 +166,59 @@ export class Agent {
       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.hookManager = new HookManager(this.workdir, undefined, this.logger); // Initialize hooks manager
+    this.liveConfigManager = new LiveConfigManager({
+      workdir: this.workdir,
+      logger: this.logger,
+      onConfigurationChanged: () => {
+        // Update Agent configuration (AIManager, SubagentManager)
+        this.updateConfiguration();
+
+        // Reload hook configuration
+        try {
+          this.hookManager.loadConfigurationFromSettings();
+          this.logger?.info(
+            "Live Config: Hook configuration reloaded successfully",
+          );
+        } catch (error) {
+          this.logger?.error(
+            `Live Config: Failed to reload hook configuration: ${(error as Error).message}`,
+          );
+        }
+      },
+      onMemoryStoreFileChanged: async (
+        filePath: string,
+        changeType: "add" | "change" | "unlink",
+      ) => {
+        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",
+            );
+          }
+        } catch (error) {
+          this.logger?.error(
+            `Live Config: Failed to update memory store: ${(error as Error).message}`,
+          );
+        }
+      },
+    }); // Initialize live configuration manager
 
     // Initialize MessageManager
     this.messageManager = new MessageManager({
       callbacks,
       workdir: this.workdir,
       logger: this.logger,
-      sessionDir,
     });
 
     // Initialize subagent manager with all dependencies in constructor
@@ -161,10 +227,20 @@ export class Agent {
       workdir: this.workdir,
       parentToolManager: this.toolManager,
       parentMessageManager: this.messageManager,
+      callbacks: {
+        onSubagentUserMessageAdded: callbacks.onSubagentUserMessageAdded,
+        onSubagentAssistantMessageAdded:
+          callbacks.onSubagentAssistantMessageAdded,
+        onSubagentAssistantContentUpdated:
+          callbacks.onSubagentAssistantContentUpdated,
+        onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
+        onSubagentMessagesChange: callbacks.onSubagentMessagesChange,
+      }, // Pass subagent callbacks for forwarding
       logger: this.logger,
       gatewayConfig,
       modelConfig,
       tokenLimit,
+      hookManager: this.hookManager,
       onUsageAdded: (usage) => this.addUsage(usage),
     });
 
@@ -257,6 +333,11 @@ export class Agent {
     return this.workdir;
   }
 
+  /** Get merged environment variables from Wave configuration */
+  public get environmentVars(): Record<string, string> | undefined {
+    return this.hookManager.getEnvironmentVars();
+  }
+
   /** Get AI loading status */
   public get isLoading(): boolean {
     return this.aiManager.isLoading;
@@ -303,9 +384,6 @@ 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.sessionDir - Optional custom directory for session file storage.
-   *   If not provided, defaults to ~/.wave/sessions/. Can be relative or absolute path.
-   *   Examples: "./app-sessions", "/var/myapp/sessions", "~/Documents/sessions"
    * @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
@@ -317,18 +395,11 @@ export class Agent {
    *
    * @example
    * ```typescript
-   * // Basic usage with default session directory
+   * // Basic usage
    * const agent = await Agent.create({
    *   apiKey: 'your-api-key',
    *   baseURL: 'https://api.example.com'
    * });
-   *
-   * // Custom session directory
-   * const agent = await Agent.create({
-   *   apiKey: 'your-api-key',
-   *   baseURL: 'https://api.example.com',
-   *   sessionDir: './app-sessions'
-   * });
    * ```
    */
   static async create(options: AgentOptions): Promise<Agent> {
@@ -386,6 +457,19 @@ export class Agent {
       // Don't throw error to prevent app startup failure
     }
 
+    // Initialize live configuration reload
+    try {
+      this.logger?.debug("Initializing live configuration reload...");
+      await this.liveConfigManager.initialize();
+      this.logger?.debug("Live configuration reload initialized successfully");
+    } 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
+    }
+
     // Handle session restoration or set provided messages
     if (options?.messages) {
       // If messages are provided, use them directly (useful for testing)
@@ -400,6 +484,87 @@ export class Agent {
       );
       // Rebuild usage array from restored messages
       this.rebuildUsageFromMessages();
+
+      // After main session is restored, restore any associated subagent sessions
+      await this.restoreSubagentSessions();
+    }
+  }
+
+  /**
+   * Restore subagent sessions associated with the current main session
+   * This method is called after the main session is restored to load any subagent sessions
+   */
+  private async restoreSubagentSessions(): Promise<void> {
+    try {
+      // Only attempt to restore subagent sessions if we have messages (session was restored)
+      if (this.messages.length === 0) {
+        return;
+      }
+
+      // Extract sessionId -> subagentId mapping from SubagentBlocks
+      const subagentBlockMap = new Map<
+        string,
+        { subagentId: string; configuration: SubagentConfiguration }
+      >(); // sessionId -> { subagentId, configuration }
+
+      for (const message of this.messages) {
+        if (message.role === "assistant" && message.blocks) {
+          for (const block of message.blocks) {
+            if (
+              block.type === "subagent" &&
+              block.sessionId &&
+              block.subagentId &&
+              block.configuration
+            ) {
+              subagentBlockMap.set(block.sessionId, {
+                subagentId: block.subagentId,
+                configuration: block.configuration,
+              });
+            }
+          }
+        }
+      }
+
+      if (subagentBlockMap.size === 0) {
+        return; // No subagent blocks found
+      }
+
+      // Load subagent sessions using sessionIds
+      const subagentSessions = [];
+      for (const [sessionId, blockData] of subagentBlockMap) {
+        try {
+          const sessionData = await loadSessionFromJsonl(
+            sessionId,
+            this.messageManager.getWorkdir(),
+          );
+          if (sessionData) {
+            subagentSessions.push({
+              sessionData,
+              subagentId: blockData.subagentId, // Use the subagentId from SubagentBlock
+              configuration: blockData.configuration, // Include configuration
+            });
+          }
+        } catch (error) {
+          this.logger?.warn(
+            `Failed to load subagent session ${sessionId}:`,
+            error,
+          );
+        }
+      }
+
+      if (subagentSessions.length > 0) {
+        this.logger?.debug(
+          `Found ${subagentSessions.length} subagent sessions to restore`,
+        );
+
+        // Restore subagent sessions through the SubagentManager
+        await this.subagentManager.restoreSubagentSessions(subagentSessions);
+
+        this.logger?.debug("Subagent sessions restored successfully");
+      }
+    } catch (error) {
+      this.logger?.warn("Failed to restore subagent sessions:", error);
+      // Don't throw error to prevent app startup failure
     }
   }
 
@@ -453,6 +618,22 @@ export class Agent {
     await this.mcpManager.cleanup();
     // Cleanup subagent manager
     this.subagentManager.cleanup();
+    // Cleanup live configuration reload
+    try {
+      await this.liveConfigManager.shutdown();
+    } catch (error) {
+      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);
+    }
   }
 
   public async sendMessage(
@@ -623,4 +804,87 @@ export class Agent {
   public getCustomCommands(): CustomSlashCommand[] {
     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
+   */
+  public updateConfiguration(): void {
+    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 as Error).message}`,
+      );
+      // Don't throw - continue with previous configuration
+    }
+  }
+
+  /**
+   * Get current Agent configuration for debugging
+   */
+  public getCurrentConfiguration(): {
+    gatewayConfig: GatewayConfig;
+    modelConfig: ModelConfig;
+    tokenLimit: number;
+  } {
+    return {
+      gatewayConfig: { ...this.gatewayConfig },
+      modelConfig: { ...this.modelConfig },
+      tokenLimit: this.tokenLimit,
+    };
+  }
 }

package/src/constants/events.ts

@@ -0,0 +1,38 @@
+/**
+ * Event name constants to prevent typos and ensure consistency
+ *
+ * Using constants instead of magic strings prevents bugs like:
+ * - ConfigurationWatcher emitting 'configurationChange'
+ * - LiveConfigManager listening for 'configurationChanged'
+ *
+ * This pattern ensures compile-time validation of event names.
+ */
+
+// Configuration Watcher Events
+export const CONFIGURATION_EVENTS = {
+  CONFIGURATION_CHANGE: "configurationChange",
+  WATCHER_ERROR: "watcherError",
+} as const;
+
+// File Watcher Events
+export const FILE_WATCHER_EVENTS = {
+  CHANGE: "change",
+  CREATE: "create",
+  DELETE: "delete",
+  RENAME: "rename",
+} as const;
+
+// Memory Store Events
+export const MEMORY_STORE_EVENTS = {
+  FILE_ADDED: "fileAdded",
+  FILE_CHANGED: "fileChanged",
+  FILE_REMOVED: "fileRemoved",
+} as const;
+
+// Type exports for better TypeScript support
+export type ConfigurationEventName =
+  (typeof CONFIGURATION_EVENTS)[keyof typeof CONFIGURATION_EVENTS];
+export type FileWatcherEventName =
+  (typeof FILE_WATCHER_EVENTS)[keyof typeof FILE_WATCHER_EVENTS];
+export type MemoryStoreEventName =
+  (typeof MEMORY_STORE_EVENTS)[keyof typeof MEMORY_STORE_EVENTS];

package/src/index.ts

@@ -3,6 +3,7 @@ export * from "./services/aiService.js";
 export * from "./services/memory.js";
 export * from "./services/session.js";
 export * from "./services/hook.js";
+export * from "./services/jsonlHandler.js";
 
 // Export main agent
 export * from "./agent.js";
@@ -11,6 +12,7 @@ export * from "./agent.js";
 export * from "./utils/bashHistory.js";
 export * from "./utils/convertMessagesForAPI.js";
 export * from "./utils/fileFilter.js";
+export * from "./utils/globalLogger.js";
 export * from "./utils/mcpUtils.js";
 export * from "./utils/messageOperations.js";
 export * from "./utils/path.js";