@dexto/agent-management 1.3.0 → 1.4.0

package/dist/AgentFactory.cjs

@@ -0,0 +1,153 @@
+"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 AgentFactory_exports = {};
+__export(AgentFactory_exports, {
+  AgentFactory: () => AgentFactory
+});
+module.exports = __toCommonJS(AgentFactory_exports);
+var import_fs = require("fs");
+var import_core = require("@dexto/core");
+var import_path = require("./utils/path.js");
+var import_types = require("./registry/types.js");
+var import_registry = require("./registry/registry.js");
+var import_config = require("./config/index.js");
+var import_installation = require("./installation.js");
+const AgentFactory = {
+  /**
+   * List all agents (installed and available from bundled registry)
+   * @param options - Optional fallback values for descriptions
+   */
+  async listAgents(options) {
+    const bundledAgents = (0, import_registry.loadBundledRegistryAgents)();
+    const installed = await listInstalledAgents();
+    const descriptionFallback = options?.descriptionFallback ?? "";
+    const customAgentDescriptionFallback = options?.customAgentDescriptionFallback ?? descriptionFallback;
+    const installedAgents = installed.map((id) => {
+      const bundledEntry = bundledAgents[id];
+      return {
+        id,
+        name: bundledEntry?.name || (0, import_types.deriveDisplayName)(id),
+        description: bundledEntry?.description || (bundledEntry ? descriptionFallback : customAgentDescriptionFallback),
+        author: bundledEntry?.author || "",
+        tags: bundledEntry?.tags || [],
+        type: bundledEntry ? "builtin" : "custom"
+      };
+    });
+    const installedSet = new Set(installed);
+    const availableAgents = Object.entries(bundledAgents).filter(([id]) => !installedSet.has(id)).map(([id, entry]) => ({
+      id,
+      name: entry.name,
+      description: entry.description || descriptionFallback,
+      author: entry.author || "",
+      tags: entry.tags || [],
+      type: "builtin"
+    }));
+    return {
+      installed: installedAgents,
+      available: availableAgents
+    };
+  },
+  /**
+   * Install an agent from the bundled registry
+   */
+  async installAgent(agentId, options) {
+    return (0, import_installation.installBundledAgent)(agentId, options);
+  },
+  /**
+   * Install a custom agent from local path
+   */
+  async installCustomAgent(agentId, sourcePath, metadata, injectPreferences) {
+    const options = typeof injectPreferences === "boolean" ? { injectPreferences } : injectPreferences || {};
+    return (0, import_installation.installCustomAgent)(agentId, sourcePath, metadata, options);
+  },
+  /**
+   * Uninstall an agent
+   * @param agentId - Agent ID to uninstall
+   * @param _force - Deprecated: force parameter is kept for backward compatibility but has no effect
+   */
+  async uninstallAgent(agentId, _force) {
+    return (0, import_installation.uninstallAgent)(agentId);
+  },
+  /**
+   * Create an agent from an inline configuration object
+   *
+   * Use this when you have a config from a database, API, or constructed programmatically
+   * and don't need a registry file. The agent is returned unstarted.
+   *
+   * @param config - Agent configuration object
+   * @param options - Optional creation options
+   * @returns Promise resolving to DextoAgent instance (not started)
+   *
+   * @example
+   * ```typescript
+   * // Create from inline config
+   * const agent = await AgentFactory.createAgent({
+   *   llm: {
+   *     provider: 'openai',
+   *     model: 'gpt-4o',
+   *     apiKey: process.env.OPENAI_API_KEY
+   *   },
+   *   systemPrompt: 'You are a helpful assistant.'
+   * });
+   * await agent.start();
+   *
+   * // With custom agent ID (affects log/storage paths)
+   * const agent = await AgentFactory.createAgent(config, { agentId: 'my-custom-agent' });
+   *
+   * // From database
+   * const configFromDb = await db.getAgentConfig(userId);
+   * const agent = await AgentFactory.createAgent(configFromDb, { agentId: `user-${userId}` });
+   * ```
+   */
+  async createAgent(config, options) {
+    let configToEnrich = config;
+    if (options?.agentId) {
+      configToEnrich = {
+        ...config,
+        agentCard: {
+          ...config.agentCard || {},
+          name: options.agentId
+        }
+      };
+    }
+    const enrichedConfig = (0, import_config.enrichAgentConfig)(
+      configToEnrich,
+      void 0,
+      // No config path for inline configs
+      options?.isInteractiveCli ?? false
+    );
+    return new import_core.DextoAgent(enrichedConfig);
+  }
+};
+async function listInstalledAgents() {
+  const agentsDir = (0, import_path.getDextoGlobalPath)("agents");
+  try {
+    const entries = await import_fs.promises.readdir(agentsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentFactory
+});

package/dist/AgentFactory.d.ts

@@ -0,0 +1,121 @@
+/**
+ * AgentFactory - Static convenience API for agent operations
+ *
+ * USE THIS WHEN: You need a simple, direct way to create agents or manage installations.
+ * No registry file required for agent creation.
+ *
+ * Key methods:
+ * - `AgentFactory.createAgent(config)` - Create agent from inline config (DB, API, dynamic)
+ * - `AgentFactory.installAgent(id)` - Install agent from bundled registry
+ * - `AgentFactory.uninstallAgent(id)` - Remove installed agent
+ * - `AgentFactory.listAgents()` - List installed/available agents
+ *
+ * Examples:
+ * - SaaS platforms with per-tenant configs from database
+ * - Dynamically constructed agent configurations
+ * - Quick scripts and demos
+ * - Single-agent applications
+ *
+ * FOR REGISTRY-BASED MULTI-AGENT SCENARIOS: Use `AgentManager` instead.
+ * This is better when you have a registry.json with multiple predefined agents
+ * and need discovery/selection capabilities.
+ *
+ * @see AgentManager for registry-based agent management
+ * @see https://docs.dexto.ai/api/sdk/agent-factory for full documentation
+ */
+import { DextoAgent, type AgentConfig } from '@dexto/core';
+import { type InstallOptions } from './installation.js';
+import type { AgentMetadata } from './AgentManager.js';
+/**
+ * Options for listing agents
+ */
+export interface ListAgentsOptions {
+    /** Fallback description when not provided */
+    descriptionFallback?: string;
+    /** Fallback description for custom agents */
+    customAgentDescriptionFallback?: string;
+}
+/**
+ * Options for creating an agent from inline config
+ */
+export interface CreateAgentOptions {
+    /** Override agent ID (otherwise derived from agentCard.name or defaults to 'inline-agent') */
+    agentId?: string;
+    /** Whether this is interactive CLI mode (affects logger defaults) */
+    isInteractiveCli?: boolean;
+}
+/**
+ * Static API for agent management operations
+ * Provides convenient methods for listing, installing, and uninstalling agents
+ */
+export declare const AgentFactory: {
+    /**
+     * List all agents (installed and available from bundled registry)
+     * @param options - Optional fallback values for descriptions
+     */
+    listAgents(options?: ListAgentsOptions): Promise<{
+        installed: {
+            id: string;
+            name: string;
+            description: string;
+            author: string;
+            tags: string[];
+            type: "custom" | "builtin";
+        }[];
+        available: {
+            id: string;
+            name: any;
+            description: any;
+            author: any;
+            tags: any;
+            type: "builtin";
+        }[];
+    }>;
+    /**
+     * Install an agent from the bundled registry
+     */
+    installAgent(agentId: string, options?: InstallOptions): Promise<string>;
+    /**
+     * Install a custom agent from local path
+     */
+    installCustomAgent(agentId: string, sourcePath: string, metadata: Pick<AgentMetadata, "name" | "description" | "author" | "tags">, injectPreferences?: boolean | InstallOptions): Promise<string>;
+    /**
+     * Uninstall an agent
+     * @param agentId - Agent ID to uninstall
+     * @param _force - Deprecated: force parameter is kept for backward compatibility but has no effect
+     */
+    uninstallAgent(agentId: string, _force?: boolean): Promise<void>;
+    /**
+     * Create an agent from an inline configuration object
+     *
+     * Use this when you have a config from a database, API, or constructed programmatically
+     * and don't need a registry file. The agent is returned unstarted.
+     *
+     * @param config - Agent configuration object
+     * @param options - Optional creation options
+     * @returns Promise resolving to DextoAgent instance (not started)
+     *
+     * @example
+     * ```typescript
+     * // Create from inline config
+     * const agent = await AgentFactory.createAgent({
+     *   llm: {
+     *     provider: 'openai',
+     *     model: 'gpt-4o',
+     *     apiKey: process.env.OPENAI_API_KEY
+     *   },
+     *   systemPrompt: 'You are a helpful assistant.'
+     * });
+     * await agent.start();
+     *
+     * // With custom agent ID (affects log/storage paths)
+     * const agent = await AgentFactory.createAgent(config, { agentId: 'my-custom-agent' });
+     *
+     * // From database
+     * const configFromDb = await db.getAgentConfig(userId);
+     * const agent = await AgentFactory.createAgent(configFromDb, { agentId: `user-${userId}` });
+     * ```
+     */
+    createAgent(config: AgentConfig, options?: CreateAgentOptions): Promise<DextoAgent>;
+};
+//# sourceMappingURL=AgentFactory.d.ts.map

package/dist/AgentFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentFactory.d.ts","sourceRoot":"","sources":["../src/AgentFactory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAK3D,OAAO,EAIH,KAAK,cAAc,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,6CAA6C;IAC7C,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,6CAA6C;IAC7C,8BAA8B,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,8FAA8F;IAC9F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;IACrB;;;OAGG;yBACwB,iBAAiB;;;;;;;;;;;;;;;;;;IAyC5C;;OAEG;0BACyB,MAAM,YAAY,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAI9E;;OAEG;gCAEU,MAAM,cACH,MAAM,YACR,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,aAAa,GAAG,QAAQ,GAAG,MAAM,CAAC,sBACrD,OAAO,GAAG,cAAc,GAC7C,OAAO,CAAC,MAAM,CAAC;IAUlB;;;;OAIG;4BAC2B,MAAM,WAAW,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAItE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;wBACuB,WAAW,YAAY,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC;CAwB5F,CAAC"}

package/dist/AgentFactory.js

@@ -0,0 +1,133 @@
+import { promises as fs } from "fs";
+import { DextoAgent } from "@dexto/core";
+import { getDextoGlobalPath } from "./utils/path.js";
+import { deriveDisplayName } from "./registry/types.js";
+import { loadBundledRegistryAgents } from "./registry/registry.js";
+import { enrichAgentConfig } from "./config/index.js";
+import {
+  installBundledAgent,
+  installCustomAgent,
+  uninstallAgent
+} from "./installation.js";
+const AgentFactory = {
+  /**
+   * List all agents (installed and available from bundled registry)
+   * @param options - Optional fallback values for descriptions
+   */
+  async listAgents(options) {
+    const bundledAgents = loadBundledRegistryAgents();
+    const installed = await listInstalledAgents();
+    const descriptionFallback = options?.descriptionFallback ?? "";
+    const customAgentDescriptionFallback = options?.customAgentDescriptionFallback ?? descriptionFallback;
+    const installedAgents = installed.map((id) => {
+      const bundledEntry = bundledAgents[id];
+      return {
+        id,
+        name: bundledEntry?.name || deriveDisplayName(id),
+        description: bundledEntry?.description || (bundledEntry ? descriptionFallback : customAgentDescriptionFallback),
+        author: bundledEntry?.author || "",
+        tags: bundledEntry?.tags || [],
+        type: bundledEntry ? "builtin" : "custom"
+      };
+    });
+    const installedSet = new Set(installed);
+    const availableAgents = Object.entries(bundledAgents).filter(([id]) => !installedSet.has(id)).map(([id, entry]) => ({
+      id,
+      name: entry.name,
+      description: entry.description || descriptionFallback,
+      author: entry.author || "",
+      tags: entry.tags || [],
+      type: "builtin"
+    }));
+    return {
+      installed: installedAgents,
+      available: availableAgents
+    };
+  },
+  /**
+   * Install an agent from the bundled registry
+   */
+  async installAgent(agentId, options) {
+    return installBundledAgent(agentId, options);
+  },
+  /**
+   * Install a custom agent from local path
+   */
+  async installCustomAgent(agentId, sourcePath, metadata, injectPreferences) {
+    const options = typeof injectPreferences === "boolean" ? { injectPreferences } : injectPreferences || {};
+    return installCustomAgent(agentId, sourcePath, metadata, options);
+  },
+  /**
+   * Uninstall an agent
+   * @param agentId - Agent ID to uninstall
+   * @param _force - Deprecated: force parameter is kept for backward compatibility but has no effect
+   */
+  async uninstallAgent(agentId, _force) {
+    return uninstallAgent(agentId);
+  },
+  /**
+   * Create an agent from an inline configuration object
+   *
+   * Use this when you have a config from a database, API, or constructed programmatically
+   * and don't need a registry file. The agent is returned unstarted.
+   *
+   * @param config - Agent configuration object
+   * @param options - Optional creation options
+   * @returns Promise resolving to DextoAgent instance (not started)
+   *
+   * @example
+   * ```typescript
+   * // Create from inline config
+   * const agent = await AgentFactory.createAgent({
+   *   llm: {
+   *     provider: 'openai',
+   *     model: 'gpt-4o',
+   *     apiKey: process.env.OPENAI_API_KEY
+   *   },
+   *   systemPrompt: 'You are a helpful assistant.'
+   * });
+   * await agent.start();
+   *
+   * // With custom agent ID (affects log/storage paths)
+   * const agent = await AgentFactory.createAgent(config, { agentId: 'my-custom-agent' });
+   *
+   * // From database
+   * const configFromDb = await db.getAgentConfig(userId);
+   * const agent = await AgentFactory.createAgent(configFromDb, { agentId: `user-${userId}` });
+   * ```
+   */
+  async createAgent(config, options) {
+    let configToEnrich = config;
+    if (options?.agentId) {
+      configToEnrich = {
+        ...config,
+        agentCard: {
+          ...config.agentCard || {},
+          name: options.agentId
+        }
+      };
+    }
+    const enrichedConfig = enrichAgentConfig(
+      configToEnrich,
+      void 0,
+      // No config path for inline configs
+      options?.isInteractiveCli ?? false
+    );
+    return new DextoAgent(enrichedConfig);
+  }
+};
+async function listInstalledAgents() {
+  const agentsDir = getDextoGlobalPath("agents");
+  try {
+    const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+export {
+  AgentFactory
+};

package/dist/AgentManager.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AgentManager_exports = {};
+__export(AgentManager_exports, {
+  AgentManager: () => AgentManager
+});
+module.exports = __toCommonJS(AgentManager_exports);
+var import_fs = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_core = require("@dexto/core");
+var import_config = require("./config/index.js");
+var import_errors = require("./registry/errors.js");
+var import_zod = require("zod");
+const RegistrySchema = import_zod.z.object({
+  agents: import_zod.z.array(
+    import_zod.z.object({
+      id: import_zod.z.string(),
+      name: import_zod.z.string(),
+      description: import_zod.z.string(),
+      configPath: import_zod.z.string(),
+      author: import_zod.z.string().optional(),
+      tags: import_zod.z.array(import_zod.z.string()).optional()
+    }).strict()
+  )
+}).strict();
+class AgentManager {
+  registry = null;
+  registryPath;
+  basePath;
+  /**
+   * Create a new AgentManager
+   *
+   * @param registryPath Absolute or relative path to registry.json file
+   *
+   * @example
+   * ```typescript
+   * // Project-local registry
+   * const manager = new AgentManager('./agents/registry.json');
+   *
+   * // Absolute path
+   * const manager = new AgentManager('/path/to/registry.json');
+   * ```
+   */
+  constructor(registryPath) {
+    this.registryPath = import_path.default.resolve(registryPath);
+    this.basePath = import_path.default.dirname(this.registryPath);
+  }
+  /**
+   * Load registry from file (lazy loaded, cached)
+   *
+   * Call this before using sync methods like `listAgents()` or `hasAgent()`.
+   * Alternatively, calling `loadAgent()` will automatically load the registry.
+   *
+   * @returns The loaded registry
+   *
+   * @example
+   * ```typescript
+   * const manager = new AgentManager('./registry.json');
+   * await manager.loadRegistry();
+   *
+   * // Now sync methods work
+   * const agents = manager.listAgents();
+   * ```
+   */
+  async loadRegistry() {
+    if (this.registry) {
+      return this.registry;
+    }
+    try {
+      const content = await import_fs.promises.readFile(this.registryPath, "utf-8");
+      const parsed = JSON.parse(content);
+      this.registry = RegistrySchema.parse(parsed);
+      import_core.logger.debug(
+        `Loaded registry from ${this.registryPath}: ${this.registry.agents.length} agents`
+      );
+      return this.registry;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw import_errors.RegistryError.registryNotFound(this.registryPath, "File does not exist");
+      }
+      if (error instanceof import_zod.ZodError) {
+        throw import_errors.RegistryError.registryParseError(
+          this.registryPath,
+          `Invalid registry schema: ${error.errors.map((e) => e.message).join(", ")}`
+        );
+      }
+      throw import_errors.RegistryError.registryParseError(
+        this.registryPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * List all agents in the registry
+   *
+   * @returns Array of agent metadata
+   *
+   * @example
+   * ```typescript
+   * const manager = new AgentManager('./registry.json');
+   * const agents = manager.listAgents();
+   * console.log(agents);
+   * // [
+   * //   { id: 'coding-agent', name: 'Coding Assistant', description: '...', tags: ['coding'] },
+   * //   { id: 'support-agent', name: 'Support Assistant', description: '...', tags: ['support'] }
+   * // ]
+   * ```
+   */
+  listAgents() {
+    if (!this.registry) {
+      throw import_errors.RegistryError.registryNotFound(
+        this.registryPath,
+        "Registry not loaded. Call loadRegistry() first or use async methods."
+      );
+    }
+    return this.registry.agents.map((entry) => ({
+      id: entry.id,
+      name: entry.name,
+      description: entry.description,
+      author: entry.author,
+      tags: entry.tags
+    }));
+  }
+  /**
+   * Load a DextoAgent instance from registry
+   *
+   * @param id Agent ID from registry
+   * @returns Promise resolving to DextoAgent instance (not started)
+   *
+   * @throws {DextoRuntimeError} If agent not found or config loading fails
+   * @throws {DextoValidationError} If agent config validation fails
+   *
+   * @example
+   * ```typescript
+   * const manager = new AgentManager('./registry.json');
+   * const agent = await manager.loadAgent('coding-agent');
+   * await agent.start();
+   *
+   * // Use the agent
+   * const session = await agent.createSession();
+   * const response = await agent.generate('Write a function', session.id);
+   * ```
+   */
+  async loadAgent(id) {
+    const registry = await this.loadRegistry();
+    const entry = registry.agents.find((a) => a.id === id);
+    if (!entry) {
+      const available = registry.agents.map((a) => a.id);
+      throw import_errors.RegistryError.agentNotFound(id, available);
+    }
+    const configPath = import_path.default.resolve(this.basePath, entry.configPath);
+    try {
+      const config = await (0, import_config.loadAgentConfig)(configPath);
+      const enrichedConfig = (0, import_config.enrichAgentConfig)(config, configPath);
+      import_core.logger.debug(`Loading agent: ${id} from ${configPath}`);
+      return new import_core.DextoAgent(enrichedConfig, configPath);
+    } catch (error) {
+      if (error instanceof import_zod.ZodError) {
+        const issues = (0, import_core.zodToIssues)(error, "error");
+        throw new import_core.DextoValidationError(issues);
+      }
+      if (error instanceof Error && error.name.startsWith("Dexto")) {
+        throw error;
+      }
+      throw import_errors.RegistryError.installationFailed(
+        id,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Check if an agent exists in the registry
+   *
+   * @param id Agent ID to check
+   * @returns True if agent exists
+   *
+   * @example
+   * ```typescript
+   * const manager = new AgentManager('./registry.json');
+   * await manager.loadRegistry();
+   *
+   * if (manager.hasAgent('coding-agent')) {
+   *   const agent = await manager.loadAgent('coding-agent');
+   * }
+   * ```
+   */
+  hasAgent(id) {
+    if (!this.registry) {
+      throw import_errors.RegistryError.registryNotFound(
+        this.registryPath,
+        "Registry not loaded. Call loadRegistry() first or use async methods."
+      );
+    }
+    return this.registry.agents.some((a) => a.id === id);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentManager
+});