@dexto/core 1.1.10 → 1.1.11

package/dist/utils/schema-metadata.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Schema metadata extraction utilities for Zod schemas
+ *
+ * This module provides utilities to extract metadata from Zod schemas at runtime.
+ *
+ * IMPORTANT: This uses Zod's private `._def` API which is not officially supported
+ * and may break in future Zod versions. We use this approach because:
+ * 1. No public Zod API exists for runtime schema introspection
+ * 2. Benefits of schema-driven UI metadata outweigh version risk
+ * 3. Changes would be caught by TypeScript/tests during upgrades
+ *
+ * TODO: Update web UI to use these helpers to reduce total code volume and improve maintainability. Also fix these helpers if needed.
+ * See packages/webui/components/AgentEditor/CustomizePanel.tsx for the UI side TODO tracking this same goal.
+ *
+ * If Zod provides official introspection APIs in the future, migrate to those.
+ */
+import { z } from 'zod';
+/**
+ * Metadata extracted from a Zod schema
+ */
+export interface SchemaMetadata {
+    /** Default values for each field */
+    defaults: Record<string, unknown>;
+    /** Required fields (not optional, not with defaults) */
+    requiredFields: string[];
+    /** Field type information */
+    fieldTypes: Record<string, string>;
+    /** Field descriptions from .describe() calls */
+    descriptions: Record<string, string>;
+    /** Enum values for enum fields (e.g., provider: ['openai', 'anthropic']) */
+    enumValues: Record<string, string[]>;
+}
+/**
+ * Extract metadata from a discriminated union schema
+ * Handles schemas like McpServerConfigSchema (stdio | sse | http)
+ */
+export interface DiscriminatedUnionMetadata {
+    /** The discriminator field name (e.g., "type") */
+    discriminator: string;
+    /** Possible discriminator values (e.g., ["stdio", "sse", "http"]) */
+    options: string[];
+    /** Metadata for each option */
+    schemas: Record<string, SchemaMetadata>;
+}
+/**
+ * Extract metadata from a Zod object schema
+ *
+ * @param schema - Zod schema to extract metadata from
+ * @returns SchemaMetadata object with defaults, required fields, types, and descriptions
+ */
+export declare function extractSchemaMetadata(schema: z.ZodTypeAny): SchemaMetadata;
+/**
+ * Extract metadata from a discriminated union schema
+ *
+ * @param schema - Zod discriminated union schema
+ * @returns DiscriminatedUnionMetadata with info about each variant
+ */
+export declare function extractDiscriminatedUnionMetadata(schema: z.ZodTypeAny): DiscriminatedUnionMetadata;
+/**
+ * Extract common fields from a discriminated union (fields present in all variants)
+ * Useful for extracting shared defaults like 'timeout' or 'connectionMode'
+ */
+export declare function extractCommonFields(metadata: DiscriminatedUnionMetadata): SchemaMetadata;
+/**
+ * Get default value for a specific field in a discriminated union variant
+ *
+ * @param metadata - Discriminated union metadata
+ * @param discriminatorValue - The discriminator value (e.g., 'stdio', 'http')
+ * @param fieldName - The field to get default for
+ * @returns The default value or undefined
+ */
+export declare function getFieldDefault(metadata: DiscriminatedUnionMetadata, discriminatorValue: string, fieldName: string): unknown;
+/**
+ * Check if a field is required in a specific discriminated union variant
+ *
+ * @param metadata - Discriminated union metadata
+ * @param discriminatorValue - The discriminator value (e.g., 'stdio', 'http')
+ * @param fieldName - The field to check
+ * @returns true if required, false otherwise
+ */
+export declare function isFieldRequiredInVariant(metadata: DiscriminatedUnionMetadata, discriminatorValue: string, fieldName: string): boolean;
+//# sourceMappingURL=schema-metadata.d.ts.map

package/dist/utils/schema-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/schema-metadata.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,wDAAwD;IACxD,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACvC,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C;AA0JD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,cAAc,CAqD1E;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC7C,MAAM,EAAE,CAAC,CAAC,UAAU,GACrB,0BAA0B,CAgC5B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,0BAA0B,GAAG,cAAc,CAiExF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,0BAA0B,EACpC,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAClB,OAAO,CAET;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACpC,QAAQ,EAAE,0BAA0B,EACpC,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAClB,OAAO,CAET"}

