@dexto/core 1.5.8 → 1.6.0

package/README.md

@@ -188,10 +188,19 @@ await manager.disconnectAll();
 Delegate tasks to other A2A-compliant agents using the built-in `delegate_to_url` tool.
 
 ```typescript
+import { builtinToolsFactory } from '@dexto/tools-builtins';
+
+const tools = builtinToolsFactory.create({
+  type: 'builtin-tools',
+  enabledTools: ['delegate_to_url'],
+});
+
 const agent = new DextoAgent({
   llm: { /* ... */ },
-  internalTools: ['delegate_to_url'], // Enable delegation tool
-  toolConfirmation: { mode: 'auto-approve' }
+  logger,   // provide a per-agent logger instance
+  storage,  // provide cache/database/blob implementations
+  tools,
+  permissions: { mode: 'auto-approve' }
 });
 await agent.start();
 
@@ -204,15 +213,18 @@ await agent.generate(`
 `, session.id);
 
 // Or call the tool directly
-const tools = await agent.getAllTools();
-const delegateTool = tools.find(t => t.name === 'internal--delegate_to_url');
-// The tool is prefixed with 'internal--' by the ToolManager
+await agent.executeTool('delegate_to_url', {
+  url: 'http://localhost:3001',
+  message: 'Extract all tables from the Q4 sales report',
+});
 ```
 
 **Configuration (YAML):**
 ```yaml
-internalTools:
-  - delegate_to_url
+tools:
+  - type: builtin-tools
+    enabledTools:
+      - delegate_to_url
 ```
 
 **What it provides:**
@@ -280,4 +292,3 @@ https://docs.dexto.ai/api/dexto-agent/
 ## License
 
 Elastic License 2.0. See the repository LICENSE for details.
-

package/dist/agent/DextoAgent.cjs

@@ -80,13 +80,11 @@ var import_events = require("events");
 var import_contributors = require("../systemPrompt/contributors.js");
 var import_resources = require("../resources/index.js");
 var import_utils = require("../context/utils.js");
+var import_storage = require("../storage/index.js");
 var import_prompts = require("../prompts/index.js");
 var import_session = require("../session/index.js");
-var import_factory = require("../logger/factory.js");
-var import_types = require("../logger/v2/types.js");
 var import_decorators = require("../telemetry/decorators.js");
 var import_api = require("@opentelemetry/api");
-var import_schemas = require("../llm/schemas.cjs");
 var import_resolver = require("../llm/resolver.js");
 var import_validation = require("../llm/validation.js");
 var import_errors = require("../llm/errors.js");
@@ -95,14 +93,23 @@ var import_errors3 = require("../mcp/errors.js");
 var import_error_codes = require("../mcp/error-codes.js");
 var import_DextoRuntimeError = require("../errors/DextoRuntimeError.js");
 var import_DextoValidationError = require("../errors/DextoValidationError.js");
-var import_result_bridge = require("../errors/result-bridge.cjs");
-var import_result = require("../utils/result.cjs");
+var import_result_bridge = require("../errors/result-bridge.js");
+var import_result = require("../utils/result.js");
 var import_resolver2 = require("../mcp/resolver.js");
 var import_registry = require("../llm/registry/index.js");
 var import_service_initializer2 = require("../utils/service-initializer.js");
-var import_schemas2 = require("./schemas.js");
+var import_schemas = require("../llm/schemas.js");
+var import_schemas2 = require("../mcp/schemas.js");
+var import_schemas3 = require("../memory/schemas.js");
+var import_schemas4 = require("../prompts/schemas.js");
+var import_schemas5 = require("../resources/schemas.js");
+var import_schemas6 = require("../session/schemas.js");
+var import_schemas7 = require("../systemPrompt/schemas.js");
+var import_schemas8 = require("../tools/schemas.js");
+var import_schemas9 = require("../telemetry/schemas.js");
+var import_schemas10 = require("./schemas.js");
 var import_events2 = require("../events/index.js");
