@dexto/core 1.1.4 → 1.1.6

package/dist/utils/service-initializer.cjs

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var service_initializer_exports = {};
+__export(service_initializer_exports, {
+  createAgentServices: () => createAgentServices
+});
+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_logger = require("../logger/index.js");
+var import_events = require("../events/index.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", {
+    cache: config.storage.cache.type,
+    database: config.storage.database.type
+  });
+  const allowedToolsProvider = (0, import_factory2.createAllowedToolsProvider)({
+    type: config.toolConfirmation.allowedToolsStorage,
+    storage
+  });
+  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
+    }
+  );
+  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
+  });
+  await toolManager.initialize();
+  const mcpServerCount = Object.keys(config.mcpServers).length;
+  if (mcpServerCount === 0) {
+    import_logger.logger.info("Agent initialized without MCP servers - only built-in capabilities available");
+  } else {
+    import_logger.logger.debug(`MCPManager initialized with ${mcpServerCount} MCP server(s)`);
+  }
+  if (config.internalTools.length === 0) {
+    import_logger.logger.info("No internal tools enabled by configuration");
+  } 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}`
+  );
+  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 sessionManager = new import_session.SessionManager(
+    {
+      stateManager,
+      promptManager,
+      toolManager,
+      agentEventBus,
+      storage
+      // Add storage backends to session services
+    },
+    {
+      maxSessions: config.sessions?.maxSessions,
+      sessionTTL: config.sessions?.sessionTTL
+    }
+  );
+  await sessionManager.init();
+  import_logger.logger.debug("Session manager initialized with storage support");
+  return {
+    mcpManager,
+    toolManager,
+    promptManager,
+    agentEventBus,
+    stateManager,
+    sessionManager,
+    searchService,
+    storage,
+    storageManager
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAgentServices
+});

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

@@ -0,0 +1,63 @@
+import { MCPManager } from '../mcp/manager.cjs';
+import { ToolManager } from '../tools/tool-manager.cjs';
+import { PromptManager } from '../systemPrompt/manager.cjs';
+import { AgentStateManager } from '../agent/state-manager.cjs';
+import { StorageBackends } from '../storage/backend/types.cjs';
+import { AgentEventBus } from '../events/index.cjs';
+import { SessionManager } from '../session/session-manager.cjs';
+import { SearchService } from '../search/search-service.cjs';
+import { StorageManager } from '../storage/storage-manager.cjs';
+import { ValidatedAgentConfig } from '../agent/schemas.cjs';
+import '../mcp/schemas.cjs';
+import 'zod';
+import '../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '../tools/types.cjs';
+import 'json-schema';
+import '@modelcontextprotocol/sdk/types.js';
+import '../tools/internal-tools/registry.cjs';
+import '../storage/backend/database-backend.cjs';
+import '../search/types.cjs';
+import '../context/types.cjs';
+import '../llm/types.cjs';
+import '../tools/schemas.cjs';
+import '../tools/confirmation/types.cjs';
+import '../tools/confirmation/allowed-tools-provider/types.cjs';
+import '../systemPrompt/schemas.cjs';
+import '../systemPrompt/types.cjs';
+import '../llm/schemas.cjs';
+import 'events';
+import '../storage/backend/cache-backend.cjs';
+import '../storage/schemas.cjs';
+import '../session/chat-session.cjs';
+import '../context/manager.cjs';
+import '../llm/formatters/types.cjs';
+import '../llm/tokenizer/types.cjs';
+import '../context/compression/types.cjs';
+import '../session/history/types.cjs';
+import '../llm/services/types.cjs';
+import 'ai';
+
+/**
+ * Type for the core agent services returned by createAgentServices
+ */
+type AgentServices = {
+    mcpManager: MCPManager;
+    toolManager: ToolManager;
+    promptManager: PromptManager;
+    agentEventBus: AgentEventBus;
+    stateManager: AgentStateManager;
+    sessionManager: SessionManager;
+    searchService: SearchService;
+    storage: StorageBackends;
+    storageManager?: StorageManager;
+};
+/**
+ * Initializes all agent services from a validated configuration.
+ * @param config The validated agent configuration object
+ * @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 };

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

@@ -0,0 +1,63 @@
+import { MCPManager } from '../mcp/manager.js';
+import { ToolManager } from '../tools/tool-manager.js';
+import { PromptManager } from '../systemPrompt/manager.js';
+import { AgentStateManager } from '../agent/state-manager.js';
+import { StorageBackends } from '../storage/backend/types.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';
+
+/**
+ * Type for the core agent services returned by createAgentServices
+ */
+type AgentServices = {
+    mcpManager: MCPManager;
+    toolManager: ToolManager;
+    promptManager: PromptManager;
+    agentEventBus: AgentEventBus;
+    stateManager: AgentStateManager;
+    sessionManager: SessionManager;
+    searchService: SearchService;
+    storage: StorageBackends;
+    storageManager?: StorageManager;
+};
+/**
+ * Initializes all agent services from a validated configuration.
+ * @param config The validated agent configuration object
+ * @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 };

package/dist/utils/service-initializer.js

@@ -0,0 +1,95 @@
+import { MCPManager } from "../mcp/manager.js";
+import { ToolManager } from "../tools/tool-manager.js";
+import { createToolConfirmationProvider } from "../tools/confirmation/factory.js";
+import { PromptManager } from "../systemPrompt/manager.js";
+import { AgentStateManager } from "../agent/state-manager.js";
+import { SessionManager } from "../session/index.js";
+import { SearchService } from "../search/index.js";
+import { dirname, resolve } from "path";
+import { createStorageBackends } from "../storage/index.js";
+import { createAllowedToolsProvider } from "../tools/confirmation/allowed-tools-provider/factory.js";
+import { logger } from "../logger/index.js";
+import { AgentEventBus } from "../events/index.js";
+async function createAgentServices(config, configPath) {
+  const agentEventBus = new AgentEventBus();
+  logger.debug("Agent event bus initialized");
+  logger.debug("Initializing storage backends");
+  const storageResult = await createStorageBackends(config.storage);
+  const storage = storageResult.backends;
+  const storageManager = storageResult.manager;
+  logger.debug("Storage backends initialized", {
+    cache: config.storage.cache.type,
+    database: config.storage.database.type
+  });
+  const allowedToolsProvider = createAllowedToolsProvider({
+    type: config.toolConfirmation.allowedToolsStorage,
+    storage
+  });
+  const confirmationProvider = createToolConfirmationProvider(
+    config.toolConfirmation.mode === "event-based" ? {
+      mode: config.toolConfirmation.mode,
+      allowedToolsProvider,
+      agentEventBus,
+      confirmationTimeout: config.toolConfirmation.timeout
+    } : {
+      mode: config.toolConfirmation.mode,
+      allowedToolsProvider
+    }
+  );
+  const mcpManager = new MCPManager();
+  await mcpManager.initializeFromConfig(config.mcpServers);
+  const searchService = new SearchService(storage.database);
+  const toolManager = new ToolManager(mcpManager, confirmationProvider, {
+    internalToolsServices: { searchService },
+    internalToolsConfig: config.internalTools
+  });
+  await toolManager.initialize();
+  const mcpServerCount = Object.keys(config.mcpServers).length;
+  if (mcpServerCount === 0) {
+    logger.info("Agent initialized without MCP servers - only built-in capabilities available");
+  } else {
+    logger.debug(`MCPManager initialized with ${mcpServerCount} MCP server(s)`);
+  }
+  if (config.internalTools.length === 0) {
+    logger.info("No internal tools enabled by configuration");
+  } else {
+    logger.info(`Internal tools enabled: ${config.internalTools.join(", ")}`);
+  }
+  const configDir = configPath ? dirname(resolve(configPath)) : process.cwd();
+  logger.debug(
+    `[ServiceInitializer] Creating PromptManager with configPath: ${configPath} \u2192 configDir: ${configDir}`
+  );
+  const promptManager = new PromptManager(config.systemPrompt, configDir);
+  const stateManager = new AgentStateManager(config, agentEventBus);
+  logger.debug("Agent state manager initialized");
+  const sessionManager = new SessionManager(
+    {
+      stateManager,
+      promptManager,
+      toolManager,
+      agentEventBus,
+      storage
+      // Add storage backends to session services
+    },
+    {
+      maxSessions: config.sessions?.maxSessions,
+      sessionTTL: config.sessions?.sessionTTL
+    }
+  );
+  await sessionManager.init();
+  logger.debug("Session manager initialized with storage support");
+  return {
+    mcpManager,
+    toolManager,
+    promptManager,
+    agentEventBus,
+    stateManager,
+    sessionManager,
+    searchService,
+    storage,
+    storageManager
+  };
+}
+export {
+  createAgentServices
+};

package/dist/utils/user-info.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var user_info_exports = {};
+__export(user_info_exports, {
+  getUserId: () => getUserId
+});
+module.exports = __toCommonJS(user_info_exports);
+function getUserId() {
+  return "default-user";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUserId
+});

package/dist/utils/user-info.d.cts

@@ -0,0 +1,3 @@
+declare function getUserId(): string;
+
+export { getUserId };

package/dist/utils/user-info.d.ts

@@ -0,0 +1,3 @@
+declare function getUserId(): string;
+
+export { getUserId };

package/dist/utils/user-info.js

@@ -0,0 +1,6 @@
+function getUserId() {
+  return "default-user";
+}
+export {
+  getUserId
+};

package/dist/utils/zod-schema-converter.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var zod_schema_converter_exports = {};
+__export(zod_schema_converter_exports, {
+  getZodTypeFromProperty: () => getZodTypeFromProperty,
+  jsonSchemaToZodShape: () => jsonSchemaToZodShape
+});
+module.exports = __toCommonJS(zod_schema_converter_exports);
+var import_zod = require("zod");
+function jsonSchemaToZodShape(jsonSchema) {
+  if (!jsonSchema || typeof jsonSchema !== "object" || jsonSchema.type !== "object") {
+    return {};
+  }
+  const shape = {};
+  if (jsonSchema.properties) {
+    for (const [key, property] of Object.entries(jsonSchema.properties)) {
+      const propSchema = property;
+      let zodType;
+      switch (propSchema.type) {
+        case "string":
+          zodType = import_zod.z.string();
+          break;
+        case "number":
+          zodType = import_zod.z.number();
+          break;
+        case "integer":
+          zodType = import_zod.z.number().int();
+          break;
+        case "boolean":
+          zodType = import_zod.z.boolean();
+          break;
+        case "array":
+          if (propSchema.items) {
+            const itemType = getZodTypeFromProperty(propSchema.items);
+            zodType = import_zod.z.array(itemType);
+          } else {
+            zodType = import_zod.z.array(import_zod.z.any());
+          }
+          break;
+        case "object":
+          zodType = import_zod.z.object(jsonSchemaToZodShape(propSchema));
+          break;
+        default:
+          zodType = import_zod.z.any();
+      }
+      if (propSchema.description) {
+        zodType._def.description = propSchema.description;
+        zodType = zodType.describe(propSchema.description);
+      }
+      if (!jsonSchema.required || !jsonSchema.required.includes(key)) {
+        zodType = zodType.optional();
+      }
+      shape[key] = zodType;
+    }
+  }
+  return shape;
+}
+function getZodTypeFromProperty(propSchema) {
+  let zodType;
+  switch (propSchema.type) {
+    case "string":
+      zodType = import_zod.z.string();
+      break;
+    case "number":
+      zodType = import_zod.z.number();
+      break;
+    case "integer":
+      zodType = import_zod.z.number().int();
+      break;
+    case "boolean":
+      zodType = import_zod.z.boolean();
+      break;
+    case "object":
+      zodType = import_zod.z.object(jsonSchemaToZodShape(propSchema));
+      break;
+    case "array":
+      if (propSchema.items) {
+        zodType = import_zod.z.array(getZodTypeFromProperty(propSchema.items));
+      } else {
+        zodType = import_zod.z.array(import_zod.z.any());
+      }
+      break;
+    default:
+      zodType = import_zod.z.any();
+  }
+  if (propSchema.description) {
+    zodType._def.description = propSchema.description;
+    zodType = zodType.describe(propSchema.description);
+  }
+  return zodType;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getZodTypeFromProperty,
+  jsonSchemaToZodShape
+});

package/dist/utils/zod-schema-converter.d.cts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+/**
+ * Converts a JSON Schema object to a Zod raw shape.
+ * This is a simplified converter that handles common MCP tool schemas.
+ */
+declare function jsonSchemaToZodShape(jsonSchema: any): z.ZodRawShape;
+/**
+ * Helper function to get a Zod type from a property schema
+ */
+declare function getZodTypeFromProperty(propSchema: any): z.ZodTypeAny;
+
+export { getZodTypeFromProperty, jsonSchemaToZodShape };

package/dist/utils/zod-schema-converter.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+/**
+ * Converts a JSON Schema object to a Zod raw shape.
+ * This is a simplified converter that handles common MCP tool schemas.
+ */
+declare function jsonSchemaToZodShape(jsonSchema: any): z.ZodRawShape;
+/**
+ * Helper function to get a Zod type from a property schema
+ */
+declare function getZodTypeFromProperty(propSchema: any): z.ZodTypeAny;
+
+export { getZodTypeFromProperty, jsonSchemaToZodShape };

package/dist/utils/zod-schema-converter.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+function jsonSchemaToZodShape(jsonSchema) {
+  if (!jsonSchema || typeof jsonSchema !== "object" || jsonSchema.type !== "object") {
+    return {};
+  }
+  const shape = {};
+  if (jsonSchema.properties) {
+    for (const [key, property] of Object.entries(jsonSchema.properties)) {
+      const propSchema = property;
+      let zodType;
+      switch (propSchema.type) {
+        case "string":
+          zodType = z.string();
+          break;
+        case "number":
+          zodType = z.number();
+          break;
+        case "integer":
+          zodType = z.number().int();
+          break;
+        case "boolean":
+          zodType = z.boolean();
+          break;
+        case "array":
+          if (propSchema.items) {
+            const itemType = getZodTypeFromProperty(propSchema.items);
+            zodType = z.array(itemType);
+          } else {
+            zodType = z.array(z.any());
+          }
+          break;
+        case "object":
+          zodType = z.object(jsonSchemaToZodShape(propSchema));
+          break;
+        default:
+          zodType = z.any();
+      }
+      if (propSchema.description) {
+        zodType._def.description = propSchema.description;
+        zodType = zodType.describe(propSchema.description);
+      }
+      if (!jsonSchema.required || !jsonSchema.required.includes(key)) {
+        zodType = zodType.optional();
+      }
+      shape[key] = zodType;
+    }
+  }
+  return shape;
+}
+function getZodTypeFromProperty(propSchema) {
+  let zodType;
+  switch (propSchema.type) {
+    case "string":
+      zodType = z.string();
+      break;
+    case "number":
+      zodType = z.number();
+      break;
+    case "integer":
+      zodType = z.number().int();
+      break;
+    case "boolean":
+      zodType = z.boolean();
+      break;
+    case "object":
+      zodType = z.object(jsonSchemaToZodShape(propSchema));
+      break;
+    case "array":
+      if (propSchema.items) {
+        zodType = z.array(getZodTypeFromProperty(propSchema.items));
+      } else {
+        zodType = z.array(z.any());
+      }
+      break;
+    default:
+      zodType = z.any();
+  }
+  if (propSchema.description) {
+    zodType._def.description = propSchema.description;
+    zodType = zodType.describe(propSchema.description);
+  }
+  return zodType;
+}
+export {
+  getZodTypeFromProperty,
+  jsonSchemaToZodShape
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/core",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node scripts/fix-dist-aliases.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint . --ext .ts"
   }