package/dist/utils/schema-metadata.js

@@ -0,0 +1,207 @@
+function extractDefault(def) {
+  if (def.defaultValue !== void 0) {
+    return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractDefault(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  return void 0;
+}
+function extractEnumValues(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractEnumValues(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractEnumValues(def.schema._def);
+  }
+  if (def.typeName === "ZodEnum") {
+    return def.values;
+  }
+  if (def.typeName === "ZodLiteral") {
+    return [String(def.value)];
+  }
+  return void 0;
+}
+function extractTypeName(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractTypeName(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodLiteral") {
+    return `literal(${JSON.stringify(def.value)})`;
+  }
+  if (def.typeName === "ZodEnum") {
+    return `enum(${def.values.join("|")})`;
+  }
+  if (def.typeName === "ZodArray") {
+    return `array<${extractTypeName(def.type._def)}>`;
+  }
+  if (def.typeName === "ZodRecord") {
+    return `record<${extractTypeName(def.valueType._def)}>`;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractTypeName(def.schema._def);
+  }
+  const typeMap = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBoolean: "boolean",
+    ZodObject: "object",
+    ZodArray: "array",
+    ZodRecord: "record",
+    ZodUnion: "union",
+    ZodDiscriminatedUnion: "discriminatedUnion"
+  };
+  return typeMap[def.typeName] || def.typeName?.replace("Zod", "").toLowerCase() || "unknown";
+}
+function isFieldRequired(def) {
+  if (def.defaultValue !== void 0) {
+    return false;
+  }
+  if (def.typeName === "ZodOptional") {
+    return false;
+  }
+  if (def.typeName === "ZodNullable") {
+    return false;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return isFieldRequired(def.type._def);
+  }
+  return true;
+}
+function extractSchemaMetadata(schema) {
+  const metadata = {
+    defaults: {},
+    requiredFields: [],
+    fieldTypes: {},
+    descriptions: {},
+    enumValues: {}
+  };
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName !== "ZodObject") {
+    throw new Error(`Expected ZodObject, got ${def.typeName}`);
+  }
+  const shape = def.shape();
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    const fieldDef = fieldSchema._def;
+    const defaultValue = extractDefault(fieldDef);
+    if (defaultValue !== void 0) {
+      metadata.defaults[fieldName] = defaultValue;
+    }
+    if (isFieldRequired(fieldDef)) {
+      metadata.requiredFields.push(fieldName);
+    }
+    metadata.fieldTypes[fieldName] = extractTypeName(fieldDef);
+    if (fieldDef.description) {
+      metadata.descriptions[fieldName] = fieldDef.description;
+    }
+    const enumVals = extractEnumValues(fieldDef);
+    if (enumVals) {
+      metadata.enumValues[fieldName] = enumVals;
+    }
+  }
+  return metadata;
+}
+function extractDiscriminatedUnionMetadata(schema) {
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    def = def.schema._def;
+  }
+  if (def.typeName !== "ZodDiscriminatedUnion") {
+    throw new Error(`Expected ZodDiscriminatedUnion, got ${def.typeName}`);
+  }
+  const discriminator = def.discriminator;
+  const optionsMap = def.optionsMap;
+  const metadata = {
+    discriminator,
+    options: Array.from(optionsMap.keys()),
+    schemas: {}
+  };
+  for (const [optionValue, optionSchema] of optionsMap.entries()) {
+    metadata.schemas[optionValue] = extractSchemaMetadata(optionSchema);
+  }
+  return metadata;
+}
+function extractCommonFields(metadata) {
+  const schemas = Object.values(metadata.schemas);
+  if (schemas.length === 0) {
+    return {
+      defaults: {},
+      requiredFields: [],
+      fieldTypes: {},
+      descriptions: {},
+      enumValues: {}
+    };
+  }
+  const first = schemas[0];
+  const rest = schemas.slice(1);
+  const common = {
+    defaults: { ...first.defaults },
+    requiredFields: [...first.requiredFields],
+    fieldTypes: { ...first.fieldTypes },
+    descriptions: { ...first.descriptions },
+    enumValues: { ...first.enumValues }
+  };
+  for (const schema of rest) {
+    for (const key of Object.keys(common.defaults)) {
+      if (!(key in schema.defaults) || schema.defaults[key] !== common.defaults[key]) {
+        delete common.defaults[key];
+      }
+    }
+    common.requiredFields = common.requiredFields.filter(
+      (field) => schema.requiredFields.includes(field)
+    );
+    for (const key of Object.keys(common.fieldTypes)) {
+      if (!(key in schema.fieldTypes) || schema.fieldTypes[key] !== common.fieldTypes[key]) {
+        delete common.fieldTypes[key];
+      }
+    }
+    for (const key of Object.keys(common.descriptions)) {
+      if (!(key in schema.descriptions) || schema.descriptions[key] !== common.descriptions[key]) {
+        delete common.descriptions[key];
+      }
+    }
+    for (const key of Object.keys(common.enumValues)) {
+      if (!(key in schema.enumValues) || JSON.stringify(schema.enumValues[key]) !== JSON.stringify(common.enumValues[key])) {
+        delete common.enumValues[key];
+      }
+    }
+  }
+  return common;
+}
+function getFieldDefault(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.defaults[fieldName];
+}
+function isFieldRequiredInVariant(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.requiredFields.includes(fieldName) ?? false;
+}
+export {
+  extractCommonFields,
+  extractDiscriminatedUnionMetadata,
+  extractSchemaMetadata,
+  getFieldDefault,
+  isFieldRequiredInVariant
+};

