@dexto/core 1.5.7 → 1.6.0

package/dist/agent/DextoAgent.js

@@ -9,13 +9,11 @@ import { setMaxListeners } from "events";
 import { SkillsContributor } from "../systemPrompt/contributors.js";
 import { expandMessageReferences } from "../resources/index.js";
 import { expandBlobReferences } from "../context/utils.js";
+import { StorageManager } from "../storage/index.js";
 import { PromptManager } from "../prompts/index.js";
 import { SessionError } from "../session/index.js";
-import { createLogger } from "../logger/factory.js";
-import { DextoLogComponent } from "../logger/v2/types.js";
 import { InstrumentClass } from "../telemetry/decorators.js";
 import { trace, context, propagation } from "@opentelemetry/api";
-import { LLMUpdatesSchema } from "../llm/schemas.js";
 import { resolveAndValidateLLMConfig } from "../llm/resolver.js";
 import { validateInputForLLM } from "../llm/validation.js";
 import { LLMError } from "../llm/errors.js";
@@ -32,9 +30,18 @@ import {
   getDefaultModelForProvider,
   getProviderFromModel,
   getAllModelsForProvider
-} from "../llm/registry.js";
+} from "../llm/registry/index.js";
 import { createAgentServices } from "../utils/service-initializer.js";
-import { AgentConfigSchema, createAgentConfigSchema } from "./schemas.js";
+import { LLMConfigSchema, LLMUpdatesSchema } from "../llm/schemas.js";
+import { ServersConfigSchema } from "../mcp/schemas.js";
+import { MemoriesConfigSchema } from "../memory/schemas.js";
+import { PromptsSchema } from "../prompts/schemas.js";
+import { ResourcesConfigSchema } from "../resources/schemas.js";
+import { SessionConfigSchema } from "../session/schemas.js";
+import { SystemPromptConfigSchema } from "../systemPrompt/schemas.js";
+import { ElicitationConfigSchema, PermissionsConfigSchema } from "../tools/schemas.js";
+import { OtelConfigurationSchema } from "../telemetry/schemas.js";
+import { AgentCardSchema } from "./schemas.js";
 import {
   AgentEventBus
 } from "../events/index.js";
@@ -47,6 +54,7 @@ const requiredServices = [
   "agentEventBus",
   "stateManager",
   "sessionManager",
+  "workspaceManager",
   "searchService",
   "memoryManager"
 ];
@@ -58,44 +66,14 @@ _DextoAgent_decorators = [InstrumentClass({
     "getConfig",
     "getEffectiveConfig",
     "registerSubscriber",
+    "on",
+    "once",
+    "off",
+    "emit",
     "ensureStarted"
   ]
 })];
