@dexto/core 1.1.10 → 1.1.11

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

@@ -1,100 +1,142 @@
 import { z } from 'zod';
-
+export declare function deriveDisplayName(slug: string): string;
 /**
  * Schema for agent data in registry JSON
  */
-declare const AgentRegistryEntrySchema: z.ZodObject<{
+export declare const AgentRegistryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
     description: z.ZodString;
     author: z.ZodString;
     tags: z.ZodArray<z.ZodString, "many">;
     source: z.ZodString;
     main: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["builtin", "custom"]>>;
 }, "strict", z.ZodTypeAny, {
+    name: string;
+    type: "custom" | "builtin";
     description: string;
-    source: string;
+    id: string;
     tags: string[];
+    source: string;
     author: string;
     main?: string | undefined;
 }, {
+    name: string;
     description: string;
-    source: string;
+    id: string;
     tags: string[];
+    source: string;
     author: string;
+    type?: "custom" | "builtin" | undefined;
     main?: string | undefined;
 }>;
-type AgentRegistryEntry = z.output<typeof AgentRegistryEntrySchema>;
+export type AgentRegistryEntry = z.output<typeof AgentRegistryEntrySchema>;
 /**
  * Schema for complete registry JSON
  */
-declare const RegistrySchema: z.ZodObject<{
+export declare const RegistrySchema: z.ZodObject<{
     version: z.ZodString;
     agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
         description: z.ZodString;
         author: z.ZodString;
         tags: z.ZodArray<z.ZodString, "many">;
         source: z.ZodString;
         main: z.ZodOptional<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<["builtin", "custom"]>>;
     }, "strict", z.ZodTypeAny, {
+        name: string;
+        type: "custom" | "builtin";
         description: string;
-        source: string;
+        id: string;
         tags: string[];
+        source: string;
         author: string;
         main?: string | undefined;
     }, {
+        name: string;
         description: string;
-        source: string;
+        id: string;
         tags: string[];
+        source: string;
         author: string;
+        type?: "custom" | "builtin" | undefined;
         main?: string | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
     version: string;
     agents: Record<string, {
+        name: string;
+        type: "custom" | "builtin";
         description: string;
-        source: string;
+        id: string;
         tags: string[];
+        source: string;
         author: string;
         main?: string | undefined;
     }>;
 }, {
     version: string;
     agents: Record<string, {
+        name: string;
         description: string;
-        source: string;
+        id: string;
         tags: string[];
+        source: string;
         author: string;
+        type?: "custom" | "builtin" | undefined;
         main?: string | undefined;
     }>;
 }>;
-type Registry = z.output<typeof RegistrySchema>;
+export type Registry = z.output<typeof RegistrySchema>;
+type RawRegistry = {
+    version?: unknown;
+    agents?: Record<string, unknown> | unknown;
+};
+/**
+ * Normalize registry JSON data to ensure consistency.
+ * Validates that id field matches the registry key and derives display names if missing.
+ */
+export declare function normalizeRegistryJson(raw: unknown): RawRegistry;
 /**
  * Agent registry interface
  */
-interface AgentRegistry {
+export interface AgentRegistry {
     /**
-     * Returns true if the registry contains an agent with the provided name
+     * Returns true if the registry contains an agent with the provided ID
      */
-    hasAgent(name: string): boolean;
+    hasAgent(agentId: string): boolean;
     /**
-     * Returns a map of available agent names to their registry entries
+     * Returns a map of available agent IDs to their registry entries
      */
     getAvailableAgents(): Record<string, AgentRegistryEntry>;
     /**
-     * Installs an agent from the registry
+     * 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(agentName: string, injectPreferences?: boolean): Promise<string>;
+    installAgent(agentId: string, injectPreferences?: boolean): Promise<string>;
     /**
-     * Uninstalls an agent
+     * Uninstalls an agent by ID
+     * @param agentId - Unique agent identifier
+     * @param force - Whether to force uninstall protected agents (default: false)
      */
-    uninstallAgent(agentName: string, force?: boolean): Promise<void>;
+    uninstallAgent(agentId: string, force?: boolean): Promise<void>;
     /**
-     * Returns list of currently installed agents
+     * Returns list of currently installed agent IDs
      */
     getInstalledAgents(): Promise<string[]>;
     /**
-     * Resolves and installs/copies the agent; returns the installed path (or main file)
+     * 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(nameOrPath: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+    resolveAgent(idOrPath: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
 }
-
-export { type AgentRegistry, type AgentRegistryEntry, AgentRegistryEntrySchema, type Registry, RegistrySchema };
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/agent/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"}

package/dist/agent/registry/types.js

@@ -1,16 +1,47 @@
 import { z } from "zod";
+function deriveDisplayName(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
 const AgentRegistryEntrySchema = z.object({
+  id: z.string().describe("Unique identifier for the agent"),
+  name: z.string().describe("Display name for the agent"),
   description: z.string(),
   author: z.string(),
   tags: z.array(z.string()),
   source: z.string(),
-  main: z.string().optional()
+  main: z.string().optional(),
+  type: z.enum(["builtin", "custom"]).default("builtin").describe("Agent type")
 }).strict();
 const RegistrySchema = z.object({
   version: z.string(),
   agents: z.record(z.string(), AgentRegistryEntrySchema)
 }).strict();
+function normalizeRegistryJson(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { version: "1.0.0", agents: {} };
+  }
+  const input = raw;
+  const normalizedAgents = {};
+  const agents = input.agents && typeof input.agents === "object" && input.agents !== null ? input.agents : {};
+  for (const [agentId, value] of Object.entries(agents)) {
+    if (!value || typeof value !== "object") continue;
+    const entry = { ...value };
+    if (!entry.id || typeof entry.id !== "string" || entry.id.trim() !== agentId) {
+      entry.id = agentId;
+    }
+    if (!entry.name || typeof entry.name !== "string" || !entry.name.trim()) {
+      entry.name = deriveDisplayName(agentId);
+    }
+    normalizedAgents[agentId] = entry;
+  }
+  return {
+    version: typeof input.version === "string" && input.version.trim().length > 0 ? input.version : "1.0.0",
+    agents: normalizedAgents
+  };
+}
 export {
   AgentRegistryEntrySchema,
-  RegistrySchema
+  RegistrySchema,
+  deriveDisplayName,
+  normalizeRegistryJson
 };

package/dist/agent/registry/user-registry.cjs

@@ -0,0 +1,140 @@
+"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 user_registry_exports = {};
+__export(user_registry_exports, {
+  addAgentToUserRegistry: () => addAgentToUserRegistry,
+  getUserRegistryPath: () => getUserRegistryPath,
+  loadUserRegistry: () => loadUserRegistry,
+  mergeRegistries: () => mergeRegistries,
+  removeAgentFromUserRegistry: () => removeAgentFromUserRegistry,
+  saveUserRegistry: () => saveUserRegistry,
+  userRegistryHasAgent: () => userRegistryHasAgent
+});
+module.exports = __toCommonJS(user_registry_exports);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_path2 = require("../../utils/path.cjs");
+var import_types = require("./types.js");
+var import_errors = require("./errors.js");
+var import_logger = require("../../logger/index.cjs");
+const USER_REGISTRY_FILENAME = "user-agent-registry.json";
+function getUserRegistryPath() {
+  return (0, import_path2.getDextoGlobalPath)("", USER_REGISTRY_FILENAME);
+}
+function loadUserRegistry() {
+  const registryPath = getUserRegistryPath();
+  if (!(0, import_fs2.existsSync)(registryPath)) {
+    import_logger.logger.debug("User registry not found, returning empty registry");
+    return { version: "1.0.0", agents: {} };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(registryPath, "utf-8");
+    const data = JSON.parse(content);
+    return import_types.RegistrySchema.parse((0, import_types.normalizeRegistryJson)(data));
+  } catch (error) {
+    throw import_errors.RegistryError.registryParseError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveUserRegistry(registry) {
+  const registryPath = getUserRegistryPath();
+  const tempPath = `${registryPath}.tmp.${Date.now()}`;
+  const dextoDir = import_path.default.dirname(registryPath);
+  try {
+    await import_fs.promises.mkdir(dextoDir, { recursive: true });
+    await import_fs.promises.writeFile(tempPath, JSON.stringify(registry, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await import_fs.promises.rename(tempPath, registryPath);
+    import_logger.logger.debug(`Saved user registry to ${registryPath}`);
+  } catch (error) {
+    try {
+      if ((0, import_fs2.existsSync)(tempPath)) {
+        await import_fs.promises.rm(tempPath, { force: true });
+      }
+    } catch {
+    }
+    throw import_errors.RegistryError.registryWriteError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function mergeRegistries(bundled, user) {
+  return {
+    version: bundled.version,
+    agents: {
+      ...bundled.agents,
+      ...user.agents
+    }
+  };
+}
+function userRegistryHasAgent(agentId) {
+  const userRegistry = loadUserRegistry();
+  return agentId in userRegistry.agents;
+}
+async function addAgentToUserRegistry(agentId, entry) {
+  const userRegistry = loadUserRegistry();
+  if (agentId in userRegistry.agents) {
+    throw import_errors.RegistryError.agentAlreadyExists(agentId);
+  }
+  userRegistry.agents[agentId] = {
+    ...entry,
+    id: agentId,
+    // Force consistency between key and id field
+    name: entry.name && entry.name.trim().length > 0 ? entry.name : (0, import_types.deriveDisplayName)(agentId),
+    // Ensure name is never undefined or whitespace-only
+    type: "custom"
+  };
+  await saveUserRegistry(userRegistry);
+  import_logger.logger.info(`Added custom agent '${agentId}' to user registry`);
+}
+async function removeAgentFromUserRegistry(agentId) {
+  const userRegistry = loadUserRegistry();
+  if (!(agentId in userRegistry.agents)) {
+    throw import_errors.RegistryError.agentNotFound(agentId, Object.keys(userRegistry.agents));
+  }
+  delete userRegistry.agents[agentId];
+  await saveUserRegistry(userRegistry);
+  import_logger.logger.info(`Removed custom agent '${agentId}' from user registry`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAgentToUserRegistry,
+  getUserRegistryPath,
+  loadUserRegistry,
+  mergeRegistries,
+  removeAgentFromUserRegistry,
+  saveUserRegistry,
+  userRegistryHasAgent
+});

package/dist/agent/registry/user-registry.d.ts

@@ -0,0 +1,34 @@
+import { Registry, AgentRegistryEntry } from './types.js';
+/**
+ * Get path to user registry file
+ */
+export declare function getUserRegistryPath(): string;
+/**
+ * Load user registry from ~/.dexto/user-agent-registry.json
+ * Returns empty registry if file doesn't exist
+ */
+export declare function loadUserRegistry(): Registry;
+/**
+ * Save user registry atomically using temp file + rename
+ */
+export declare function saveUserRegistry(registry: Registry): Promise<void>;
+/**
+ * Merge bundled and user registries
+ * User registry only contains custom agents
+ * Name conflicts are not allowed (validated before adding to user registry)
+ */
+export declare function mergeRegistries(bundled: Registry, user: Registry): Registry;
+/**
+ * Check if agent exists in user registry
+ */
+export declare function userRegistryHasAgent(agentId: string): boolean;
+/**
+ * Add custom agent to user registry
+ * Validates that name doesn't conflict with bundled registry
+ */
+export declare function addAgentToUserRegistry(agentId: string, entry: Omit<AgentRegistryEntry, 'type'>): Promise<void>;
+/**
+ * Remove custom agent from user registry
+ */
+export declare function removeAgentFromUserRegistry(agentId: string): Promise<void>;
+//# sourceMappingURL=user-registry.d.ts.map

package/dist/agent/registry/user-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-registry.d.ts","sourceRoot":"","sources":["../../../src/agent/registry/user-registry.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,QAAQ,EAER,kBAAkB,EAGrB,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAkB3C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCxE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAQ3E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAG7D;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED;;GAEG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhF"}

package/dist/agent/registry/user-registry.js

@@ -0,0 +1,104 @@
+import { promises as fs, readFileSync } from "fs";
+import { existsSync } from "fs";
+import path from "path";
+import { getDextoGlobalPath } from "../../utils/path.js";
+import {
+  RegistrySchema,
+  normalizeRegistryJson,
+  deriveDisplayName
+} from "./types.js";
+import { RegistryError } from "./errors.js";
+import { logger } from "../../logger/index.js";
+const USER_REGISTRY_FILENAME = "user-agent-registry.json";
+function getUserRegistryPath() {
+  return getDextoGlobalPath("", USER_REGISTRY_FILENAME);
+}
+function loadUserRegistry() {
+  const registryPath = getUserRegistryPath();
+  if (!existsSync(registryPath)) {
+    logger.debug("User registry not found, returning empty registry");
+    return { version: "1.0.0", agents: {} };
+  }
+  try {
+    const content = readFileSync(registryPath, "utf-8");
+    const data = JSON.parse(content);
+    return RegistrySchema.parse(normalizeRegistryJson(data));
+  } catch (error) {
+    throw RegistryError.registryParseError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveUserRegistry(registry) {
+  const registryPath = getUserRegistryPath();
+  const tempPath = `${registryPath}.tmp.${Date.now()}`;
+  const dextoDir = path.dirname(registryPath);
+  try {
+    await fs.mkdir(dextoDir, { recursive: true });
+    await fs.writeFile(tempPath, JSON.stringify(registry, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await fs.rename(tempPath, registryPath);
+    logger.debug(`Saved user registry to ${registryPath}`);
+  } catch (error) {
+    try {
+      if (existsSync(tempPath)) {
+        await fs.rm(tempPath, { force: true });
+      }
+    } catch {
+    }
+    throw RegistryError.registryWriteError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function mergeRegistries(bundled, user) {
+  return {
+    version: bundled.version,
+    agents: {
+      ...bundled.agents,
+      ...user.agents
+    }
+  };
+}
+function userRegistryHasAgent(agentId) {
+  const userRegistry = loadUserRegistry();
+  return agentId in userRegistry.agents;
+}
+async function addAgentToUserRegistry(agentId, entry) {
+  const userRegistry = loadUserRegistry();
+  if (agentId in userRegistry.agents) {
+    throw RegistryError.agentAlreadyExists(agentId);
+  }
+  userRegistry.agents[agentId] = {
+    ...entry,
+    id: agentId,
+    // Force consistency between key and id field
+    name: entry.name && entry.name.trim().length > 0 ? entry.name : deriveDisplayName(agentId),
+    // Ensure name is never undefined or whitespace-only
+    type: "custom"
+  };
+  await saveUserRegistry(userRegistry);
+  logger.info(`Added custom agent '${agentId}' to user registry`);
+}
+async function removeAgentFromUserRegistry(agentId) {
+  const userRegistry = loadUserRegistry();
+  if (!(agentId in userRegistry.agents)) {
+    throw RegistryError.agentNotFound(agentId, Object.keys(userRegistry.agents));
+  }
+  delete userRegistry.agents[agentId];
+  await saveUserRegistry(userRegistry);
+  logger.info(`Removed custom agent '${agentId}' from user registry`);
+}
+export {
+  addAgentToUserRegistry,
+  getUserRegistryPath,
+  loadUserRegistry,
+  mergeRegistries,
+  removeAgentFromUserRegistry,
+  saveUserRegistry,
+  userRegistryHasAgent
+};

package/dist/agent/schemas.cjs

@@ -29,6 +29,9 @@ var import_schemas4 = require("../storage/schemas.cjs");
 var import_schemas5 = require("../systemPrompt/schemas.cjs");
 var import_schemas6 = require("../tools/schemas.cjs");
 var import_zod = require("zod");
+var import_schemas7 = require("../resources/schemas.cjs");
+var import_schemas8 = require("../prompts/schemas.cjs");
+var import_schemas9 = require("../plugins/schemas.cjs");
 const AgentCardSchema = import_zod.z.object({
   name: import_zod.z.string(),
   // No default, must be provided by context
@@ -99,12 +102,23 @@ const AgentConfigSchema = import_zod.z.object({
   // Storage configuration
   storage: import_schemas4.StorageSchema.default({
     cache: { type: "in-memory" },
-    database: { type: "in-memory" }
-  }).describe("Storage configuration for the agent using cache and database backends"),
+    database: { type: "in-memory" },
+    blob: { type: "local" }
+  }).describe("Storage configuration for cache, database, and blob storage"),
   sessions: import_schemas3.SessionConfigSchema.default({}).describe("Session management configuration"),
   toolConfirmation: import_schemas6.ToolConfirmationConfigSchema.default({}).describe(
     "Tool confirmation and approval configuration"
-  )
+  ),
+  // Internal resources configuration (filesystem, etc.)
+  internalResources: import_schemas7.InternalResourcesSchema.describe(
+    "Configuration for internal resources (filesystem, etc.)"
+  ).default([]),
+  // Agent-specific starter prompts configuration (used by WebUI and PromptManager)
+  starterPrompts: import_schemas8.StarterPromptsSchema,
+  // Plugin configuration
+  plugins: import_schemas9.PluginsConfigSchema.describe(
+    "Plugin system configuration for built-in and custom plugins"
+  ).default({})
 }).strict().describe("Main configuration for an agent, including its LLM and server connections").brand();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {