@dexto/agent-config 1.6.0

package/dist/resolver/load-image.cjs

@@ -0,0 +1,139 @@
+"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 load_image_exports = {};
+__export(load_image_exports, {
+  loadImage: () => loadImage,
+  setImageImporter: () => setImageImporter
+});
+module.exports = __toCommonJS(load_image_exports);
+var import_utils = require("./utils.js");
+let configuredImageImporter;
+function setImageImporter(importer) {
+  configuredImageImporter = importer;
+}
+function assertFactoryMap(value, options) {
+  const { imageName, field } = options;
+  if (!(0, import_utils.isPlainObject)(value)) {
+    throw new Error(`Invalid image '${imageName}': expected '${field}' to be an object`);
+  }
+  for (const [key, factory] of Object.entries(value)) {
+    if (!(0, import_utils.isPlainObject)(factory)) {
+      throw new Error(
+        `Invalid image '${imageName}': expected '${field}.${key}' to be an object`
+      );
+    }
+    if (!(0, import_utils.isSchemaLike)(factory.configSchema)) {
+      throw new Error(
+        `Invalid image '${imageName}': expected '${field}.${key}.configSchema' to be a Zod schema`
+      );
+    }
+    if (typeof factory.create !== "function") {
+      throw new Error(
+        `Invalid image '${imageName}': expected '${field}.${key}.create' to be a function`
+      );
+    }
+  }
+}
+function assertDextoImage(value, imageName) {
+  if (!(0, import_utils.isPlainObject)(value)) {
+    throw new Error(`Invalid image '${imageName}': expected an object export`);
+  }
+  const metadata = value.metadata;
+  if (!(0, import_utils.isPlainObject)(metadata)) {
+    throw new Error(`Invalid image '${imageName}': missing required 'metadata' object`);
+  }
+  if (typeof metadata.name !== "string" || metadata.name.length === 0) {
+    throw new Error(`Invalid image '${imageName}': metadata.name must be a non-empty string`);
+  }
+  if (typeof metadata.version !== "string" || metadata.version.length === 0) {
+    throw new Error(
+      `Invalid image '${imageName}': metadata.version must be a non-empty string`
+    );
+  }
+  if (typeof metadata.description !== "string" || metadata.description.length === 0) {
+    throw new Error(
+      `Invalid image '${imageName}': metadata.description must be a non-empty string`
+    );
+  }
+  if (metadata.target !== void 0 && typeof metadata.target !== "string") {
+    throw new Error(
+      `Invalid image '${imageName}': metadata.target must be a string when provided`
+    );
+  }
+  if (metadata.constraints !== void 0) {
+    if (!Array.isArray(metadata.constraints) || metadata.constraints.some((c) => typeof c !== "string")) {
+      throw new Error(
+        `Invalid image '${imageName}': metadata.constraints must be string[] when provided`
+      );
+    }
+  }
+  assertFactoryMap(value.tools, { imageName, field: "tools" });
+  const storage = value.storage;
+  if (!(0, import_utils.isPlainObject)(storage)) {
+    throw new Error(`Invalid image '${imageName}': missing required 'storage' object`);
+  }
+  assertFactoryMap(storage.blob, { imageName, field: "storage.blob" });
+  assertFactoryMap(storage.database, { imageName, field: "storage.database" });
+  assertFactoryMap(storage.cache, { imageName, field: "storage.cache" });
+  assertFactoryMap(value.hooks, { imageName, field: "hooks" });
+  assertFactoryMap(value.compaction, { imageName, field: "compaction" });
+  const logger = value.logger;
+  if (!(0, import_utils.isPlainObject)(logger)) {
+    throw new Error(`Invalid image '${imageName}': missing required 'logger' factory`);
+  }
+  if (!(0, import_utils.isSchemaLike)(logger.configSchema)) {
+    throw new Error(`Invalid image '${imageName}': logger.configSchema must be a Zod schema`);
+  }
+  if (typeof logger.create !== "function") {
+    throw new Error(`Invalid image '${imageName}': logger.create must be a function`);
+  }
+}
+function extractImageExport(module2) {
+  if (!(0, import_utils.isPlainObject)(module2)) {
+    return module2;
+  }
+  if ("default" in module2 && module2.default !== void 0) {
+    return module2.default;
+  }
+  if ("image" in module2 && module2.image !== void 0) {
+    return module2.image;
+  }
+  return module2;
+}
+async function loadImage(imageName) {
+  let module2;
+  try {
+    const importer = configuredImageImporter ?? ((specifier) => import(specifier));
+    module2 = await importer(imageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to import image '${imageName}': ${message}
+If you're running under pnpm (strict dependency boundaries), call setImageImporter((s) => import(s)) from the host entrypoint.`
+    );
+  }
+  const candidate = extractImageExport(module2);
+  assertDextoImage(candidate, imageName);
+  return candidate;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadImage,
+  setImageImporter
+});

