@dexto/core 1.5.8 → 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";
@@ -34,7 +32,16 @@ import {
   getAllModelsForProvider
 } 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,50 +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 (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 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
@@ -113,6 +85,7 @@ class DextoAgent {
   promptManager;
   stateManager;
   sessionManager;
+  workspaceManager;
   toolManager;
   resourceManager;
   memoryManager;
@@ -135,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.
@@ -153,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);
@@ -168,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");
@@ -181,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 }`
         );
       }
@@ -195,6 +246,7 @@ Either:
         systemPromptManager: services.systemPromptManager,
         stateManager: services.stateManager,
         sessionManager: services.sessionManager,
+        workspaceManager: services.workspaceManager,
         memoryManager: services.memoryManager,
         services
       });
@@ -208,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,
@@ -221,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;
@@ -264,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(`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) {
@@ -281,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();
@@ -319,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.
@@ -571,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 });
@@ -948,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.
@@ -1232,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", {
@@ -1303,16 +1454,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
     );
@@ -1594,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.
    */
@@ -2101,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.
    *
@@ -2257,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
 };

package/dist/{context/compaction/provider.cjs → agent/agent-options.cjs}

@@ -12,5 +12,5 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var provider_exports = {};
-module.exports = __toCommonJS(provider_exports);
+var agent_options_exports = {};
+module.exports = __toCommonJS(agent_options_exports);

package/dist/agent/agent-options.d.ts

@@ -0,0 +1,53 @@
+import type { BlobStore } from '../storage/blob/types.js';
+import type { Cache } from '../storage/cache/types.js';
+import type { Database } from '../storage/database/types.js';
+import type { CompactionStrategy } from '../context/compaction/types.js';
+import type { Logger } from '../logger/v2/types.js';
+import type { Hook } from '../hooks/types.js';
+import type { Tool } from '../tools/types.js';
+import type { InitializeServicesOptions } from '../utils/service-initializer.js';
+import type { DextoAgentConfigInput } from './runtime-config.js';
+/**
+ * Constructor options for {@link DextoAgent}.
+ *
+ * This is the DI-first surface that replaces passing YAML-derived provider configs into core.
+ * Product layers (CLI/server/platform) are responsible for:
+ * - parsing/validating YAML into config sections
+ * - applying image defaults
+ * - resolving tool/storage/hook/compaction/logger instances via image factories
+ *
+ * Core normalizes + validates runtime settings (LLM/MCP/sessions/etc.) and receives concrete instances.
+ */
+export interface DextoAgentOptions {
+    /**
+     * Optional service overrides for host environments (e.g. tests, servers).
+     * This preserves the existing override pattern while we migrate to a DI-first resolver.
+     */
+    overrides?: InitializeServicesOptions | undefined;
+    /**
+     * Logger instance scoped to this agent.
+     *
+     * Product layers should typically create this from `config.logger` via `createLogger()`,
+     * but may supply a custom implementation.
+     */
+    logger: Logger;
+    /** Concrete storage backends (DI-first). */
+    storage: {
+        blob: BlobStore;
+        database: Database;
+        cache: Cache;
+    };
+    /** Concrete tool implementations (DI-first). */
+    tools?: Tool[] | undefined;
+    /** Concrete hooks installed for the agent (DI-first). */
+    hooks?: Hook[] | undefined;
+    /**
+     * Context compaction controller (DI-first).
+     *
+     * If omitted/null, automatic compaction is disabled.
+     */
+    compaction?: CompactionStrategy | null | undefined;
+}
+export interface DextoAgentOptions extends DextoAgentConfigInput {
+}
+//# sourceMappingURL=agent-options.d.ts.map

package/dist/agent/agent-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-options.d.ts","sourceRoot":"","sources":["../../src/agent/agent-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAW9B;;;OAGG;IACH,SAAS,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;IAElD;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf,4CAA4C;IAC5C,OAAO,EAAE;QAAE,IAAI,EAAE,SAAS,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IAE/D,gDAAgD;IAChD,KAAK,CAAC,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC;IAE3B,yDAAyD;IACzD,KAAK,CAAC,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC;IAE3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,CAAC;CACtD;AAED,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;CAAG"}

package/dist/agent/agentCard.cjs

@@ -21,7 +21,7 @@ __export(agentCard_exports, {
   createAgentCard: () => createAgentCard
 });
 module.exports = __toCommonJS(agentCard_exports);
-var import_schemas = require("./schemas.cjs");
+var import_schemas = require("./schemas.js");
 const DEFAULT_AGENT_DESCRIPTION = "Dexto is an AI assistant capable of chat and task delegation, accessible via multiple protocols.";
 function createAgentCard(context, overrides) {
   const { defaultName, defaultVersion, defaultBaseUrl } = context;