@dexto/agent-management 1.3.0 → 1.5.0

package/dist/registry/registry.js

@@ -3,8 +3,6 @@ import { promises as fs } from "fs";
 import path from "path";
 import { logger } from "@dexto/core";
 import { resolveBundledScript, getDextoGlobalPath, copyDirectory } from "../utils/path.js";
-import { loadGlobalPreferences } from "../preferences/loader.js";
-import { writePreferencesToAgent } from "../writer.js";
 import {
   RegistrySchema,
   normalizeRegistryJson
@@ -16,6 +14,7 @@ import {
   removeAgentFromUserRegistry,
   addAgentToUserRegistry
 } from "./user-registry.js";
+import { loadGlobalPreferences } from "../preferences/loader.js";
 let cachedRegistry = null;
 class LocalAgentRegistry {
   _registry = null;
@@ -141,12 +140,15 @@ class LocalAgentRegistry {
       return configPath;
     }
   }
+  // TODO: Consider removing install/uninstall methods from LocalAgentRegistry class.
+  // Installing/uninstalling from registry to local agents/ is better suited as a CLI command.
+  // A bundler/opinionated project structure should help - agents/ will by default be their registry.
+  // For now these methods remain for backward compatibility.
   /**
    * Install agent atomically using temp + rename pattern
    * @param agentId ID of the agent to install
-   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
    */
-  async installAgent(agentId, injectPreferences = true) {
+  async installAgent(agentId) {
     logger.info(`Installing agent: ${agentId}`);
     const registry = this.getRegistry();
     const agentData = registry.agents[agentId];
@@ -184,24 +186,6 @@ class LocalAgentRegistry {
       }
       await fs.rename(tempDir, targetDir);
       logger.info(`\u2713 Installed agent '${agentId}' to ${targetDir}`);
-      if (injectPreferences) {
-        try {
-          const preferences = await loadGlobalPreferences();
-          await writePreferencesToAgent(targetDir, preferences);
-          logger.info(`\u2713 Applied global preferences to installed agent '${agentId}'`);
-        } catch (error) {
-          logger.warn(
-            `Failed to inject preferences to '${agentId}': ${error instanceof Error ? error.message : String(error)}`
-          );
-          console.log(
-            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentId}' - agent will use bundled settings`
-          );
-        }
-      } else {
-        logger.info(
-          `Skipped preference injection for '${agentId}' (injectPreferences=false)`
-        );
-      }
       return this.resolveMainConfig(targetDir, agentId);
     } catch (error) {
       try {
@@ -224,10 +208,9 @@ class LocalAgentRegistry {
    * @param agentId Unique identifier for the custom agent
    * @param sourcePath Absolute path to agent YAML file or directory
    * @param metadata Agent metadata (name for display, description, author, tags, main)
-   * @param injectPreferences Whether to inject global preferences (default: true)
    * @returns Path to the installed agent's main config file
    */
-  async installCustomAgentFromPath(agentId, sourcePath, metadata, injectPreferences = true) {
+  async installCustomAgentFromPath(agentId, sourcePath, metadata) {
     logger.info(`Installing custom agent '${agentId}' from ${sourcePath}`);
     this.validateCustomAgentId(agentId);
     if (!existsSync(sourcePath)) {
@@ -301,20 +284,6 @@ class LocalAgentRegistry {
         }
         throw registryError;
       }
-      if (injectPreferences) {
-        try {
-          const preferences = await loadGlobalPreferences();
-          await writePreferencesToAgent(targetDir, preferences);
-          logger.info(`\u2713 Applied global preferences to custom agent '${agentId}'`);
-        } catch (error) {
-          logger.warn(
-            `Failed to inject preferences to '${agentId}': ${error instanceof Error ? error.message : String(error)}`
-          );
-          console.log(
-            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentId}' - agent will use default settings`
-          );
-        }
-      }
       return mainConfigPath;
     } catch (error) {
       try {
@@ -338,9 +307,8 @@ class LocalAgentRegistry {
    * Handles installing agent if needed
    * @param agentId ID of the agent to resolve
    * @param autoInstall Whether to automatically install missing agents from registry (default: true)
-   * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
    */
-  async resolveAgent(agentId, autoInstall = true, injectPreferences = true) {
+  async resolveAgent(agentId, autoInstall = true) {
     logger.debug(`Resolving registry agent: ${agentId}`);
     const globalAgentsDir = getDextoGlobalPath("agents");
     const installedPath = path.resolve(globalAgentsDir, agentId);
@@ -357,7 +325,7 @@ class LocalAgentRegistry {
     if (this.hasAgent(agentId)) {
       if (autoInstall) {
         logger.info(`Installing agent '${agentId}' from registry...`);
-        return await this.installAgent(agentId, injectPreferences);
+        return await this.installAgent(agentId);
       } else {
         const registry2 = this.getRegistry();
         const available2 = Object.keys(registry2.agents);
@@ -393,8 +361,8 @@ class LocalAgentRegistry {
       const defaultAgent = preferences.defaults.defaultAgent;
       return agentId !== defaultAgent;
     } catch {
-      logger.warn("Could not load preferences, using fallback protection for default-agent");
-      return agentId !== "default-agent";
+      logger.warn("Could not load preferences, using fallback protection for coding-agent");
+      return agentId !== "coding-agent";
     }
   }
   /**
@@ -446,7 +414,21 @@ function getAgentRegistry() {
   }
   return cachedRegistry;
 }
+function loadBundledRegistryAgents() {
+  try {
+    const registryPath = resolveBundledScript("agents/agent-registry.json");
+    const content = readFileSync(registryPath, "utf-8");
+    const registry = JSON.parse(content);
+    return registry.agents || {};
+  } catch (error) {
+    logger.warn(
+      `Could not load bundled registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {};
+  }
+}
 export {
   LocalAgentRegistry,
-  getAgentRegistry
+  getAgentRegistry,
+  loadBundledRegistryAgents
 };

package/dist/registry/types.d.ts

@@ -13,17 +13,17 @@ export declare const AgentRegistryEntrySchema: z.ZodObject<{
     main: z.ZodOptional<z.ZodString>;
     type: z.ZodDefault<z.ZodEnum<["builtin", "custom"]>>;
 }, "strict", z.ZodTypeAny, {
-    name: string;
-    type: "custom" | "builtin";
     id: string;
+    name: string;
     description: string;
     author: string;
     tags: string[];
+    type: "custom" | "builtin";
     source: string;
     main?: string | undefined;
 }, {
-    name: string;
     id: string;
+    name: string;
     description: string;
     author: string;
     tags: string[];
@@ -47,17 +47,17 @@ export declare const RegistrySchema: z.ZodObject<{
         main: z.ZodOptional<z.ZodString>;
         type: z.ZodDefault<z.ZodEnum<["builtin", "custom"]>>;
     }, "strict", z.ZodTypeAny, {
-        name: string;
-        type: "custom" | "builtin";
         id: string;
+        name: string;
         description: string;
         author: string;
         tags: string[];
+        type: "custom" | "builtin";
         source: string;
         main?: string | undefined;
     }, {
-        name: string;
         id: string;
+        name: string;
         description: string;
         author: string;
         tags: string[];
@@ -68,20 +68,20 @@ export declare const RegistrySchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     version: string;
     agents: Record<string, {
-        name: string;
-        type: "custom" | "builtin";
         id: string;
+        name: string;
         description: string;
         author: string;
         tags: string[];
+        type: "custom" | "builtin";
         source: string;
         main?: string | undefined;
     }>;
 }, {
     version: string;
     agents: Record<string, {
-        name: string;
         id: string;
+        name: string;
         description: string;
         author: string;
         tags: string[];
@@ -115,10 +115,9 @@ export interface AgentRegistry {
     /**
      * Installs an agent from the registry by ID
      * @param agentId - Unique agent identifier
-     * @param injectPreferences - Whether to inject global preferences (default: true)
      * @returns Path to the installed agent config
      */
-    installAgent(agentId: string, injectPreferences?: boolean): Promise<string>;
+    installAgent(agentId: string): Promise<string>;
     /**
      * Uninstalls an agent by ID
      * @param agentId - Unique agent identifier
@@ -133,10 +132,9 @@ export interface AgentRegistry {
      * Resolves an agent ID or path and optionally auto-installs if needed
      * @param idOrPath - Agent ID from registry or filesystem path
      * @param autoInstall - Whether to auto-install from registry (default: true)
-     * @param injectPreferences - Whether to inject preferences during install (default: true)
      * @returns Path to the agent config file
      */
-    resolveAgent(idOrPath: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+    resolveAgent(idOrPath: string, autoInstall?: boolean): Promise<string>;
 }
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/registry/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/registry/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKd,CAAC;AAEd,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,KAAK,WAAW,GAAG;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;CAC9C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAsC/D;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IACzD;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5E;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACxC;;;;;;OAMG;IACH,YAAY,CACR,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,OAAO,EACrB,iBAAiB,CAAC,EAAE,OAAO,GAC5B,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/registry/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKd,CAAC;AAEd,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,KAAK,WAAW,GAAG;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;CAC9C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAsC/D;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IACzD;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACxC;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC1E"}

package/dist/resolver.cjs

@@ -39,7 +39,10 @@ var import_execution_context = require("./utils/execution-context.js");
 var import_core = require("@dexto/core");
 var import_loader = require("./preferences/loader.js");
 var import_config = require("./config/index.js");
-async function resolveAgentPath(nameOrPath, autoInstall = true, injectPreferences = true) {
+var import_errors = require("./registry/errors.js");
+var import_AgentManager = require("./AgentManager.js");
+var import_installation = require("./installation.js");
+async function resolveAgentPath(nameOrPath, autoInstall = true) {
   if (nameOrPath && (0, import_path2.isPath)(nameOrPath)) {
     const resolved = import_path.default.resolve(nameOrPath);
     try {
@@ -53,32 +56,67 @@ async function resolveAgentPath(nameOrPath, autoInstall = true, injectPreference
     }
   }
   if (nameOrPath) {
-    const { getAgentRegistry } = await import("./registry/registry.js");
-    const registry = getAgentRegistry();
-    return await registry.resolveAgent(nameOrPath, autoInstall, injectPreferences);
+    return await resolveAgentByName(nameOrPath, autoInstall);
   }
-  return await resolveDefaultAgentByContext(autoInstall, injectPreferences);
+  return await resolveDefaultAgentByContext(autoInstall);
 }
-async function resolveDefaultAgentByContext(autoInstall = true, injectPreferences = true) {
+async function resolveAgentByName(agentId, autoInstall) {
+  const agentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+  const installedRegistryPath = import_path.default.join(agentsDir, "registry.json");
+  try {
+    const manager = new import_AgentManager.AgentManager(installedRegistryPath);
+    await manager.loadRegistry();
+    if (manager.hasAgent(agentId)) {
+      const agentPath = await getAgentConfigPath(agentId);
+      return agentPath;
+    }
+  } catch (error) {
+    import_core.logger.debug(`Agent '${agentId}' not found in installed registry: ${error}`);
+  }
+  if (autoInstall) {
+    try {
+      import_core.logger.info(`Auto-installing agent '${agentId}' from bundled registry`);
+      const configPath = await (0, import_installation.installBundledAgent)(agentId);
+      return configPath;
+    } catch (error) {
+      import_core.logger.debug(`Failed to auto-install agent '${agentId}': ${error}`);
+      throw import_errors.RegistryError.agentNotFound(agentId, []);
+    }
+  }
+  throw import_errors.RegistryError.agentNotInstalledAutoInstallDisabled(agentId, []);
+}
+async function getAgentConfigPath(agentId) {
+  const agentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+  const installedRegistryPath = import_path.default.join(agentsDir, "registry.json");
+  const registryContent = await import_fs.promises.readFile(installedRegistryPath, "utf-8");
+  const registry = JSON.parse(registryContent);
+  const agentEntry = registry.agents.find((a) => a.id === agentId);
+  if (!agentEntry) {
+    const available = registry.agents.map((a) => a.id);
+    throw import_errors.RegistryError.agentNotFound(agentId, available);
+  }
+  return import_path.default.resolve(import_path.default.dirname(installedRegistryPath), agentEntry.configPath);
+}
+async function resolveDefaultAgentByContext(autoInstall = true) {
   const executionContext = (0, import_execution_context.getExecutionContext)();
   switch (executionContext) {
     case "dexto-source":
-      return await resolveDefaultAgentForDextoSource(autoInstall, injectPreferences);
+      return await resolveDefaultAgentForDextoSource(autoInstall);
     case "dexto-project":
-      return await resolveDefaultAgentForDextoProject(autoInstall, injectPreferences);
+      return await resolveDefaultAgentForDextoProject(autoInstall);
     case "global-cli":
-      return await resolveDefaultAgentForGlobalCLI(autoInstall, injectPreferences);
+      return await resolveDefaultAgentForGlobalCLI(autoInstall);
     default:
       throw import_config.ConfigError.unknownContext(executionContext);
   }
 }
-async function resolveDefaultAgentForDextoSource(autoInstall = true, injectPreferences = true) {
+async function resolveDefaultAgentForDextoSource(autoInstall = true) {
   import_core.logger.debug("Resolving default agent for dexto source context");
   const sourceRoot = (0, import_execution_context.findDextoSourceRoot)();
   if (!sourceRoot) {
     throw import_config.ConfigError.bundledNotFound("dexto source directory not found");
   }
-  const repoConfigPath = import_path.default.join(sourceRoot, "agents", "default-agent.yml");
+  const repoConfigPath = import_path.default.join(sourceRoot, "agents", "coding-agent", "coding-agent.yml");
   const isDevMode = process.env.DEXTO_DEV_MODE === "true";
   if (isDevMode) {
     import_core.logger.debug("Dev mode: using repository config file");
@@ -95,13 +133,7 @@ async function resolveDefaultAgentForDextoSource(autoInstall = true, injectPrefe
       if (preferences.setup.completed) {
         import_core.logger.debug("Using user preferences in dexto-source context");
         const preferredAgentName = preferences.defaults.defaultAgent;
-        const { getAgentRegistry } = await import("./registry/registry.js");
-        const registry = getAgentRegistry();
-        return await registry.resolveAgent(
-          preferredAgentName,
-          autoInstall,
-          injectPreferences
-        );
+        return await resolveAgentByName(preferredAgentName, autoInstall);
       }
     } catch (error) {
       import_core.logger.warn(`Failed to load preferences, falling back to repo config: ${error}`);
@@ -115,16 +147,16 @@ async function resolveDefaultAgentForDextoSource(autoInstall = true, injectPrefe
     throw import_config.ConfigError.bundledNotFound(repoConfigPath);
   }
 }
-async function resolveDefaultAgentForDextoProject(autoInstall = true, injectPreferences = true) {
+async function resolveDefaultAgentForDextoProject(autoInstall = true) {
   import_core.logger.debug("Resolving default agent for dexto project context");
   const projectRoot = (0, import_execution_context.findDextoProjectRoot)();
   if (!projectRoot) {
     throw import_config.ConfigError.unknownContext("dexto-project: project root not found");
   }
   const candidatePaths = [
-    import_path.default.join(projectRoot, "default-agent.yml"),
-    import_path.default.join(projectRoot, "agents", "default-agent.yml"),
-    import_path.default.join(projectRoot, "src", "dexto", "agents", "default-agent.yml")
+    import_path.default.join(projectRoot, "coding-agent.yml"),
+    import_path.default.join(projectRoot, "agents", "coding-agent.yml"),
+    import_path.default.join(projectRoot, "src", "dexto", "agents", "coding-agent.yml")
   ];
   for (const p of candidatePaths) {
     try {
@@ -133,7 +165,7 @@ async function resolveDefaultAgentForDextoProject(autoInstall = true, injectPref
     } catch {
     }
   }
-  import_core.logger.debug(`No project-local default-agent.yml found in ${projectRoot}`);
+  import_core.logger.debug(`No project-local coding-agent.yml found in ${projectRoot}`);
   if (!(0, import_loader.globalPreferencesExist)()) {
     throw import_config.ConfigError.noProjectDefault(projectRoot);
   }
@@ -142,11 +174,9 @@ async function resolveDefaultAgentForDextoProject(autoInstall = true, injectPref
     throw import_config.ConfigError.setupIncomplete();
   }
   const preferredAgentName = preferences.defaults.defaultAgent;
-  const { getAgentRegistry } = await import("./registry/registry.js");
-  const registry = getAgentRegistry();
-  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+  return await resolveAgentByName(preferredAgentName, autoInstall);
 }
-async function resolveDefaultAgentForGlobalCLI(autoInstall = true, injectPreferences = true) {
+async function resolveDefaultAgentForGlobalCLI(autoInstall = true) {
   import_core.logger.debug("Resolving default agent for global CLI context");
   if (!(0, import_loader.globalPreferencesExist)()) {
     throw import_config.ConfigError.noGlobalPreferences();
@@ -156,24 +186,33 @@ async function resolveDefaultAgentForGlobalCLI(autoInstall = true, injectPrefere
     throw import_config.ConfigError.setupIncomplete();
   }
   const preferredAgentName = preferences.defaults.defaultAgent;
-  const { getAgentRegistry } = await import("./registry/registry.js");
-  const registry = getAgentRegistry();
-  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+  return await resolveAgentByName(preferredAgentName, autoInstall);
 }
 async function updateDefaultAgentPreference(agentName) {
-  const { getAgentRegistry } = await import("./registry/registry.js");
-  const { RegistryError } = await import("./registry/errors.js");
-  const { isPath: isPath2 } = await import("@dexto/core");
-  const registry = getAgentRegistry();
-  if (isPath2(agentName) || !registry.hasAgent(agentName)) {
-    const available = Object.keys(registry.getAvailableAgents());
-    throw RegistryError.agentNotFound(agentName, available);
-  }
-  const { updateGlobalPreferences } = await import("./preferences/loader.js");
-  await updateGlobalPreferences({
-    defaults: { defaultAgent: agentName }
-  });
-  import_core.logger.info(`Updated default agent preference to: ${agentName}`);
+  const agentsDir = (0, import_path2.getDextoGlobalPath)("agents");
+  const installedRegistryPath = import_path.default.join(agentsDir, "registry.json");
+  const bundledRegistryPath = (0, import_path2.resolveBundledScript)("agents/agent-registry.json");
+  const registriesToCheck = [
+    { path: installedRegistryPath, name: "installed" },
+    { path: bundledRegistryPath, name: "bundled" }
+  ];
+  for (const registry of registriesToCheck) {
+    try {
+      const manager = new import_AgentManager.AgentManager(registry.path);
+      await manager.loadRegistry();
+      if (manager.hasAgent(agentName)) {
+        const { updateGlobalPreferences } = await import("./preferences/loader.js");
+        await updateGlobalPreferences({
+          defaults: { defaultAgent: agentName }
+        });
+        import_core.logger.info(`Updated default agent preference to: ${agentName}`);
+        return;
+      }
+    } catch (error) {
+      import_core.logger.debug(`Agent '${agentName}' not found in ${registry.name} registry: ${error}`);
+    }
+  }
+  throw import_errors.RegistryError.agentNotFound(agentName, []);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/resolver.d.ts

@@ -1,14 +1,16 @@
 /**
- * Resolve agent path with preference integration
+ * Resolve agent path with automatic installation if needed
  * @param nameOrPath Optional agent name or explicit path
- * @param autoInstall Whether to automatically install missing agents from registry (default: true)
- * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+ * @param autoInstall Whether to automatically install missing agents from bundled registry (default: true)
  * @returns Resolved absolute path to agent config
- * @throws DextoRuntimeError for any resolution failures
+ * @throws {ConfigError} For path/config issues (file not found, unknown context, setup incomplete)
+ * @throws {RegistryError} For agent lookup failures (agent not found, not installed)
  */
-export declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+export declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean): Promise<string>;
 /**
  * Update default agent preference
+ * @param agentName The agent name to set as the new default
+ * @throws {RegistryError} If the agent is not found in installed or bundled registry
  */
 export declare function updateDefaultAgentPreference(agentName: string): Promise<void>;
 //# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,GAAE,OAAc,EAC3B,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC,CAyBjB;AAoKD;;GAEG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBnF"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAoCA;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,GAAE,OAAc,GAC5B,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAiMD;;;;GAIG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BnF"}