package/dist/resolver/load-image.d.ts

@@ -0,0 +1,13 @@
+import type { DextoImage } from '../image/types.js';
+export type ImageImporter = (specifier: string) => Promise<unknown>;
+/**
+ * Configure how images are dynamically imported.
+ *
+ * Why: In strict package manager layouts (pnpm), a helper inside `@dexto/agent-config`
+ * cannot reliably `import('@dexto/image-local')` because that image is not a dependency
+ * of agent-config. Hosts (CLI/server/apps) should call `setImageImporter((s) => import(s))`
+ * from their entrypoint so the import resolves relative to the host package.
+ */
+export declare function setImageImporter(importer: ImageImporter | undefined): void;
+export declare function loadImage(imageName: string): Promise<DextoImage>;
+//# sourceMappingURL=load-image.d.ts.map

package/dist/resolver/load-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-image.d.ts","sourceRoot":"","sources":["../../src/resolver/load-image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,MAAM,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAIpE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI,CAE1E;AA8GD,wBAAsB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAgBtE"}

package/dist/resolver/load-image.js

@@ -0,0 +1,114 @@
+import { isPlainObject, isSchemaLike } from "./utils.js";
+let configuredImageImporter;
+function setImageImporter(importer) {
+  configuredImageImporter = importer;
+}
+function assertFactoryMap(value, options) {
+  const { imageName, field } = options;
+  if (!isPlainObject(value)) {
+    throw new Error(`Invalid image '${imageName}': expected '${field}' to be an object`);
+  }
+  for (const [key, factory] of Object.entries(value)) {
+    if (!isPlainObject(factory)) {
+      throw new Error(
+        `Invalid image '${imageName}': expected '${field}.${key}' to be an object`
+      );
+    }
+    if (!isSchemaLike(factory.configSchema)) {
+      throw new Error(
+        `Invalid image '${imageName}': expected '${field}.${key}.configSchema' to be a Zod schema`
+      );
+    }
+    if (typeof factory.create !== "function") {
+      throw new Error(
+        `Invalid image '${imageName}': expected '${field}.${key}.create' to be a function`
+      );
+    }
+  }
+}
+function assertDextoImage(value, imageName) {
+  if (!isPlainObject(value)) {
+    throw new Error(`Invalid image '${imageName}': expected an object export`);
+  }
+  const metadata = value.metadata;
+  if (!isPlainObject(metadata)) {
+    throw new Error(`Invalid image '${imageName}': missing required 'metadata' object`);
+  }
+  if (typeof metadata.name !== "string" || metadata.name.length === 0) {
+    throw new Error(`Invalid image '${imageName}': metadata.name must be a non-empty string`);
+  }
+  if (typeof metadata.version !== "string" || metadata.version.length === 0) {
+    throw new Error(
+      `Invalid image '${imageName}': metadata.version must be a non-empty string`
+    );
+  }
+  if (typeof metadata.description !== "string" || metadata.description.length === 0) {
+    throw new Error(
+      `Invalid image '${imageName}': metadata.description must be a non-empty string`
+    );
+  }
+  if (metadata.target !== void 0 && typeof metadata.target !== "string") {
+    throw new Error(
+      `Invalid image '${imageName}': metadata.target must be a string when provided`
+    );
+  }
+  if (metadata.constraints !== void 0) {
+    if (!Array.isArray(metadata.constraints) || metadata.constraints.some((c) => typeof c !== "string")) {
+      throw new Error(
+        `Invalid image '${imageName}': metadata.constraints must be string[] when provided`
+      );
+    }
+  }
+  assertFactoryMap(value.tools, { imageName, field: "tools" });
+  const storage = value.storage;
+  if (!isPlainObject(storage)) {
+    throw new Error(`Invalid image '${imageName}': missing required 'storage' object`);
+  }
+  assertFactoryMap(storage.blob, { imageName, field: "storage.blob" });
+  assertFactoryMap(storage.database, { imageName, field: "storage.database" });
+  assertFactoryMap(storage.cache, { imageName, field: "storage.cache" });
+  assertFactoryMap(value.hooks, { imageName, field: "hooks" });
+  assertFactoryMap(value.compaction, { imageName, field: "compaction" });
+  const logger = value.logger;
+  if (!isPlainObject(logger)) {
+    throw new Error(`Invalid image '${imageName}': missing required 'logger' factory`);
+  }
+  if (!isSchemaLike(logger.configSchema)) {
+    throw new Error(`Invalid image '${imageName}': logger.configSchema must be a Zod schema`);
+  }
+  if (typeof logger.create !== "function") {
+    throw new Error(`Invalid image '${imageName}': logger.create must be a function`);
+  }
+}
+function extractImageExport(module) {
+  if (!isPlainObject(module)) {
+    return module;
+  }
+  if ("default" in module && module.default !== void 0) {
+    return module.default;
+  }
+  if ("image" in module && module.image !== void 0) {
+    return module.image;
+  }
+  return module;
+}
+async function loadImage(imageName) {
+  let module;
+  try {
+    const importer = configuredImageImporter ?? ((specifier) => import(specifier));
+    module = await importer(imageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to import image '${imageName}': ${message}
+If you're running under pnpm (strict dependency boundaries), call setImageImporter((s) => import(s)) from the host entrypoint.`
+    );
+  }
+  const candidate = extractImageExport(module);
+  assertDextoImage(candidate, imageName);
+  return candidate;
+}
+export {
+  loadImage,
+  setImageImporter
+};