package/dist/utils/schema.d.ts

@@ -1,6 +1,5 @@
 /**
  * Convert Zod schema to JSON Schema format for tool parameters
  */
-declare function convertZodSchemaToJsonSchema(zodSchema: any): any;
-
-export { convertZodSchemaToJsonSchema };
+export declare function convertZodSchemaToJsonSchema(zodSchema: any): any;
+//# sourceMappingURL=schema.d.ts.map

package/dist/utils/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/utils/schema.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,GAAG,GAAG,GAAG,CAchE"}

package/dist/utils/service-initializer.cjs

@@ -23,49 +23,67 @@ __export(service_initializer_exports, {
 module.exports = __toCommonJS(service_initializer_exports);
 var import_manager = require("../mcp/manager.js");
 var import_tool_manager = require("../tools/tool-manager.js");
-var import_factory = require("../tools/confirmation/factory.js");
 var import_manager2 = require("../systemPrompt/manager.js");
 var import_state_manager = require("../agent/state-manager.js");
 var import_session = require("../session/index.js");
 var import_search = require("../search/index.js");
 var import_path = require("path");
 var import_storage = require("../storage/index.js");
-var import_factory2 = require("../tools/confirmation/allowed-tools-provider/factory.js");
+var import_factory = require("../tools/confirmation/allowed-tools-provider/factory.js");
 var import_logger = require("../logger/index.js");
 var import_events = require("../events/index.js");
+var import_manager3 = require("../resources/manager.js");
+var import_manager4 = require("../approval/manager.js");
+var import_memory = require("../memory/index.js");
+var import_manager5 = require("../plugins/manager.js");
+var import_builtins = require("../plugins/registrations/builtins.js");
 async function createAgentServices(config, configPath) {
   const agentEventBus = new import_events.AgentEventBus();
   import_logger.logger.debug("Agent event bus initialized");
-  import_logger.logger.debug("Initializing storage backends");
-  const storageResult = await (0, import_storage.createStorageBackends)(config.storage);
-  const storage = storageResult.backends;
-  const storageManager = storageResult.manager;
-  import_logger.logger.debug("Storage backends initialized", {
+  import_logger.logger.debug("Initializing storage manager");
+  const storageManager = await (0, import_storage.createStorageManager)(config.storage);
+  import_logger.logger.debug("Storage manager initialized", {
     cache: config.storage.cache.type,
     database: config.storage.database.type
   });
-  const allowedToolsProvider = (0, import_factory2.createAllowedToolsProvider)({
-    type: config.toolConfirmation.allowedToolsStorage,
-    storage
+  import_logger.logger.debug("Initializing approval manager");
+  const approvalManager = new import_manager4.ApprovalManager(agentEventBus, {
+    mode: config.toolConfirmation.mode,
+    timeout: config.toolConfirmation.timeout
   });
-  const confirmationProvider = (0, import_factory.createToolConfirmationProvider)(
-    config.toolConfirmation.mode === "event-based" ? {
-      mode: config.toolConfirmation.mode,
-      allowedToolsProvider,
-      agentEventBus,
-      confirmationTimeout: config.toolConfirmation.timeout
-    } : {
-      mode: config.toolConfirmation.mode,
-      allowedToolsProvider
-    }
-  );
+  import_logger.logger.debug("Approval system initialized");
   const mcpManager = new import_manager.MCPManager();
   await mcpManager.initializeFromConfig(config.mcpServers);
-  const searchService = new import_search.SearchService(storage.database);
-  const toolManager = new import_tool_manager.ToolManager(mcpManager, confirmationProvider, {
-    internalToolsServices: { searchService },
-    internalToolsConfig: config.internalTools
+  mcpManager.setApprovalManager(approvalManager);
+  import_logger.logger.debug("Approval manager connected to MCP manager for elicitation support");
+  const searchService = new import_search.SearchService(storageManager.getDatabase());
+  const memoryManager = new import_memory.MemoryManager(storageManager.getDatabase());
+  import_logger.logger.debug("Memory manager initialized");
+  const configDir = configPath ? (0, import_path.dirname)((0, import_path.resolve)(configPath)) : process.cwd();
+  const pluginManager = new import_manager5.PluginManager({
+    agentEventBus,
+    storageManager,
+    configDir
+  });
+  (0, import_builtins.registerBuiltInPlugins)({ pluginManager, config });
+  import_logger.logger.debug("Built-in plugins registered");
+  await pluginManager.initialize(config.plugins.custom);
+  import_logger.logger.info("Plugin manager initialized");
+  const allowedToolsProvider = (0, import_factory.createAllowedToolsProvider)({
+    type: config.toolConfirmation.allowedToolsStorage,
+    storageManager
   });
+  const toolManager = new import_tool_manager.ToolManager(
+    mcpManager,
+    approvalManager,
+    allowedToolsProvider,
+    config.toolConfirmation.mode,
+    agentEventBus,
+    {
+      internalToolsServices: { searchService },
+      internalToolsConfig: config.internalTools
+    }
+  );
   await toolManager.initialize();
   const mcpServerCount = Object.keys(config.mcpServers).length;
   if (mcpServerCount === 0) {
@@ -78,21 +96,35 @@ async function createAgentServices(config, configPath) {
   } else {
     import_logger.logger.info(`Internal tools enabled: ${config.internalTools.join(", ")}`);
   }
-  const configDir = configPath ? (0, import_path.dirname)((0, import_path.resolve)(configPath)) : process.cwd();
   import_logger.logger.debug(
-    `[ServiceInitializer] Creating PromptManager with configPath: ${configPath} \u2192 configDir: ${configDir}`
+    `[ServiceInitializer] Creating SystemPromptManager with configPath: ${configPath} \u2192 configDir: ${configDir}`
+  );
+  const systemPromptManager = new import_manager2.SystemPromptManager(
+    config.systemPrompt,
+    configDir,
+    memoryManager
   );
-  const promptManager = new import_manager2.PromptManager(config.systemPrompt, configDir);
   const stateManager = new import_state_manager.AgentStateManager(config, agentEventBus);
   import_logger.logger.debug("Agent state manager initialized");
+  const resourceManager = new import_manager3.ResourceManager(mcpManager, {
+    internalResourcesConfig: config.internalResources,
+    blobStore: storageManager.getBlobStore()
+  });
+  await resourceManager.initialize();
   const sessionManager = new import_session.SessionManager(
     {
       stateManager,
-      promptManager,
+      systemPromptManager,
       toolManager,
       agentEventBus,
-      storage
-      // Add storage backends to session services
+      storageManager,
+      // Add storage manager to session services
+      resourceManager,
+      // Add resource manager for blob storage
+      pluginManager,
+      // Add plugin manager for plugin execution
+      mcpManager
+      // Add MCP manager for ChatSession
     },
     {
       maxSessions: config.sessions?.maxSessions,
@@ -101,16 +133,21 @@ async function createAgentServices(config, configPath) {
   );
   await sessionManager.init();
   import_logger.logger.debug("Session manager initialized with storage support");
+  toolManager.setPluginSupport(pluginManager, sessionManager, stateManager);
+  import_logger.logger.debug("Plugin support connected to ToolManager");
   return {
     mcpManager,
     toolManager,
-    promptManager,
+    systemPromptManager,
     agentEventBus,
     stateManager,
     sessionManager,
     searchService,
-    storage,
-    storageManager
+    storageManager,
+    resourceManager,
+    approvalManager,
+    memoryManager,
+    pluginManager
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/utils/service-initializer.d.ts

@@ -1,56 +1,32 @@
 import { MCPManager } from '../mcp/manager.js';
 import { ToolManager } from '../tools/tool-manager.js';
-import { PromptManager } from '../systemPrompt/manager.js';
+import { SystemPromptManager } from '../systemPrompt/manager.js';
 import { AgentStateManager } from '../agent/state-manager.js';
-import { StorageBackends } from '../storage/backend/types.js';
+import { SessionManager } from '../session/index.js';
+import { SearchService } from '../search/index.js';
+import { StorageManager } from '../storage/index.js';
+import type { ValidatedAgentConfig } from '../agent/schemas.js';
 import { AgentEventBus } from '../events/index.js';
-import { SessionManager } from '../session/session-manager.js';
-import { SearchService } from '../search/search-service.js';
-import { StorageManager } from '../storage/storage-manager.js';
-import { ValidatedAgentConfig } from '../agent/schemas.js';
-import '../mcp/schemas.js';
-import 'zod';
-import '../mcp/types.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '../tools/types.js';
-import 'json-schema';
-import '@modelcontextprotocol/sdk/types.js';
-import '../tools/internal-tools/registry.js';
-import '../storage/backend/database-backend.js';
-import '../search/types.js';
-import '../context/types.js';
-import '../llm/types.js';
-import '../tools/schemas.js';
-import '../tools/confirmation/types.js';
-import '../tools/confirmation/allowed-tools-provider/types.js';
-import '../systemPrompt/schemas.js';
-import '../systemPrompt/types.js';
-import '../llm/schemas.js';
-import 'events';
-import '../storage/backend/cache-backend.js';
-import '../storage/schemas.js';
-import '../session/chat-session.js';
-import '../context/manager.js';
-import '../llm/formatters/types.js';
-import '../llm/tokenizer/types.js';
-import '../context/compression/types.js';
-import '../session/history/types.js';
-import '../llm/services/types.js';
-import 'ai';
-
+import { ResourceManager } from '../resources/manager.js';
+import { ApprovalManager } from '../approval/manager.js';
+import { MemoryManager } from '../memory/index.js';
+import { PluginManager } from '../plugins/manager.js';
 /**
  * Type for the core agent services returned by createAgentServices
  */
-type AgentServices = {
+export type AgentServices = {
     mcpManager: MCPManager;
     toolManager: ToolManager;
-    promptManager: PromptManager;
+    systemPromptManager: SystemPromptManager;
     agentEventBus: AgentEventBus;
     stateManager: AgentStateManager;
     sessionManager: SessionManager;
     searchService: SearchService;
-    storage: StorageBackends;
-    storageManager?: StorageManager;
+    storageManager: StorageManager;
+    resourceManager: ResourceManager;
+    approvalManager: ApprovalManager;
+    memoryManager: MemoryManager;
+    pluginManager: PluginManager;
 };
 /**
  * Initializes all agent services from a validated configuration.
@@ -58,6 +34,5 @@ type AgentServices = {
  * @param configPath Optional path to the config file (for relative path resolution)
  * @returns All the initialized services required for a Dexto agent
  */
-declare function createAgentServices(config: ValidatedAgentConfig, configPath?: string): Promise<AgentServices>;
-
-export { type AgentServices, createAgentServices };
+export declare function createAgentServices(config: ValidatedAgentConfig, configPath?: string): Promise<AgentServices>;
+//# sourceMappingURL=service-initializer.d.ts.map

package/dist/utils/service-initializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-initializer.d.ts","sourceRoot":"","sources":["../../src/utils/service-initializer.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAwB,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,iBAAiB,CAAC;IAChC,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,eAAe,EAAE,eAAe,CAAC;IACjC,aAAa,EAAE,aAAa,CAAC;IAC7B,aAAa,EAAE,aAAa,CAAC;CAChC,CAAC;AAGF;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACrC,MAAM,EAAE,oBAAoB,EAC5B,UAAU,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAuJxB"}