@dexto/agent-management 1.3.0 → 1.4.0

package/dist/installation.js

@@ -0,0 +1,215 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { logger } from "@dexto/core";
+import { getDextoGlobalPath, resolveBundledScript, copyDirectory } from "./utils/path.js";
+import { loadGlobalPreferences } from "./preferences/loader.js";
+import { writePreferencesToAgent } from "./writer.js";
+import { RegistryError } from "./registry/errors.js";
+import { ConfigError } from "./config/errors.js";
+function getAgentsDir(options) {
+  return options?.agentsDir ?? getDextoGlobalPath("agents");
+}
+function getUserRegistryPath(agentsDir) {
+  return path.join(agentsDir, "registry.json");
+}
+async function loadUserRegistry(registryPath) {
+  try {
+    const content = await fs.readFile(registryPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { agents: [] };
+    }
+    throw error;
+  }
+}
+async function saveUserRegistry(registryPath, registry) {
+  await fs.mkdir(path.dirname(registryPath), { recursive: true });
+  await fs.writeFile(registryPath, JSON.stringify(registry, null, 2));
+}
+async function installBundledAgent(agentId, options) {
+  const agentsDir = getAgentsDir(options);
+  const bundledRegistryPath = resolveBundledScript("agents/agent-registry.json");
+  logger.info(`Installing agent: ${agentId}`);
+  let bundledRegistry;
+  try {
+    const content = await fs.readFile(bundledRegistryPath, "utf-8");
+    bundledRegistry = JSON.parse(content);
+  } catch (error) {
+    throw RegistryError.registryParseError(
+      bundledRegistryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const agentEntry = bundledRegistry.agents[agentId];
+  if (!agentEntry) {
+    const available = Object.keys(bundledRegistry.agents);
+    throw RegistryError.agentNotFound(agentId, available);
+  }
+  const targetDir = path.join(agentsDir, agentId);
+  try {
+    await fs.access(targetDir);
+    logger.info(`Agent '${agentId}' already installed`);
+    const mainFile = agentEntry.main || path.basename(agentEntry.source);
+    return path.join(targetDir, mainFile);
+  } catch {
+  }
+  await fs.mkdir(agentsDir, { recursive: true });
+  const sourcePath = resolveBundledScript(`agents/${agentEntry.source}`);
+  const tempDir = `${targetDir}.tmp.${Date.now()}`;
+  try {
+    if (agentEntry.source.endsWith("/")) {
+      await copyDirectory(sourcePath, tempDir);
+    } else {
+      await fs.mkdir(tempDir, { recursive: true });
+      const targetFile = path.join(tempDir, path.basename(sourcePath));
+      await fs.copyFile(sourcePath, targetFile);
+    }
+    await fs.rename(tempDir, targetDir);
+    logger.info(`\u2713 Installed agent '${agentId}' to ${targetDir}`);
+    if (options?.injectPreferences !== false) {
+      try {
+        const preferences = await loadGlobalPreferences();
+        await writePreferencesToAgent(targetDir, preferences);
+        logger.info(`\u2713 Applied global preferences to '${agentId}'`);
+      } catch (error) {
+        logger.warn(
+          `Failed to inject preferences: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const userRegistryPath = getUserRegistryPath(agentsDir);
+    const userRegistry = await loadUserRegistry(userRegistryPath);
+    if (!userRegistry.agents.some((a) => a.id === agentId)) {
+      const mainFile = agentEntry.main || path.basename(agentEntry.source);
+      userRegistry.agents.push({
+        id: agentId,
+        name: agentEntry.name,
+        description: agentEntry.description,
+        configPath: `./${agentId}/${mainFile}`,
+        author: agentEntry.author,
+        tags: agentEntry.tags
+      });
+      await saveUserRegistry(userRegistryPath, userRegistry);
+    }
+    return path.join(targetDir, agentEntry.main || path.basename(agentEntry.source));
+  } catch (error) {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+    throw RegistryError.installationFailed(
+      agentId,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function installCustomAgent(agentId, sourcePath, metadata, options) {
+  const agentsDir = getAgentsDir(options);
+  const targetDir = path.join(agentsDir, agentId);
+  logger.info(`Installing custom agent: ${agentId}`);
+  try {
+    const bundledRegistryPath = resolveBundledScript("agents/agent-registry.json");
+    const bundledContent = await fs.readFile(bundledRegistryPath, "utf-8");
+    const bundledRegistry = JSON.parse(bundledContent);
+    if (agentId in bundledRegistry.agents) {
+      throw RegistryError.customAgentNameConflict(agentId);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("conflicts with builtin")) {
+      throw error;
+    }
+    logger.debug(
+      `Could not validate against bundled registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    await fs.access(targetDir);
+    throw RegistryError.agentAlreadyExists(agentId);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const resolvedSource = path.resolve(sourcePath);
+  let stat;
+  try {
+    stat = await fs.stat(resolvedSource);
+  } catch (_error) {
+    throw ConfigError.fileNotFound(resolvedSource);
+  }
+  await fs.mkdir(agentsDir, { recursive: true });
+  try {
+    if (stat.isDirectory()) {
+      await copyDirectory(resolvedSource, targetDir);
+    } else {
+      await fs.mkdir(targetDir, { recursive: true });
+      const filename = path.basename(resolvedSource);
+      await fs.copyFile(resolvedSource, path.join(targetDir, filename));
+    }
+    logger.info(`\u2713 Installed custom agent '${agentId}' to ${targetDir}`);
+    const userRegistryPath = getUserRegistryPath(agentsDir);
+    const userRegistry = await loadUserRegistry(userRegistryPath);
+    const configFile = stat.isDirectory() ? "agent.yml" : path.basename(resolvedSource);
+    userRegistry.agents.push({
+      id: agentId,
+      name: metadata.name || agentId,
+      description: metadata.description,
+      configPath: `./${agentId}/${configFile}`,
+      author: metadata.author,
+      tags: metadata.tags || []
+    });
+    await saveUserRegistry(userRegistryPath, userRegistry);
+    return path.join(targetDir, configFile);
+  } catch (error) {
+    try {
+      await fs.rm(targetDir, { recursive: true, force: true });
+    } catch {
+    }
+    throw RegistryError.installationFailed(
+      agentId,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function uninstallAgent(agentId, options) {
+  const agentsDir = getAgentsDir(options);
+  const targetDir = path.join(agentsDir, agentId);
+  logger.info(`Uninstalling agent: ${agentId}`);
+  try {
+    await fs.access(targetDir);
+  } catch (_error) {
+    throw RegistryError.agentNotInstalled(agentId);
+  }
+  await fs.rm(targetDir, { recursive: true, force: true });
+  logger.info(`\u2713 Removed agent directory: ${targetDir}`);
+  const userRegistryPath = getUserRegistryPath(agentsDir);
+  try {
+    const userRegistry = await loadUserRegistry(userRegistryPath);
+    userRegistry.agents = userRegistry.agents.filter((a) => a.id !== agentId);
+    await saveUserRegistry(userRegistryPath, userRegistry);
+    logger.info(`\u2713 Removed '${agentId}' from user registry`);
+  } catch (error) {
+    logger.warn(
+      `Failed to update user registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function listInstalledAgents(options) {
+  const agentsDir = getAgentsDir(options);
+  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 {
+  installBundledAgent,
+  installCustomAgent,
+  listInstalledAgents,
+  uninstallAgent
+};

package/dist/models/custom-models.cjs

@@ -0,0 +1,116 @@
+"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 custom_models_exports = {};
+__export(custom_models_exports, {
+  CustomModelSchema: () => CustomModelSchema,
+  deleteCustomModel: () => deleteCustomModel,
+  getCustomModel: () => getCustomModel,
+  getCustomModelsPath: () => getCustomModelsPath,
+  loadCustomModels: () => loadCustomModels,
+  saveCustomModel: () => saveCustomModel
+});
+module.exports = __toCommonJS(custom_models_exports);
+var import_zod = require("zod");
+var import_fs = require("fs");
+var path = __toESM(require("path"), 1);
+var import_path = require("../utils/path.js");
+const CustomModelSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1),
+  baseURL: import_zod.z.string().url(),
+  displayName: import_zod.z.string().optional(),
+  maxInputTokens: import_zod.z.number().int().positive().optional(),
+  maxOutputTokens: import_zod.z.number().int().positive().optional()
+});
+const StorageSchema = import_zod.z.object({
+  version: import_zod.z.literal(1),
+  models: import_zod.z.array(CustomModelSchema)
+});
+function getCustomModelsPath() {
+  return (0, import_path.getDextoGlobalPath)("models", "custom-models.json");
+}
+async function loadCustomModels() {
+  const filePath = getCustomModelsPath();
+  try {
+    const content = await import_fs.promises.readFile(filePath, "utf-8");
+    const parsed = StorageSchema.safeParse(JSON.parse(content));
+    if (!parsed.success) {
+      console.warn(
+        `[custom-models] Failed to parse ${filePath}: ${parsed.error.issues.map((i) => i.message).join(", ")}`
+      );
+      return [];
+    }
+    return parsed.data.models;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function saveCustomModel(model) {
+  const parsed = CustomModelSchema.safeParse(model);
+  if (!parsed.success) {
+    throw new Error(`Invalid model: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+  }
+  const models = await loadCustomModels();
+  const existingIndex = models.findIndex((m) => m.name === parsed.data.name);
+  if (existingIndex >= 0) {
+    models[existingIndex] = parsed.data;
+  } else {
+    models.push(parsed.data);
+  }
+  await writeCustomModels(models);
+}
+async function deleteCustomModel(name) {
+  const models = await loadCustomModels();
+  const filtered = models.filter((m) => m.name !== name);
+  if (filtered.length === models.length) {
+    return false;
+  }
+  await writeCustomModels(filtered);
+  return true;
+}
+async function getCustomModel(name) {
+  const models = await loadCustomModels();
+  return models.find((m) => m.name === name) ?? null;
+}
+async function writeCustomModels(models) {
+  const filePath = getCustomModelsPath();
+  await import_fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await import_fs.promises.writeFile(filePath, JSON.stringify({ version: 1, models }, null, 2), "utf-8");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomModelSchema,
+  deleteCustomModel,
+  getCustomModel,
+  getCustomModelsPath,
+  loadCustomModels,
+  saveCustomModel
+});

package/dist/models/custom-models.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Custom Models Persistence
+ *
+ * Manages saved openai-compatible model configurations.
+ * Stored in ~/.dexto/models/custom-models.json
+ */
+import { z } from 'zod';
+/**
+ * Schema for a saved openai-compatible model configuration.
+ */
+export declare const CustomModelSchema: z.ZodObject<{
+    name: z.ZodString;
+    baseURL: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    baseURL: string;
+    displayName?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+}, {
+    name: string;
+    baseURL: string;
+    displayName?: string | undefined;
+    maxInputTokens?: number | undefined;
+    maxOutputTokens?: number | undefined;
+}>;
+export type CustomModel = z.output<typeof CustomModelSchema>;
+/**
+ * Get the path to the custom models storage file.
+ */
+export declare function getCustomModelsPath(): string;
+/**
+ * Load custom models from storage.
+ */
+export declare function loadCustomModels(): Promise<CustomModel[]>;
+/**
+ * Save a custom model to storage.
+ */
+export declare function saveCustomModel(model: CustomModel): Promise<void>;
+/**
+ * Delete a custom model by name.
+ */
+export declare function deleteCustomModel(name: string): Promise<boolean>;
+/**
+ * Get a specific custom model by name.
+ */
+export declare function getCustomModel(name: string): Promise<CustomModel | null>;
+//# sourceMappingURL=custom-models.d.ts.map

package/dist/models/custom-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-models.d.ts","sourceRoot":"","sources":["../../src/models/custom-models.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO7D;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAmB/D;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBvE;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUtE;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAG9E"}

package/dist/models/custom-models.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { promises as fs } from "fs";
+import * as path from "path";
+import { getDextoGlobalPath } from "../utils/path.js";
+const CustomModelSchema = z.object({
+  name: z.string().min(1),
+  baseURL: z.string().url(),
+  displayName: z.string().optional(),
+  maxInputTokens: z.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional()
+});
+const StorageSchema = z.object({
+  version: z.literal(1),
+  models: z.array(CustomModelSchema)
+});
+function getCustomModelsPath() {
+  return getDextoGlobalPath("models", "custom-models.json");
+}
+async function loadCustomModels() {
+  const filePath = getCustomModelsPath();
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const parsed = StorageSchema.safeParse(JSON.parse(content));
+    if (!parsed.success) {
+      console.warn(
+        `[custom-models] Failed to parse ${filePath}: ${parsed.error.issues.map((i) => i.message).join(", ")}`
+      );
+      return [];
+    }
+    return parsed.data.models;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function saveCustomModel(model) {
+  const parsed = CustomModelSchema.safeParse(model);
+  if (!parsed.success) {
+    throw new Error(`Invalid model: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+  }
+  const models = await loadCustomModels();
+  const existingIndex = models.findIndex((m) => m.name === parsed.data.name);
+  if (existingIndex >= 0) {
+    models[existingIndex] = parsed.data;
+  } else {
+    models.push(parsed.data);
+  }
+  await writeCustomModels(models);
+}
+async function deleteCustomModel(name) {
+  const models = await loadCustomModels();
+  const filtered = models.filter((m) => m.name !== name);
+  if (filtered.length === models.length) {
+    return false;
+  }
+  await writeCustomModels(filtered);
+  return true;
+}
+async function getCustomModel(name) {
+  const models = await loadCustomModels();
+  return models.find((m) => m.name === name) ?? null;
+}
+async function writeCustomModels(models) {
+  const filePath = getCustomModelsPath();
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify({ version: 1, models }, null, 2), "utf-8");
+}
+export {
+  CustomModelSchema,
+  deleteCustomModel,
+  getCustomModel,
+  getCustomModelsPath,
+  loadCustomModels,
+  saveCustomModel
+};

package/dist/registry/registry.cjs

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var registry_exports = {};
 __export(registry_exports, {
   LocalAgentRegistry: () => LocalAgentRegistry,
-  getAgentRegistry: () => getAgentRegistry
+  getAgentRegistry: () => getAgentRegistry,
+  loadBundledRegistryAgents: () => loadBundledRegistryAgents
 });
 module.exports = __toCommonJS(registry_exports);
 var import_fs = require("fs");
@@ -167,6 +168,10 @@ 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
@@ -472,8 +477,22 @@ function getAgentRegistry() {
   }
   return cachedRegistry;
 }
+function loadBundledRegistryAgents() {
+  try {
+    const registryPath = (0, import_path2.resolveBundledScript)("agents/agent-registry.json");
+    const content = (0, import_fs.readFileSync)(registryPath, "utf-8");
+    const registry = JSON.parse(content);
+    return registry.agents || {};
+  } catch (error) {
+    import_core.logger.warn(
+      `Could not load bundled registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {};
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LocalAgentRegistry,
-  getAgentRegistry
+  getAgentRegistry,
+  loadBundledRegistryAgents
 });

package/dist/registry/registry.d.ts

@@ -127,4 +127,9 @@ export declare class LocalAgentRegistry implements AgentRegistry {
  * Get cached registry instance (singleton pattern)
  */
 export declare function getAgentRegistry(): LocalAgentRegistry;
+/**
+ * Load bundled agent registry (agents field only)
+ * Returns empty object on error - use for non-critical lookups like display names
+ */
+export declare function loadBundledRegistryAgents(): Record<string, AgentRegistryEntry>;
 //# sourceMappingURL=registry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry/registry.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,QAAQ,EAER,aAAa,EACb,kBAAkB,EAErB,MAAM,YAAY,CAAC;AAYpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IACpD,OAAO,CAAC,SAAS,CAAyB;IAE1C;;OAEG;IACH,WAAW,IAAI,QAAQ;IAOvB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAyCpB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKlC;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAKxD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgC7B;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAqC5D;;;;OAIG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,GAAE,OAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAqGvF;;;;;;;OAOG;IACG,0BAA0B,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;KACjB,EACD,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC;IAqKlB;;;;;;;OAOG;IACG,YAAY,CACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAc,EAC3B,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC;IAsClB;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAsB7C;;OAEG;YACW,sBAAsB;IAYpC;;;;;;OAMG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CA8C/E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAKrD"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry/registry.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,QAAQ,EAER,aAAa,EACb,kBAAkB,EAErB,MAAM,YAAY,CAAC;AAYpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IACpD,OAAO,CAAC,SAAS,CAAyB;IAE1C;;OAEG;IACH,WAAW,IAAI,QAAQ;IAOvB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAyCpB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKlC;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAKxD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgC7B;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IA0C5D;;;;OAIG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,GAAE,OAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAqGvF;;;;;;;OAOG;IACG,0BAA0B,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;KACjB,EACD,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC;IAqKlB;;;;;;;OAOG;IACG,YAAY,CACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAc,EAC3B,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC;IAsClB;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAsB7C;;OAEG;YACW,sBAAsB;IAYpC;;;;;;OAMG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CA8C/E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAKrD;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAY9E"}

package/dist/registry/registry.js

@@ -141,6 +141,10 @@ 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
@@ -446,7 +450,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[];