package/dist/resolver/resolve-services-from-config.cjs

@@ -0,0 +1,146 @@
+"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 resolve_services_from_config_exports = {};
+__export(resolve_services_from_config_exports, {
+  resolveServicesFromConfig: () => resolveServicesFromConfig
+});
+module.exports = __toCommonJS(resolve_services_from_config_exports);
+var import_utils = require("./utils.js");
+const MCP_TOOL_PREFIX = "mcp--";
+function stripEnabled(entry) {
+  const obj = entry;
+  if (!Object.prototype.hasOwnProperty.call(obj, "enabled")) {
+    return obj;
+  }
+  const { enabled: _enabled, ...rest } = obj;
+  return rest;
+}
+function resolveByType(options) {
+  const { kind, type, factories, imageName } = options;
+  const factory = factories[type];
+  if (!factory) {
+    const available = Object.keys(factories).sort();
+    throw new Error(
+      `Unknown ${kind} type '${type}'. Available types from image '${imageName}': ${available.join(", ")}`
+    );
+  }
+  return factory;
+}
+async function resolveServicesFromConfig(config, image) {
+  const imageName = image.metadata.name;
+  const loggerFactoryInput = {
+    agentId: config.agentId,
+    config: config.logger
+  };
+  const loggerConfig = image.logger.configSchema.parse(loggerFactoryInput);
+  const logger = image.logger.create(loggerConfig);
+  const blobFactory = resolveByType({
+    kind: "blob storage",
+    type: config.storage.blob.type,
+    factories: image.storage.blob,
+    imageName
+  });
+  const databaseFactory = resolveByType({
+    kind: "database",
+    type: config.storage.database.type,
+    factories: image.storage.database,
+    imageName
+  });
+  const cacheFactory = resolveByType({
+    kind: "cache",
+    type: config.storage.cache.type,
+    factories: image.storage.cache,
+    imageName
+  });
+  const blobConfig = blobFactory.configSchema.parse(config.storage.blob);
+  const databaseConfig = databaseFactory.configSchema.parse(config.storage.database);
+  const cacheConfig = cacheFactory.configSchema.parse(config.storage.cache);
+  const storage = {
+    blob: await blobFactory.create(blobConfig, logger),
+    database: await databaseFactory.create(databaseConfig, logger),
+    cache: await cacheFactory.create(cacheConfig, logger)
+  };
+  const toolEntries = config.tools ?? image.defaults?.tools ?? [];
+  const tools = [];
+  const toolIds = /* @__PURE__ */ new Set();
+  for (const entry of toolEntries) {
+    if (entry.enabled === false) {
+      continue;
+    }
+    const factory = resolveByType({
+      kind: "tool",
+      type: entry.type,
+      factories: image.tools,
+      imageName
+    });
+    const validatedConfig = factory.configSchema.parse(stripEnabled(entry));
+    for (const tool of factory.create(validatedConfig)) {
+      if (tool.id.startsWith(MCP_TOOL_PREFIX)) {
+        throw new Error(
+          `Invalid local tool id '${tool.id}': '${MCP_TOOL_PREFIX}' prefix is reserved for MCP tools.`
+        );
+      }
+      if (toolIds.has(tool.id)) {
+        logger.warn(`Tool id conflict for '${tool.id}'. Skipping duplicate tool.`);
+        continue;
+      }
+      toolIds.add(tool.id);
+      tools.push(tool);
+    }
+  }
+  const hookEntries = config.hooks ?? image.defaults?.hooks ?? [];
+  const hooks = [];
+  for (const entry of hookEntries) {
+    if (entry.enabled === false) {
+      continue;
+    }
+    const factory = resolveByType({
+      kind: "hook",
+      type: entry.type,
+      factories: image.hooks,
+      imageName
+    });
+    const parsedConfig = factory.configSchema.parse(stripEnabled(entry));
+    const hook = factory.create(parsedConfig);
+    if (hook.initialize) {
+      if (!(0, import_utils.isPlainObject)(parsedConfig)) {
+        throw new Error(`Invalid hook config for '${entry.type}': expected an object`);
+      }
+      await hook.initialize(parsedConfig);
+    }
+    hooks.push(hook);
+  }
+  const compactionConfig = config.compaction;
+  let compaction = null;
+  if (compactionConfig.enabled !== false) {
+    const factory = resolveByType({
+      kind: "compaction",
+      type: compactionConfig.type,
+      factories: image.compaction,
+      imageName
+    });
+    const parsedConfig = factory.configSchema.parse(compactionConfig);
+    compaction = await factory.create(parsedConfig);
+  }
+  return { logger, storage, tools, hooks, compaction };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveServicesFromConfig
+});