-var import_safe_stringify = require("../utils/safe-stringify.cjs");
+var import_safe_stringify = require("../utils/safe-stringify.js");
 var import_title_generator = require("../session/title-generator.js");
 var _DextoAgent_decorators, _init;
 const requiredServices = [
@@ -112,6 +119,7 @@ const requiredServices = [
   "agentEventBus",
   "stateManager",
   "sessionManager",
+  "workspaceManager",
   "searchService",
   "memoryManager"
 ];
@@ -123,50 +131,14 @@ _DextoAgent_decorators = [(0, import_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 ? (0, import_schemas2.createAgentConfigSchema)({ strict: false }) : import_schemas2.AgentConfigSchema;
-    this.config = schema.parse(config);
-    this.logger = (0, import_factory.createLogger)({
-      config: this.config.logger,
-      agentId: this.config.agentId,
-      component: import_types.DextoLogComponent.AGENT
-    });
-    const serviceOverrides = {};
-    if (options?.sessionLoggerFactory) {
-      serviceOverrides.sessionLoggerFactory = options.sessionLoggerFactory;
-    }
-    if (options && "mcpAuthProviderFactory" in options) {
-      serviceOverrides.mcpAuthProviderFactory = options.mcpAuthProviderFactory ?? null;
-    }
-    if (options?.toolManager) {
-      serviceOverrides.toolManager = options.toolManager;
-    }
-    if (options?.toolManagerFactory) {
-      serviceOverrides.toolManagerFactory = options.toolManagerFactory;
-    }
-    if (Object.keys(serviceOverrides).length > 0) {
-      this.serviceOverrides = serviceOverrides;
-    }
-    if (options?.mcpAuthProviderFactory) {
-      this.mcpAuthProviderFactory = options.mcpAuthProviderFactory;
-    }
-    this.agentEventBus = new import_events2.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
@@ -178,6 +150,7 @@ class DextoAgent {
   promptManager;
   stateManager;
   sessionManager;
+  workspaceManager;
   toolManager;
   resourceManager;
   memoryManager;
@@ -200,9 +173,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: import_schemas.LLMConfigSchema.parse(options.llm),
+      systemPrompt: import_schemas7.SystemPromptConfigSchema.parse(options.systemPrompt),
+      mcpServers: import_schemas2.ServersConfigSchema.parse(options.mcpServers ?? {}),
+      sessions: import_schemas6.SessionConfigSchema.parse(options.sessions ?? {}),
+      permissions: import_schemas8.PermissionsConfigSchema.parse(options.permissions ?? {}),
+      elicitation: import_schemas8.ElicitationConfigSchema.parse(options.elicitation ?? {}),
+      resources: import_schemas5.ResourcesConfigSchema.parse(options.resources ?? []),
+      prompts: import_schemas4.PromptsSchema.parse(options.prompts),
+      ...options.agentCard !== void 0 && {
+        agentCard: import_schemas10.AgentCardSchema.parse(options.agentCard)
+      },
+      ...options.greeting !== void 0 && { greeting: options.greeting },
+      ...options.telemetry !== void 0 && {
+        telemetry: import_schemas9.OtelConfigurationSchema.parse(options.telemetry)
+      },
+      ...options.memories !== void 0 && {
+        memories: import_schemas3.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 import_storage.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 import_events2.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.
@@ -218,10 +269,10 @@ class DextoAgent {
       this.logger.info("Starting DextoAgent...");
       const services = await (0, import_service_initializer2.createAgentServices)(
         this.config,
-        this.configPath,
         this.logger,
         this.agentEventBus,
-        this.serviceOverrides
+        this.overrides,
+        this.compactionStrategy
       );
       if (this.mcpAuthProviderFactory) {
         services.mcpManager.setAuthProviderFactory(this.mcpAuthProviderFactory);
@@ -233,11 +284,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");
@@ -246,7 +297,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 }`
         );
       }
@@ -260,6 +311,7 @@ Either:
         systemPromptManager: services.systemPromptManager,
         stateManager: services.stateManager,
         sessionManager: services.sessionManager,
+        workspaceManager: services.workspaceManager,
         memoryManager: services.memoryManager,
         services
       });
@@ -273,9 +325,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 import_contributors.SkillsContributor(
           "skills",
           50,
@@ -286,6 +356,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;
@@ -329,13 +400,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(`PluginManager cleanup failed: ${err.message}`));
+        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(`HookManager cleanup failed: ${err.message}`));
       }
       try {
         if (this.mcpManager) {
@@ -346,6 +426,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();
@@ -384,6 +473,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.
@@ -636,6 +745,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 });
@@ -1013,6 +1130,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.
@@ -1297,7 +1444,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", {
@@ -1368,16 +1519,12 @@ Either:
     );
     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
     );
@@ -1659,6 +1806,70 @@ Either:
       throw import_errors3.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 import_errors3.MCPError.serverNotFound(name);
+    }
+    const existingServerNames = Object.keys(this.stateManager.getRuntimeConfig().mcpServers);
+    const validation = (0, import_resolver2.resolveAndValidateMcpServerConfig)(name, config, existingServerNames);
+    const validatedConfig = (0, import_result_bridge.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 import_errors3.MCPError.connectionFailed(name, errorMessage);
+    }
+  }
   /**
    * @deprecated Use `addMcpServer` instead. This method will be removed in a future version.
    */
@@ -2166,90 +2377,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 import_errors2.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 = import_schemas2.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.
    *
@@ -2322,10 +2460,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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DextoAgent