@dexto/server 1.2.5

package/dist/hono/routes/agents.cjs

@@ -0,0 +1,735 @@
+"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 agents_exports = {};
+__export(agents_exports, {
+  createAgentsRouter: () => createAgentsRouter
+});
+module.exports = __toCommonJS(agents_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_agent_management = require("@dexto/agent-management");
+var import_agent_management2 = require("@dexto/agent-management");
+var import_yaml = require("yaml");
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_core2 = require("@dexto/core");
+var import_responses = require("../schemas/responses.js");
+const AgentIdentifierSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().min(1, "Agent id is required").describe('Unique agent identifier (e.g., "database-agent")'),
+  path: import_zod_openapi.z.string().optional().describe(
+    'Optional absolute file path for file-based agents (e.g., "/path/to/agent.yml")'
+  )
+}).strict().describe("Agent identifier for switching agents by ID or file path");
+const UninstallAgentSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().min(1, "Agent id is required").describe("Unique agent identifier to uninstall"),
+  force: import_zod_openapi.z.boolean().default(false).describe("Force uninstall even if agent is currently active")
+}).strict().describe("Request body for uninstalling an agent");
+const CustomAgentInstallSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().min(1, "Agent id is required").describe("Unique agent identifier"),
+  name: import_zod_openapi.z.string().optional().describe("Display name (defaults to derived from id)"),
+  sourcePath: import_zod_openapi.z.string().min(1).describe("Path to agent configuration file or directory"),
+  metadata: import_zod_openapi.z.object({
+    description: import_zod_openapi.z.string().min(1).describe("Human-readable description of the agent"),
+    author: import_zod_openapi.z.string().min(1).describe("Agent author or organization name"),
+    tags: import_zod_openapi.z.array(import_zod_openapi.z.string()).describe("Tags for categorizing the agent"),
+    main: import_zod_openapi.z.string().optional().describe("Main configuration file name within source directory")
+  }).strict().describe("Agent metadata including description, author, and tags"),
+  injectPreferences: import_zod_openapi.z.boolean().default(true).describe("Whether to inject user preferences into agent config")
+}).strict().describe("Request body for installing a custom agent from file system").transform((value) => {
+  const displayName = value.name?.trim() || (0, import_agent_management2.deriveDisplayName)(value.id);
+  return {
+    id: value.id,
+    displayName,
+    sourcePath: value.sourcePath,
+    metadata: value.metadata,
+    injectPreferences: value.injectPreferences
+  };
+});
+const CustomAgentCreateSchema = import_zod_openapi.z.object({
+  // Registry metadata
+  id: import_zod_openapi.z.string().min(1, "Agent ID is required").regex(
+    /^[a-z0-9-]+$/,
+    "Agent ID must contain only lowercase letters, numbers, and hyphens"
+  ).describe("Unique agent identifier"),
+  name: import_zod_openapi.z.string().min(1, "Agent name is required").describe("Display name for the agent"),
+  description: import_zod_openapi.z.string().min(1, "Description is required").describe("One-line description of the agent"),
+  author: import_zod_openapi.z.string().optional().describe("Author or organization"),
+  tags: import_zod_openapi.z.array(import_zod_openapi.z.string()).default([]).describe("Tags for discovery"),
+  // Full agent configuration
+  config: import_core.AgentConfigSchema.describe("Complete agent configuration")
+}).strict().describe("Request body for creating a new custom agent with full configuration");
+const AgentConfigValidateSchema = import_zod_openapi.z.object({
+  yaml: import_zod_openapi.z.string().describe("YAML agent configuration content to validate")
+}).describe("Request body for validating agent configuration YAML");
+const AgentConfigSaveSchema = import_zod_openapi.z.object({
+  yaml: import_zod_openapi.z.string().min(1, "YAML content is required").describe("YAML agent configuration content to save")
+}).describe("Request body for saving agent configuration YAML");
+const AgentInfoNullableSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().nullable().describe("Agent identifier (null if no active agent)"),
+  name: import_zod_openapi.z.string().nullable().describe("Agent display name (null if no active agent)")
+}).strict().describe("Basic agent information (nullable)");
+const ListAgentsResponseSchema = import_zod_openapi.z.object({
+  installed: import_zod_openapi.z.array(import_responses.AgentRegistryEntrySchema).describe("Agents installed locally"),
+  available: import_zod_openapi.z.array(import_responses.AgentRegistryEntrySchema).describe("Agents available from registry"),
+  current: AgentInfoNullableSchema.describe("Currently active agent")
+}).strict().describe("List of all agents");
+const InstallAgentResponseSchema = import_zod_openapi.z.object({
+  installed: import_zod_openapi.z.literal(true).describe("Indicates successful installation"),
+  id: import_zod_openapi.z.string().describe("Installed agent ID"),
+  name: import_zod_openapi.z.string().describe("Installed agent name"),
+  type: import_zod_openapi.z.enum(["builtin", "custom"]).describe("Type of agent installed")
+}).strict().describe("Agent installation response");
+const SwitchAgentResponseSchema = import_zod_openapi.z.object({
+  switched: import_zod_openapi.z.literal(true).describe("Indicates successful agent switch"),
+  id: import_zod_openapi.z.string().describe("New active agent ID"),
+  name: import_zod_openapi.z.string().describe("New active agent name")
+}).strict().describe("Agent switch response");
+const ValidateNameResponseSchema = import_zod_openapi.z.object({
+  valid: import_zod_openapi.z.boolean().describe("Whether the agent name is valid"),
+  conflict: import_zod_openapi.z.string().optional().describe("Type of conflict if name is invalid"),
+  message: import_zod_openapi.z.string().optional().describe("Validation message")
+}).strict().describe("Agent name validation result");
+const UninstallAgentResponseSchema = import_zod_openapi.z.object({
+  uninstalled: import_zod_openapi.z.literal(true).describe("Indicates successful uninstallation"),
+  id: import_zod_openapi.z.string().describe("Uninstalled agent ID")
+}).strict().describe("Agent uninstallation response");
+const AgentPathResponseSchema = import_zod_openapi.z.object({
+  path: import_zod_openapi.z.string().describe("Absolute path to agent configuration file"),
+  relativePath: import_zod_openapi.z.string().describe("Relative path or basename"),
+  name: import_zod_openapi.z.string().describe("Agent configuration filename without extension"),
+  isDefault: import_zod_openapi.z.boolean().describe("Whether this is the default agent")
+}).strict().describe("Agent file path information");
+const AgentConfigResponseSchema = import_zod_openapi.z.object({
+  yaml: import_zod_openapi.z.string().describe("Raw YAML configuration content"),
+  path: import_zod_openapi.z.string().describe("Absolute path to configuration file"),
+  relativePath: import_zod_openapi.z.string().describe("Relative path or basename"),
+  lastModified: import_zod_openapi.z.date().describe("Last modification timestamp"),
+  warnings: import_zod_openapi.z.array(import_zod_openapi.z.string()).describe("Configuration warnings")
+}).strict().describe("Agent configuration content");
+const SaveConfigResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(true).describe("Indicates successful save"),
+  path: import_zod_openapi.z.string().describe("Path to saved configuration file"),
+  reloaded: import_zod_openapi.z.boolean().describe("Whether configuration was reloaded"),
+  restarted: import_zod_openapi.z.boolean().describe("Whether agent was restarted"),
+  changesApplied: import_zod_openapi.z.array(import_zod_openapi.z.string()).describe("List of changes that were applied"),
+  message: import_zod_openapi.z.string().describe("Success message")
+}).strict().describe("Configuration save result");
+function createAgentsRouter(getAgent, context) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const { switchAgentById, switchAgentByPath, resolveAgentInfo, getActiveAgentId } = context;
+  const listRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/agents",
+    summary: "List Agents",
+    description: "Retrieves all agents (installed, available, and current active agent)",
+    tags: ["agents"],
+    responses: {
+      200: {
+        description: "List all agents",
+        content: { "application/json": { schema: ListAgentsResponseSchema } }
+      }
+    }
+  });
+  const currentRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/agents/current",
+    summary: "Get Current Agent",
+    description: "Retrieves the currently active agent",
+    tags: ["agents"],
+    responses: {
+      200: {
+        description: "Current agent",
+        content: { "application/json": { schema: AgentInfoNullableSchema } }
+      }
+    }
+  });
+  const installRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agents/install",
+    summary: "Install Agent",
+    description: "Installs an agent from the registry or from a custom source",
+    tags: ["agents"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.union([CustomAgentInstallSchema, AgentIdentifierSchema])
+          }
+        }
+      }
+    },
+    responses: {
+      201: {
+        description: "Agent installed",
+        content: { "application/json": { schema: InstallAgentResponseSchema } }
+      }
+    }
+  });
+  const switchRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agents/switch",
+    summary: "Switch Agent",
+    description: "Switches to a different agent by ID or file path",
+    tags: ["agents"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: AgentIdentifierSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Agent switched",
+        content: { "application/json": { schema: SwitchAgentResponseSchema } }
+      }
+    }
+  });
+  const validateNameRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agents/validate-name",
+    summary: "Validate Agent Name",
+    description: "Checks if an agent ID conflicts with existing agents",
+    tags: ["agents"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: AgentIdentifierSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Name validation result",
+        content: { "application/json": { schema: ValidateNameResponseSchema } }
+      }
+    }
+  });
+  const uninstallRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agents/uninstall",
+    summary: "Uninstall Agent",
+    description: "Removes an agent from the system. Custom agents are removed from registry; builtin agents can be reinstalled",
+    tags: ["agents"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: UninstallAgentSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Agent uninstalled",
+        content: { "application/json": { schema: UninstallAgentResponseSchema } }
+      }
+    }
+  });
+  const customCreateRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agents/custom/create",
+    summary: "Create Custom Agent",
+    description: "Creates a new custom agent from scratch via the UI/API",
+    tags: ["agents"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: CustomAgentCreateSchema
+          }
+        }
+      }
+    },
+    responses: {
+      201: {
+        description: "Custom agent created",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              created: import_zod_openapi.z.literal(true).describe("Creation success indicator"),
+              id: import_zod_openapi.z.string().describe("Agent identifier"),
+              name: import_zod_openapi.z.string().describe("Agent name")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getPathRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/agent/path",
+    summary: "Get Agent File Path",
+    description: "Retrieves the file path of the currently active agent configuration",
+    tags: ["agent"],
+    responses: {
+      200: {
+        description: "Agent file path",
+        content: {
+          "application/json": {
+            schema: AgentPathResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const getConfigRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/agent/config",
+    summary: "Get Agent Configuration",
+    description: "Retrieves the raw YAML configuration of the currently active agent",
+    tags: ["agent"],
+    responses: {
+      200: {
+        description: "Agent configuration",
+        content: {
+          "application/json": {
+            schema: AgentConfigResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const validateConfigRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agent/validate",
+    summary: "Validate Agent Configuration",
+    description: "Validates YAML agent configuration without saving it",
+    tags: ["agent"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: AgentConfigValidateSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Validation result",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              valid: import_zod_openapi.z.boolean().describe("Whether configuration is valid"),
+              errors: import_zod_openapi.z.array(
+                import_zod_openapi.z.object({
+                  line: import_zod_openapi.z.number().int().optional().describe("Line number"),
+                  column: import_zod_openapi.z.number().int().optional().describe("Column number"),
+                  path: import_zod_openapi.z.string().optional().describe("Configuration path"),
+                  message: import_zod_openapi.z.string().describe("Error message"),
+                  code: import_zod_openapi.z.string().describe("Error code")
+                }).passthrough()
+              ).describe("Validation errors"),
+              warnings: import_zod_openapi.z.array(
+                import_zod_openapi.z.object({
+                  path: import_zod_openapi.z.string().describe("Configuration path"),
+                  message: import_zod_openapi.z.string().describe("Warning message"),
+                  code: import_zod_openapi.z.string().describe("Warning code")
+                }).strict()
+              ).describe("Configuration warnings")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const saveConfigRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/agent/config",
+    summary: "Save Agent Configuration",
+    description: "Saves and applies YAML agent configuration. Creates backup before saving",
+    tags: ["agent"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: AgentConfigSaveSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Configuration saved",
+        content: {
+          "application/json": {
+            schema: SaveConfigResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const exportConfigRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/agent/config/export",
+    summary: "Export Agent Configuration",
+    description: "Exports the effective agent configuration with sensitive values redacted",
+    tags: ["agent"],
+    request: {
+      query: import_zod_openapi.z.object({
+        sessionId: import_zod_openapi.z.string().optional().describe("Session identifier to export session-specific configuration")
+      })
+    },
+    responses: {
+      200: {
+        description: "Exported configuration",
+        content: { "application/x-yaml": { schema: import_zod_openapi.z.string() } }
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agents = await import_agent_management2.Dexto.listAgents();
+    const currentId = getActiveAgentId() ?? null;
+    return ctx.json({
+      installed: agents.installed,
+      available: agents.available,
+      current: currentId ? await resolveAgentInfo(currentId) : { id: null, name: null }
+    });
+  }).openapi(currentRoute, async (ctx) => {
+    const currentId = getActiveAgentId() ?? null;
+    if (!currentId) {
+      return ctx.json({ id: null, name: null });
+    }
+    return ctx.json(await resolveAgentInfo(currentId));
+  }).openapi(installRoute, async (ctx) => {
+    const body = ctx.req.valid("json");
+    if ("sourcePath" in body && "metadata" in body) {
+      const { id, displayName, sourcePath, metadata, injectPreferences } = body;
+      await import_agent_management2.Dexto.installCustomAgent(
+        id,
+        sourcePath,
+        {
+          name: displayName,
+          description: metadata.description,
+          author: metadata.author,
+          tags: metadata.tags,
+          ...metadata.main ? { main: metadata.main } : {}
+        },
+        injectPreferences
+      );
+      return ctx.json(
+        { installed: true, id, name: displayName, type: "custom" },
+        201
+      );
+    } else {
+      const { id } = body;
+      await import_agent_management2.Dexto.installAgent(id);
+      const agentInfo = await resolveAgentInfo(id);
+      return ctx.json(
+        {
+          installed: true,
+          ...agentInfo,
+          type: "builtin"
+        },
+        201
+      );
+    }
+  }).openapi(switchRoute, async (ctx) => {
+    const { id, path: filePath } = ctx.req.valid("json");
+    const result = filePath ? await switchAgentByPath(filePath) : await switchAgentById(id);
+    return ctx.json({ switched: true, ...result });
+  }).openapi(validateNameRoute, async (ctx) => {
+    const { id } = ctx.req.valid("json");
+    const agents = await import_agent_management2.Dexto.listAgents();
+    const installedAgent = agents.installed.find((a) => a.id === id);
+    if (installedAgent) {
+      return ctx.json({
+        valid: false,
+        conflict: installedAgent.type,
+        message: `Agent id '${id}' already exists (${installedAgent.type})`
+      });
+    }
+    const availableAgent = agents.available.find((a) => a.id === id);
+    if (availableAgent) {
+      return ctx.json({
+        valid: false,
+        conflict: availableAgent.type,
+        message: `Agent id '${id}' conflicts with ${availableAgent.type} agent`
+      });
+    }
+    return ctx.json({ valid: true });
+  }).openapi(uninstallRoute, async (ctx) => {
+    const { id, force } = ctx.req.valid("json");
+    await import_agent_management2.Dexto.uninstallAgent(id, force);
+    return ctx.json({ uninstalled: true, id });
+  }).openapi(customCreateRoute, async (ctx) => {
+    const { id, name, description, author, tags, config } = ctx.req.valid("json");
+    const provider = config.llm.provider;
+    let agentConfig = config;
+    if (config.llm.apiKey && !config.llm.apiKey.startsWith("$")) {
+      const meta = await (0, import_agent_management.saveProviderApiKey)(provider, config.llm.apiKey, process.cwd());
+      const apiKeyRef = `$${meta.envVar}`;
+      import_core.logger.info(
+        `Stored API key securely for ${provider}, using env var: ${meta.envVar}`
+      );
+      agentConfig = {
+        ...config,
+        llm: {
+          ...config.llm,
+          apiKey: apiKeyRef
+        }
+      };
+    } else if (!config.llm.apiKey) {
+      agentConfig = {
+        ...config,
+        llm: {
+          ...config.llm,
+          apiKey: `$${(0, import_agent_management.getPrimaryApiKeyEnvVar)(provider)}`
+        }
+      };
+    }
+    const yamlContent = (0, import_yaml.stringify)(agentConfig);
+    import_core.logger.info(
+      `Creating agent config for ${id}: agentConfig=${(0, import_core.safeStringify)(agentConfig)}, yamlContent=${yamlContent}`
+    );
+    const tmpDir = import_os.default.tmpdir();
+    const tmpFile = import_path.default.join(tmpDir, `${id}-${Date.now()}.yml`);
+    await import_fs.promises.writeFile(tmpFile, yamlContent, "utf-8");
+    try {
+      await import_agent_management2.Dexto.installCustomAgent(
+        id,
+        tmpFile,
+        {
+          name,
+          description,
+          author: author || "Custom",
+          tags: tags || []
+        },
+        false
+        // Don't inject preferences
+      );
+      await import_fs.promises.unlink(tmpFile).catch(() => {
+      });
+      return ctx.json({ created: true, id, name }, 201);
+    } catch (installError) {
+      await import_fs.promises.unlink(tmpFile).catch(() => {
+      });
+      throw installError;
+    }
+  }).openapi(getPathRoute, (ctx) => {
+    const agent = getAgent();
+    const agentPath = agent.getAgentFilePath();
+    const relativePath = import_path.default.basename(agentPath);
+    const ext = import_path.default.extname(agentPath);
+    const name = import_path.default.basename(agentPath, ext);
+    return ctx.json({
+      path: agentPath,
+      relativePath,
+      name,
+      isDefault: name === "default-agent"
+    });
+  }).openapi(getConfigRoute, async (ctx) => {
+    const agent = getAgent();
+    const agentPath = agent.getAgentFilePath();
+    const yamlContent = await import_fs.promises.readFile(agentPath, "utf-8");
+    const stats = await import_fs.promises.stat(agentPath);
+    return ctx.json({
+      yaml: yamlContent,
+      path: agentPath,
+      relativePath: import_path.default.basename(agentPath),
+      lastModified: stats.mtime,
+      warnings: [
+        "Environment variables ($VAR) will be resolved at runtime",
+        "API keys should use environment variables"
+      ]
+    });
+  }).openapi(validateConfigRoute, async (ctx) => {
+    const { yaml } = ctx.req.valid("json");
+    let parsed;
+    try {
+      parsed = (0, import_yaml.parse)(yaml);
+    } catch (parseError) {
+      return ctx.json({
+        valid: false,
+        errors: [
+          {
+            line: parseError.linePos?.[0]?.line || 1,
+            column: parseError.linePos?.[0]?.col || 1,
+            message: parseError.message,
+            code: "YAML_PARSE_ERROR"
+          }
+        ],
+        warnings: []
+      });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return ctx.json({
+        valid: false,
+        errors: [
+          {
+            line: 1,
+            column: 1,
+            message: "Configuration must be a valid YAML object",
+            code: "INVALID_CONFIG_TYPE"
+          }
+        ],
+        warnings: []
+      });
+    }
+    const enriched = (0, import_agent_management.enrichAgentConfig)(parsed, void 0);
+    const result = import_core.AgentConfigSchema.safeParse(enriched);
+    if (!result.success) {
+      const issues = (0, import_core.zodToIssues)(result.error);
+      const errors = issues.map((issue) => ({
+        path: issue.path?.join(".") ?? "root",
+        message: issue.message,
+        code: "SCHEMA_VALIDATION_ERROR"
+      }));
+      return ctx.json({
+        valid: false,
+        errors,
+        warnings: []
+      });
+    }
+    const warnings = [];
+    if (parsed.llm?.apiKey && !parsed.llm.apiKey.startsWith("$")) {
+      warnings.push({
+        path: "llm.apiKey",
+        message: "Consider using environment variable instead of plain text",
+        code: "SECURITY_WARNING"
+      });
+    }
+    return ctx.json({
+      valid: true,
+      errors: [],
+      warnings
+    });
+  }).openapi(saveConfigRoute, async (ctx) => {
+    const agent = getAgent();
+    const { yaml } = ctx.req.valid("json");
+    let parsed;
+    try {
+      parsed = (0, import_yaml.parse)(yaml);
+    } catch (parseError) {
+      throw new import_core2.DextoValidationError([
+        {
+          code: import_core2.AgentErrorCode.INVALID_CONFIG,
+          message: `Invalid YAML syntax: ${parseError.message}`,
+          scope: import_core2.ErrorScope.AGENT,
+          type: import_core2.ErrorType.USER,
+          severity: "error"
+        }
+      ]);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new import_core2.DextoValidationError([
+        {
+          code: import_core2.AgentErrorCode.INVALID_CONFIG,
+          message: "Configuration must be a valid YAML object",
+          scope: import_core2.ErrorScope.AGENT,
+          type: import_core2.ErrorType.USER,
+          severity: "error"
+        }
+      ]);
+    }
+    const agentPath = agent.getAgentFilePath();
+    const enriched = (0, import_agent_management.enrichAgentConfig)(parsed, agentPath);
+    const validationResult = import_core.AgentConfigSchema.safeParse(enriched);
+    if (!validationResult.success) {
+      throw new import_core2.DextoValidationError(
+        validationResult.error.errors.map((err) => ({
+          code: import_core2.AgentErrorCode.INVALID_CONFIG,
+          message: `${err.path.join(".")}: ${err.message}`,
+          scope: import_core2.ErrorScope.AGENT,
+          type: import_core2.ErrorType.USER,
+          severity: "error"
+        }))
+      );
+    }
+    const backupPath = `${agentPath}.backup`;
+    await import_fs.promises.copyFile(agentPath, backupPath);
+    try {
+      await import_fs.promises.writeFile(agentPath, yaml, "utf-8");
+      const newConfig = await (0, import_agent_management.reloadAgentConfigFromFile)(agentPath);
+      const enrichedConfig = (0, import_agent_management.enrichAgentConfig)(newConfig, agentPath);
+      const reloadResult = await agent.reload(enrichedConfig);
+      if (reloadResult.restarted) {
+        import_core.logger.info(
+          `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
+        );
+      } else if (reloadResult.changesApplied.length === 0) {
+        import_core.logger.info("Configuration saved (no changes detected)");
+      }
+      await import_fs.promises.unlink(backupPath).catch(() => {
+      });
+      import_core.logger.info(`Agent configuration saved and applied: ${agentPath}`);
+      return ctx.json({
+        ok: true,
+        path: agentPath,
+        reloaded: true,
+        restarted: reloadResult.restarted,
+        changesApplied: reloadResult.changesApplied,
+        message: reloadResult.restarted ? "Configuration saved and applied successfully (agent restarted)" : "Configuration saved successfully (no changes detected)"
+      });
+    } catch (error) {
+      await import_fs.promises.copyFile(backupPath, agentPath).catch(() => {
+      });
+      throw error;
+    }
+  }).openapi(exportConfigRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("query");
+    const config = agent.getEffectiveConfig(sessionId);
+    const maskedConfig = {
+      ...config,
+      llm: {
+        ...config.llm,
+        apiKey: config.llm.apiKey ? "[REDACTED]" : void 0
+      },
+      mcpServers: config.mcpServers ? Object.fromEntries(
+        Object.entries(config.mcpServers).map(([name, serverConfig]) => [
+          name,
+          serverConfig.type === "stdio" && serverConfig.env ? {
+            ...serverConfig,
+            env: Object.fromEntries(
+              Object.keys(serverConfig.env).map((key) => [
+                key,
+                "[REDACTED]"
+              ])
+            )
+          } : serverConfig
+        ])
+      ) : void 0
+    };
+    const yamlStr = (0, import_yaml.stringify)(maskedConfig);
+    ctx.header("Content-Type", "application/x-yaml");
+    return ctx.body(yamlStr);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAgentsRouter
+});