package/dist/resolver/resolve-services-from-config.d.ts

@@ -0,0 +1,5 @@
+import type { ValidatedAgentConfig } from '../schemas/agent-config.js';
+import type { DextoImage } from '../image/types.js';
+import type { ResolvedServices } from './types.js';
+export declare function resolveServicesFromConfig(config: ValidatedAgentConfig, image: DextoImage): Promise<ResolvedServices>;
+//# sourceMappingURL=resolve-services-from-config.d.ts.map

package/dist/resolver/resolve-services-from-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-services-from-config.d.ts","sourceRoot":"","sources":["../../src/resolver/resolve-services-from-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAmCnD,wBAAsB,yBAAyB,CAC3C,MAAM,EAAE,oBAAoB,EAC5B,KAAK,EAAE,UAAU,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAqH3B"}

package/dist/resolver/resolve-services-from-config.js

@@ -0,0 +1,122 @@
+import { isPlainObject } from "./utils.js";
+const MCP_TOOL_PREFIX = "mcp--";
+function stripEnabled(entry) {
+  const obj = entry;
+  if (!Object.prototype.hasOwnProperty.call(obj, "enabled")) {
+    return obj;
+  }
+  const { enabled: _enabled, ...rest } = obj;
+  return rest;
+}
+function resolveByType(options) {
+  const { kind, type, factories, imageName } = options;
+  const factory = factories[type];
+  if (!factory) {
+    const available = Object.keys(factories).sort();
+    throw new Error(
+      `Unknown ${kind} type '${type}'. Available types from image '${imageName}': ${available.join(", ")}`
+    );
+  }
+  return factory;
+}
+async function resolveServicesFromConfig(config, image) {
+  const imageName = image.metadata.name;
+  const loggerFactoryInput = {
+    agentId: config.agentId,
+    config: config.logger
+  };
+  const loggerConfig = image.logger.configSchema.parse(loggerFactoryInput);
+  const logger = image.logger.create(loggerConfig);
+  const blobFactory = resolveByType({
+    kind: "blob storage",
+    type: config.storage.blob.type,
+    factories: image.storage.blob,
+    imageName
+  });
+  const databaseFactory = resolveByType({
+    kind: "database",
+    type: config.storage.database.type,
+    factories: image.storage.database,
+    imageName
+  });
+  const cacheFactory = resolveByType({
+    kind: "cache",
+    type: config.storage.cache.type,
+    factories: image.storage.cache,
+    imageName
+  });
+  const blobConfig = blobFactory.configSchema.parse(config.storage.blob);
+  const databaseConfig = databaseFactory.configSchema.parse(config.storage.database);
+  const cacheConfig = cacheFactory.configSchema.parse(config.storage.cache);
+  const storage = {
+    blob: await blobFactory.create(blobConfig, logger),
+    database: await databaseFactory.create(databaseConfig, logger),
+    cache: await cacheFactory.create(cacheConfig, logger)
+  };
+  const toolEntries = config.tools ?? image.defaults?.tools ?? [];
+  const tools = [];
+  const toolIds = /* @__PURE__ */ new Set();
+  for (const entry of toolEntries) {
+    if (entry.enabled === false) {
+      continue;
+    }
+    const factory = resolveByType({
+      kind: "tool",
+      type: entry.type,
+      factories: image.tools,
+      imageName
+    });
+    const validatedConfig = factory.configSchema.parse(stripEnabled(entry));
+    for (const tool of factory.create(validatedConfig)) {
+      if (tool.id.startsWith(MCP_TOOL_PREFIX)) {
+        throw new Error(
+          `Invalid local tool id '${tool.id}': '${MCP_TOOL_PREFIX}' prefix is reserved for MCP tools.`
+        );
+      }
+      if (toolIds.has(tool.id)) {
+        logger.warn(`Tool id conflict for '${tool.id}'. Skipping duplicate tool.`);
+        continue;
+      }
+      toolIds.add(tool.id);
+      tools.push(tool);
+    }
+  }
+  const hookEntries = config.hooks ?? image.defaults?.hooks ?? [];
+  const hooks = [];
+  for (const entry of hookEntries) {
+    if (entry.enabled === false) {
+      continue;
+    }
+    const factory = resolveByType({
+      kind: "hook",
+      type: entry.type,
+      factories: image.hooks,
+      imageName
+    });
+    const parsedConfig = factory.configSchema.parse(stripEnabled(entry));
+    const hook = factory.create(parsedConfig);
+    if (hook.initialize) {
+      if (!isPlainObject(parsedConfig)) {
+        throw new Error(`Invalid hook config for '${entry.type}': expected an object`);
+      }
+      await hook.initialize(parsedConfig);
+    }
+    hooks.push(hook);
+  }
+  const compactionConfig = config.compaction;
+  let compaction = null;
+  if (compactionConfig.enabled !== false) {
+    const factory = resolveByType({
+      kind: "compaction",
+      type: compactionConfig.type,
+      factories: image.compaction,
+      imageName
+    });
+    const parsedConfig = factory.configSchema.parse(compactionConfig);
+    compaction = await factory.create(parsedConfig);
+  }
+  return { logger, storage, tools, hooks, compaction };
+}
+export {
+  resolveServicesFromConfig
+};