-class DextoAgent {
-  /**
-   * Creates a DextoAgent instance.
-   *
-   * @param config - Agent configuration (validated and enriched)
-   * @param configPath - Optional path to config file (for relative path resolution)
-   * @param options - Validation options
-   * @param options.strict - When true (default), enforces API key and baseURL requirements.
-   *                         When false, allows missing credentials for interactive configuration.
-   */
-  constructor(config, configPath, options) {
-    this.configPath = configPath;
-    const schema = options?.strict === false ? createAgentConfigSchema({ strict: false }) : AgentConfigSchema;
-    this.config = schema.parse(config);
-    this.logger = createLogger({
-      config: this.config.logger,
-      agentId: this.config.agentId,
-      component: DextoLogComponent.AGENT
-    });
-    const serviceOverrides = {};
-    if (options?.sessionLoggerFactory) {
-      serviceOverrides.sessionLoggerFactory = options.sessionLoggerFactory;
-    }
-    if (options && "mcpAuthProviderFactory" in options) {
-      serviceOverrides.mcpAuthProviderFactory = options.mcpAuthProviderFactory ?? null;
-    }
-    if (Object.keys(serviceOverrides).length > 0) {
-      this.serviceOverrides = serviceOverrides;
-    }
-    if (options?.mcpAuthProviderFactory) {
-      this.mcpAuthProviderFactory = options.mcpAuthProviderFactory;
-    }
-    this.agentEventBus = new AgentEventBus();
-    this.logger.info("DextoAgent created.");
-  }
+let _DextoAgent = class _DextoAgent {
   /**
    * These services are public for use by the outside world
    * This gives users the option to use methods of the services directly if they know what they are doing
@@ -107,6 +85,7 @@ class DextoAgent {
   promptManager;
   stateManager;
   sessionManager;
+  workspaceManager;
   toolManager;
   resourceManager;
   memoryManager;
@@ -129,9 +108,87 @@ class DextoAgent {
   // Active stream controllers per session - allows cancel() to abort iterators
   activeStreamControllers = /* @__PURE__ */ new Map();
   // Host overrides for service initialization (e.g. session logger factory)
-  serviceOverrides;
+  overrides;
+  // DI-provided local tools.
+  tools;
+  compactionStrategy;
   // Logger instance for this agent (dependency injection)
   logger;
+  /**
+   * Validate + normalize runtime settings.
+   *
+   * This is the single validation boundary for programmatic (code-first) construction.
+   * Host layers may validate earlier (e.g. YAML parsing), but core always normalizes
+   * runtime settings before use.
+   */
+  static validateConfig(options) {
+    return {
+      agentId: options.agentId,
+      llm: LLMConfigSchema.parse(options.llm),
+      systemPrompt: SystemPromptConfigSchema.parse(options.systemPrompt),
+      mcpServers: ServersConfigSchema.parse(options.mcpServers ?? {}),
+      sessions: SessionConfigSchema.parse(options.sessions ?? {}),
+      permissions: PermissionsConfigSchema.parse(options.permissions ?? {}),
+      elicitation: ElicitationConfigSchema.parse(options.elicitation ?? {}),
+      resources: ResourcesConfigSchema.parse(options.resources ?? []),
+      prompts: PromptsSchema.parse(options.prompts),
+      ...options.agentCard !== void 0 && {
+        agentCard: AgentCardSchema.parse(options.agentCard)
+      },
+      ...options.greeting !== void 0 && { greeting: options.greeting },
+      ...options.telemetry !== void 0 && {
+        telemetry: OtelConfigurationSchema.parse(options.telemetry)
+      },
+      ...options.memories !== void 0 && {
+        memories: MemoriesConfigSchema.parse(options.memories)
+      }
+    };
+  }
+  /**
+   * Creates a DextoAgent instance.
+   *
+   * Constructor options are DI-first:
+   * - runtime settings (validated + defaulted by core)
+   * - concrete services (logger/tools/hooks/storage backends)
+   * - optional internal service overrides (session logging, auth factories, etc.)
+   */
+  constructor(options) {
+    const {
+      logger,
+      storage,
+      tools: toolsInput,
+      hooks: hooksInput,
+      compaction,
+      overrides: overridesInput,
+      ...runtimeSettings
+    } = options;
+    const tools = toolsInput ?? [];
+    const hooks = hooksInput ?? [];
+    this.config = _DextoAgent.validateConfig(runtimeSettings);
+    this.logger = logger;
+    this.tools = tools;
+    this.compactionStrategy = compaction ?? null;
+    const overrides = { ...overridesInput ?? {} };
+    if (overrides.storageManager === void 0) {
+      overrides.storageManager = new StorageManager(
+        {
+          cache: storage.cache,
+          database: storage.database,
+          blobStore: storage.blob
+        },
+        this.logger
+      );
+    }
+    if (overrides.hooks === void 0) {
+      overrides.hooks = hooks;
+    }
+    this.overrides = overrides;
+    if (overrides.mcpAuthProviderFactory !== void 0) {
+      this.mcpAuthProviderFactory = overrides.mcpAuthProviderFactory;
+    }
+    this.agentEventBus = new AgentEventBus();
+    this.logger.info("DextoAgent created.");
+  }
   /**
    * Starts the agent by initializing all async services.
    * This method handles storage backends, MCP connections, session manager initialization, and other async operations.
@@ -147,10 +204,10 @@ class DextoAgent {
       this.logger.info("Starting DextoAgent...");
       const services = await createAgentServices(
         this.config,
-        this.configPath,
         this.logger,
         this.agentEventBus,
-        this.serviceOverrides
+        this.overrides,
+        this.compactionStrategy
       );
       if (this.mcpAuthProviderFactory) {
         services.mcpManager.setAuthProviderFactory(this.mcpAuthProviderFactory);
@@ -162,11 +219,11 @@ class DextoAgent {
           );
         }
       }
-      const needsHandler = this.config.toolConfirmation.mode === "manual" || this.config.elicitation.enabled;
+      const needsHandler = this.config.permissions.mode === "manual" || this.config.elicitation.enabled;
       if (needsHandler && !this.approvalHandler) {
         const reasons = [];
-        if (this.config.toolConfirmation.mode === "manual") {
-          reasons.push('tool confirmation mode is "manual"');
+        if (this.config.permissions.mode === "manual") {
+          reasons.push('permissions mode is "manual"');
         }
         if (this.config.elicitation.enabled) {
           reasons.push("elicitation is enabled");
@@ -175,7 +232,7 @@ class DextoAgent {
           `An approval handler is required but not configured (${reasons.join(" and ")}).
 Either:
   \u2022 Call agent.setApprovalHandler() before starting
-  \u2022 Set toolConfirmation: { mode: "auto-approve" } or { mode: "auto-deny" }
+  \u2022 Set permissions: { mode: "auto-approve" } or { mode: "auto-deny" }
   \u2022 Disable elicitation: { enabled: false }`
         );
       }
@@ -189,6 +246,7 @@ Either:
         systemPromptManager: services.systemPromptManager,
         stateManager: services.stateManager,
         sessionManager: services.sessionManager,
+        workspaceManager: services.workspaceManager,
         memoryManager: services.memoryManager,
         services
       });
@@ -202,9 +260,27 @@ Either:
       );
       await promptManager.initialize();
       Object.assign(this, { promptManager });
-      services.toolManager.setAgent(this);
-      services.toolManager.setPromptManager(promptManager);
-      if (this.config.internalTools?.includes("invoke_skill")) {
+      const toolExecutionStorage = {
+        blob: services.storageManager.getBlobStore(),
+        database: services.storageManager.getDatabase(),
+        cache: services.storageManager.getCache()
+      };
+      const toolExecutionServices = {
+        approval: services.approvalManager,
+        search: services.searchService,
+        resources: services.resourceManager,
+        prompts: promptManager,
+        mcp: services.mcpManager,
+        taskForker: null
+      };
+      services.toolManager.setToolExecutionContextFactory((baseContext) => ({
+        ...baseContext,
+        agent: this,
+        storage: toolExecutionStorage,
+        services: toolExecutionServices
+      }));
+      const agentTools = this.tools;
+      if (agentTools.some((t) => t.id === "invoke_skill")) {
         const skillsContributor = new SkillsContributor(
           "skills",
           50,
@@ -215,6 +291,7 @@ Either:
         services.systemPromptManager.addContributor(skillsContributor);
         this.logger.debug("Added SkillsContributor to system prompt");
       }
+      services.toolManager.setTools(agentTools);
       await services.toolManager.initialize();
       this.searchService = services.searchService;
       this._isStarted = true;
@@ -258,13 +335,22 @@ Either:
         shutdownErrors.push(new Error(`SessionManager cleanup failed: ${err.message}`));
       }
       try {
-        if (this.services?.pluginManager) {
-          await this.services.pluginManager.cleanup();
-          this.logger.debug("PluginManager cleaned up successfully");
+        if (this.toolManager) {
+          await this.toolManager.cleanup();
+          this.logger.debug("ToolManager cleaned up successfully");
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        shutdownErrors.push(new Error(`ToolManager cleanup failed: ${err.message}`));
+      }
+      try {
+        if (this.services?.hookManager) {
+          await this.services.hookManager.cleanup();
+          this.logger.debug("HookManager cleaned up successfully");
         }
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        shutdownErrors.push(new Error(`PluginManager cleanup failed: ${err.message}`));
+        shutdownErrors.push(new Error(`HookManager cleanup failed: ${err.message}`));
       }
       try {
         if (this.mcpManager) {
@@ -275,6 +361,15 @@ Either:
         const err = error instanceof Error ? error : new Error(String(error));
         shutdownErrors.push(new Error(`MCPManager disconnect failed: ${err.message}`));
       }
+      try {
+        if (this.resourceManager) {
+          this.resourceManager.cleanup();
+          this.logger.debug("ResourceManager cleaned up successfully");
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        shutdownErrors.push(new Error(`ResourceManager cleanup failed: ${err.message}`));
+      }
       try {
         if (this.services?.storageManager) {
           await this.services.storageManager.disconnect();
@@ -292,6 +387,7 @@ Either:
       } else {
         this.logger.info("DextoAgent stopped successfully.");
       }
+      this.agentEventBus.emit("agent:stopped");
     } catch (error) {
       this.logger.error("Failed to stop DextoAgent", {
         error: error instanceof Error ? error.message : String(error)
@@ -312,6 +408,26 @@ Either:
       subscriber.subscribe(this.agentEventBus);
     }
   }
+  /**
+   * Convenience event subscription APIs (typed delegates to {@link AgentEventBus}).
+   *
+   * Prefer these over reaching into the internal event bus directly.
+   */
+  on(event, listener, options) {
+    this.agentEventBus.on(event, listener, options);
+    return this;
+  }
+  once(event, listener, options) {
+    this.agentEventBus.once(event, listener, options);
+    return this;
+  }
+  off(event, listener) {
+    this.agentEventBus.off(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.agentEventBus.emit(event, ...args);
+  }
   /**
    * Restart the agent by stopping and starting it.
    * Automatically re-subscribes all registered event subscribers to the new event bus.
@@ -564,6 +680,14 @@ Either:
     };
     this.agentEventBus.on("llm:tool-call", toolCallListener, { signal: cleanupSignal });
     listeners.push({ event: "llm:tool-call", listener: toolCallListener });
+    const toolCallPartialListener = (data) => {
+      if (data.sessionId !== sessionId) return;
+      eventQueue.push({ name: "llm:tool-call-partial", ...data });
+    };
+    this.agentEventBus.on("llm:tool-call-partial", toolCallPartialListener, {
+      signal: cleanupSignal
+    });
+    listeners.push({ event: "llm:tool-call-partial", listener: toolCallPartialListener });
     const toolResultListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:tool-result", ...data });
@@ -941,6 +1065,36 @@ Either:
     }
     return !!streamController;
   }
+  // ============= WORKSPACE MANAGEMENT =============
+  /**
+   * Sets the active workspace for this runtime.
+   * The workspace context is persisted and emitted via the agent event bus.
+   */
+  async setWorkspace(input) {
+    this.ensureStarted();
+    return await this.workspaceManager.setWorkspace(input);
+  }
+  /**
+   * Gets the currently active workspace, if any.
+   */
+  async getWorkspace() {
+    this.ensureStarted();
+    return await this.workspaceManager.getWorkspace();
+  }
+  /**
+   * Clears the active workspace for this runtime.
+   */
+  async clearWorkspace() {
+    this.ensureStarted();
+    await this.workspaceManager.clearWorkspace();
+  }
+  /**
+   * Lists all known workspaces in storage.
+   */
+  async listWorkspaces() {
+    this.ensureStarted();
+    return await this.workspaceManager.listWorkspaces();
+  }
   // ============= SESSION MANAGEMENT =============
   /**
    * Creates a new chat session or returns an existing one.
@@ -1214,7 +1368,7 @@ Either:
       return null;
     }
     const contributorContext = { mcpManager: this.mcpManager };
-    const tools = await llmService.getAllTools();
+    const tools = await llmService.getEnabledTools();
     const beforeEstimate = await contextManager.getContextTokenEstimate(
       contributorContext,
       tools
@@ -1225,7 +1379,11 @@ Either:
       estimatedTokens: originalTokens,
       sessionId
     });
-    const summaryMessages = await compactionStrategy.compact(history);
+    const summaryMessages = await compactionStrategy.compact(history, {
+      sessionId,
+      model: llmService.getLanguageModel(),
+      logger: session.logger
+    });
     if (summaryMessages.length === 0) {
       this.logger.debug(`Compaction skipped for session ${sessionId} - nothing to compact`);
       this.agentEventBus.emit("context:compacted", {
@@ -1289,28 +1447,24 @@ Either:
     const contextManager = session.getContextManager();
     const contributorContext = { mcpManager: this.mcpManager };
     const llmService = session.getLLMService();
-    const tools = await llmService.getAllTools();
+    const tools = await llmService.getEnabledTools();
     const tokenEstimate = await contextManager.getContextTokenEstimate(
       contributorContext,
       tools
     );
     const history = await contextManager.getHistory();
     const runtimeConfig = this.stateManager.getRuntimeConfig(sessionId);
-    const compactionConfig = runtimeConfig.compaction;
     const modelContextWindow = contextManager.getMaxInputTokens();
-    let maxContextTokens = modelContextWindow;
-    if (compactionConfig?.maxContextTokens !== void 0) {
-      maxContextTokens = Math.min(maxContextTokens, compactionConfig.maxContextTokens);
-    }
-    const thresholdPercent = compactionConfig?.thresholdPercent ?? 0.9;
-    if (thresholdPercent < 1) {
-      maxContextTokens = Math.floor(maxContextTokens * thresholdPercent);
-    }
+    const compactionStrategy = this.compactionStrategy;
+    const compactionSettings = compactionStrategy?.getSettings();
+    const thresholdPercent = compactionSettings && compactionSettings.enabled ? compactionSettings.thresholdPercent : 1;
+    const modelLimits = compactionStrategy ? compactionStrategy.getModelLimits(modelContextWindow) : { contextWindow: modelContextWindow };
+    const maxContextTokens = thresholdPercent < 1 ? Math.floor(modelLimits.contextWindow * thresholdPercent) : modelLimits.contextWindow;
     const hasSummary = history.some(
       (msg) => msg.metadata?.isSummary === true || msg.metadata?.isSessionSummary === true
     );
     const llmConfig = runtimeConfig.llm;
-    const { getModelDisplayName } = await import("../llm/registry.js");
+    const { getModelDisplayName } = await import("../llm/registry/index.js");
     const modelDisplayName = getModelDisplayName(llmConfig.model, llmConfig.provider);
     const estimatedTokens = tokenEstimate.estimated;
     const autoCompactBuffer = thresholdPercent > 0 && thresholdPercent < 1 ? Math.floor(maxContextTokens * (1 - thresholdPercent) / thresholdPercent) : 0;
@@ -1483,7 +1637,7 @@ Either:
   /**
    * Gets supported models for a specific provider.
    * Returns model information including metadata for the specified provider only.
-   * For gateway providers like 'dexto' with supportsAllRegistryModels, returns
+   * For gateway providers like 'dexto-nova' with supportsAllRegistryModels, returns
    * all models from all accessible providers with their original provider info.
    *
    * @param provider The provider to get models for
@@ -1587,6 +1741,70 @@ Either:
       throw MCPError.connectionFailed(name, errorMessage);
     }
   }
+  /**
+   * Updates an existing MCP server configuration and reconnects if needed.
+   * This is used when editing server params (timeout, headers, env, etc.).
+   *
+   * @param name The name of the server to update.
+   * @param config The updated configuration object.
+   * @throws MCPError if validation fails or reconnect fails.
+   */
+  async updateMcpServer(name, config) {
+    this.ensureStarted();
+    const currentConfig = this.stateManager.getRuntimeConfig().mcpServers[name];
+    if (!currentConfig) {
+      throw MCPError.serverNotFound(name);
+    }
+    const existingServerNames = Object.keys(this.stateManager.getRuntimeConfig().mcpServers);
+    const validation = resolveAndValidateMcpServerConfig(name, config, existingServerNames);
+    const validatedConfig = ensureOk(validation, this.logger);
+    this.stateManager.setMcpServer(name, validatedConfig);
+    const shouldEnable = validatedConfig.enabled !== false;
+    const hasClient = this.mcpManager.getClients().has(name);
+    if (!shouldEnable) {
+      if (hasClient) {
+        await this.mcpManager.removeClient(name);
+        await this.toolManager.refresh();
+      }
+      this.logger.info(`MCP server '${name}' updated (disabled)`);
+      return;
+    }
+    try {
+      if (hasClient) {
+        await this.mcpManager.removeClient(name);
+      }
+      await this.mcpManager.connectServer(name, validatedConfig);
+      await this.toolManager.refresh();
+      this.agentEventBus.emit("mcp:server-connected", { name, success: true });
+      this.agentEventBus.emit("tools:available-updated", {
+        tools: Object.keys(await this.toolManager.getAllTools()),
+        source: "mcp"
+      });
+      this.logger.info(`MCP server '${name}' updated and reconnected successfully`);
+      const warnings = validation.issues.filter((i) => i.severity === "warning");
+      if (warnings.length > 0) {
+        this.logger.warn(
+          `MCP server updated with warnings: ${warnings.map((w) => w.message).join(", ")}`
+        );
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to update MCP server '${name}': ${errorMessage}`);
+      this.stateManager.setMcpServer(name, currentConfig);
+      if (currentConfig.enabled !== false) {
+        try {
+          await this.mcpManager.connectServer(name, currentConfig);
+          await this.toolManager.refresh();
+        } catch (reconnectError) {
+          const reconnectMsg = reconnectError instanceof Error ? reconnectError.message : String(reconnectError);
+          this.logger.error(
+            `Failed to restore MCP server '${name}' after update error: ${reconnectMsg}`
+          );
+        }
+      }
+      throw MCPError.connectionFailed(name, errorMessage);
+    }
+  }
   /**
    * @deprecated Use `addMcpServer` instead. This method will be removed in a future version.
    */
@@ -1742,6 +1960,90 @@ Either:
     this.ensureStarted();
     return await this.toolManager.getAllTools();
   }
+  /**
+   * Gets tools enabled for LLM context (applies session overrides + global preferences).
+   */
+  async getEnabledTools(sessionId) {
+    this.ensureStarted();
+    if (sessionId !== void 0 && (!sessionId || typeof sessionId !== "string")) {
+      throw AgentError.apiValidationError("sessionId must be a non-empty string");
+    }
+    return this.toolManager.filterToolsForSession(
+      await this.toolManager.getAllTools(),
+      sessionId
+    );
+  }
+  /**
+   * Get global disabled tools (agent preferences).
+   */
+  getGlobalDisabledTools() {
+    this.ensureStarted();
+    return this.toolManager.getGlobalDisabledTools();
+  }
+  /**
+   * Set global disabled tools (agent preferences).
+   */
+  setGlobalDisabledTools(toolNames) {
+    this.ensureStarted();
+    if (!Array.isArray(toolNames) || toolNames.some((name) => !name || typeof name !== "string")) {
+      throw AgentError.apiValidationError("toolNames must be an array of non-empty strings");
+    }
+    this.toolManager.setGlobalDisabledTools(toolNames);
+  }
+  /**
+   * Set session-level disabled tools (session override).
+   */
+  setSessionDisabledTools(sessionId, toolNames) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    if (!Array.isArray(toolNames) || toolNames.some((name) => !name || typeof name !== "string")) {
+      throw AgentError.apiValidationError("toolNames must be an array of non-empty strings");
+    }
+    this.toolManager.setSessionDisabledTools(sessionId, toolNames);
+  }
+  /**
+   * Clear session-level disabled tools (session override).
+   */
+  clearSessionDisabledTools(sessionId) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    this.toolManager.clearSessionDisabledTools(sessionId);
+  }
+  /**
+   * Get session-level auto-approve tools.
+   */
+  getSessionAutoApproveTools(sessionId) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    return this.toolManager.getSessionUserAutoApproveTools(sessionId) ?? [];
+  }
+  /**
+   * Set session-level auto-approve tools (user selection).
+   */
+  setSessionAutoApproveTools(sessionId, toolNames) {
+    this.ensureStarted();
+    if (!sessionId || typeof sessionId !== "string") {
+      throw AgentError.apiValidationError(
+        "sessionId is required and must be a non-empty string"
+      );
+    }
+    if (!Array.isArray(toolNames) || toolNames.some((name) => !name || typeof name !== "string")) {
+      throw AgentError.apiValidationError("toolNames must be an array of non-empty strings");
+    }
+    this.toolManager.setSessionUserAutoApproveTools(sessionId, toolNames);
+  }
   /**
    * Gets all connected MCP clients.
    * Used by the API layer to inspect client status.
@@ -2010,90 +2312,17 @@ Either:
     this.ensureStarted();
     return sessionId ? this.stateManager.getRuntimeConfig(sessionId) : this.stateManager.getRuntimeConfig();
   }
-  /**
-   * Gets the file path of the agent configuration currently in use.
-   * This returns the source agent file path, not session-specific overrides.
-   * @returns The path to the agent configuration file
-   * @throws AgentError if no config path is available
-   */
-  getAgentFilePath() {
-    if (!this.configPath) {
-      throw AgentError.noConfigPath();
-    }
-    return this.configPath;
-  }
-  /**
-   * Reloads the agent configuration with a new config object.
-   * Validates the new config, detects what changed, and automatically
-   * restarts the agent if necessary to apply the changes.
-   *
-   * @param newConfig The new agent configuration to apply
-   * @returns Object containing whether agent was restarted and list of changes applied
-   * @throws Error if config is invalid or restart fails
-   *
-   * TODO: improve hot reload capabilites so that we don't always require a restart
-   */
-  async reload(newConfig) {
-    this.logger.info("Reloading agent configuration");
-    const oldConfig = this.config;
-    const validated = AgentConfigSchema.parse(newConfig);
-    const changesApplied = this.detectConfigChanges(oldConfig, validated);
-    this.config = validated;
-    let restarted = false;
-    if (changesApplied.length > 0) {
-      this.logger.info(
-        `Configuration changed. Restarting agent to apply: ${changesApplied.join(", ")}`
-      );
-      await this.restart();
-      restarted = true;
-      this.logger.info("Agent restarted successfully with new configuration");
-    } else {
-      this.logger.info("Agent configuration reloaded successfully (no changes detected)");
-    }
-    return {
-      restarted,
-      changesApplied
-    };
-  }
-  /**
-   * Detects configuration changes that require a full agent restart.
-   * Pure comparison logic - no file I/O.
-   * Returns an array of change descriptions.
-   *
-   * @param oldConfig Previous validated configuration
-   * @param newConfig New validated configuration
-   * @returns Array of restart-required change descriptions
-   */
-  detectConfigChanges(oldConfig, newConfig) {
-    const changes = [];
-    if (JSON.stringify(oldConfig.storage) !== JSON.stringify(newConfig.storage)) {
-      changes.push("Storage backend");
-    }
-    if (JSON.stringify(oldConfig.sessions) !== JSON.stringify(newConfig.sessions)) {
-      changes.push("Session configuration");
-    }
-    if (JSON.stringify(oldConfig.systemPrompt) !== JSON.stringify(newConfig.systemPrompt)) {
-      changes.push("System prompt");
-    }
-    if (JSON.stringify(oldConfig.toolConfirmation) !== JSON.stringify(newConfig.toolConfirmation)) {
-      changes.push("Tool confirmation");
-    }
-    if (JSON.stringify(oldConfig.internalTools) !== JSON.stringify(newConfig.internalTools)) {
-      changes.push("Internal tools");
-    }
-    if (JSON.stringify(oldConfig.mcpServers) !== JSON.stringify(newConfig.mcpServers)) {
-      changes.push("MCP servers");
-    }
-    if (oldConfig.llm.provider !== newConfig.llm.provider || oldConfig.llm.model !== newConfig.llm.model || oldConfig.llm.apiKey !== newConfig.llm.apiKey) {
-      changes.push("LLM configuration");
-    }
-    return changes;
+  getMcpServerConfig(name) {
+    this.ensureStarted();
+    const config = this.stateManager.getRuntimeConfig().mcpServers[name];
+    if (config) return config;
+    return this.mcpManager.getServerConfig(name);
   }
   // ============= APPROVAL HANDLER API =============
   /**
    * Set a custom approval handler for manual approval mode.
    *
-   * When `toolConfirmation.mode` is set to 'manual', an approval handler must be
+   * When `permissions.mode` is set to 'manual', an approval handler must be
    * provided to process tool confirmation requests. The handler will be called
    * whenever a tool execution requires user approval.
    *
@@ -2166,10 +2395,11 @@ Either:
   // - Memory and context management across sessions
   // - Tool chaining and workflow automation
   // - Agent collaboration and delegation
-}
+};
 _init = __decoratorStart(null);
-DextoAgent = __decorateElement(_init, 0, "DextoAgent", _DextoAgent_decorators, DextoAgent);
-__runInitializers(_init, 1, DextoAgent);
+_DextoAgent = __decorateElement(_init, 0, "DextoAgent", _DextoAgent_decorators, _DextoAgent);
+__runInitializers(_init, 1, _DextoAgent);
+let DextoAgent = _DextoAgent;
 export {
   DextoAgent
 };