package/dist/resolver/to-dexto-agent-options.cjs

@@ -0,0 +1,51 @@
+"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 to_dexto_agent_options_exports = {};
+__export(to_dexto_agent_options_exports, {
+  toDextoAgentOptions: () => toDextoAgentOptions
+});
+module.exports = __toCommonJS(to_dexto_agent_options_exports);
+function toDextoAgentOptions(options) {
+  const { config, services, overrides } = options;
+  return {
+    agentId: config.agentId,
+    llm: config.llm,
+    systemPrompt: config.systemPrompt,
+    agentCard: config.agentCard,
+    greeting: config.greeting,
+    telemetry: config.telemetry,
+    memories: config.memories,
+    mcpServers: config.mcpServers,
+    sessions: config.sessions,
+    permissions: config.permissions,
+    elicitation: config.elicitation,
+    resources: config.resources,
+    prompts: config.prompts,
+    logger: services.logger,
+    storage: services.storage,
+    tools: services.tools,
+    hooks: services.hooks,
+    compaction: services.compaction,
+    ...overrides ? { overrides } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toDextoAgentOptions
+});

package/dist/resolver/to-dexto-agent-options.d.ts

@@ -0,0 +1,10 @@
+import type { DextoAgentOptions, InitializeServicesOptions } from '@dexto/core';
+import type { ValidatedAgentConfig } from '../schemas/agent-config.js';
+import type { ResolvedServices } from './types.js';
+export interface ToDextoAgentOptionsInput {
+    config: ValidatedAgentConfig;
+    services: ResolvedServices;
+    overrides?: InitializeServicesOptions | undefined;
+}
+export declare function toDextoAgentOptions(options: ToDextoAgentOptionsInput): DextoAgentOptions;
+//# sourceMappingURL=to-dexto-agent-options.d.ts.map

package/dist/resolver/to-dexto-agent-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-dexto-agent-options.d.ts","sourceRoot":"","sources":["../../src/resolver/to-dexto-agent-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;CACrD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CAwBxF"}

package/dist/resolver/to-dexto-agent-options.js

@@ -0,0 +1,27 @@
+function toDextoAgentOptions(options) {
+  const { config, services, overrides } = options;
+  return {
+    agentId: config.agentId,
+    llm: config.llm,
+    systemPrompt: config.systemPrompt,
+    agentCard: config.agentCard,
+    greeting: config.greeting,
+    telemetry: config.telemetry,
+    memories: config.memories,
+    mcpServers: config.mcpServers,
+    sessions: config.sessions,
+    permissions: config.permissions,
+    elicitation: config.elicitation,
+    resources: config.resources,
+    prompts: config.prompts,
+    logger: services.logger,
+    storage: services.storage,
+    tools: services.tools,
+    hooks: services.hooks,
+    compaction: services.compaction,
+    ...overrides ? { overrides } : {}
+  };
+}
+export {
+  toDextoAgentOptions
+};

package/dist/resolver/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/resolver/types.d.ts

@@ -0,0 +1,19 @@
+import type { BlobStore } from '@dexto/core';
+import type { Cache } from '@dexto/core';
+import type { Database } from '@dexto/core';
+import type { Hook } from '@dexto/core';
+import type { CompactionStrategy } from '@dexto/core';
+import type { Logger } from '@dexto/core';
+import type { Tool } from '@dexto/core';
+export interface ResolvedServices {
+    logger: Logger;
+    storage: {
+        blob: BlobStore;
+        database: Database;
+        cache: Cache;
+    };
+    tools: Tool[];
+    hooks: Hook[];
+    compaction: CompactionStrategy | null;
+}
+//# sourceMappingURL=types.d.ts.map