@dexto/server 1.5.7 → 1.6.0

package/dist/hono/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hono/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAgBzD,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AASlF,OAAO,EAGH,KAAK,kBAAkB,EAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAKxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AA+B1E,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAE5E,MAAM,MAAM,qBAAqB,GAAG;IAChC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,UAAU,CAAC;IACrB,YAAY,EAAE,MAAM,SAAS,CAAC;IAC9B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,aAAa,EAAE,qBAAqB,CAAC;IACrC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,+EAA+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAKF,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA4M5D;AAID,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAGxD,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hono/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAkBzD,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AASlF,OAAO,EAGH,KAAK,kBAAkB,EAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAKxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AA+B1E,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAC5E,MAAM,MAAM,oBAAoB,GAAG,CAC/B,GAAG,EAAE,OAAO,KACX,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAEtD,MAAM,MAAM,qBAAqB,GAAG;IAChC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,UAAU,CAAC;IACrB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,oBAAoB,CAAC;IAC1C,YAAY,EAAE,MAAM,SAAS,CAAC;IAC9B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,aAAa,EAAE,qBAAqB,CAAC;IACrC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,+EAA+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAKF,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA0N5D;AAID,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAGxD,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/hono/index.js

@@ -14,6 +14,8 @@ import { createWebhooksRouter } from "./routes/webhooks.js";
 import { createPromptsRouter } from "./routes/prompts.js";
 import { createResourcesRouter } from "./routes/resources.js";
 import { createMemoryRouter } from "./routes/memory.js";
+import { createWorkspacesRouter } from "./routes/workspaces.js";
+import { createSchedulesRouter } from "./routes/schedules.js";
 import { createAgentsRouter } from "./routes/agents.js";
 import { createApprovalsRouter } from "./routes/approvals.js";
 import { createQueueRouter } from "./routes/queue.js";
@@ -56,6 +58,7 @@ function createDextoApp(options) {
   const {
     apiPrefix,
     getAgent,
+    getAgentConfigPath,
     getAgentCard,
     approvalCoordinator,
     webhookSubscriber,
@@ -82,7 +85,15 @@ function createDextoApp(options) {
   app.use(middlewarePattern, prettyJsonMiddleware);
   app.use(middlewarePattern, redactionMiddleware);
   const routePrefix = normalizedPrefix;
-  const fullApp = app.route("/health", createHealthRouter(getAgent)).route("/", createA2aRouter(getAgentCard)).route("/", createA2AJsonRpcRouter(getAgent, sseSubscriber)).route("/", createA2ATasksRouter(getAgent, sseSubscriber)).route(routePrefix, createGreetingRouter(getAgent)).route(routePrefix, createMessagesRouter(getAgent, approvalCoordinator)).route(routePrefix, createLlmRouter(getAgent)).route(routePrefix, createSessionsRouter(getAgent)).route(routePrefix, createSearchRouter(getAgent)).route(routePrefix, createMcpRouter(getAgent)).route(routePrefix, createWebhooksRouter(getAgent, webhookSubscriber)).route(routePrefix, createPromptsRouter(getAgent)).route(routePrefix, createResourcesRouter(getAgent)).route(routePrefix, createMemoryRouter(getAgent)).route(routePrefix, createApprovalsRouter(getAgent, approvalCoordinator)).route(routePrefix, createAgentsRouter(getAgent, agentsContext || dummyAgentsContext)).route(routePrefix, createQueueRouter(getAgent)).route(routePrefix, createOpenRouterRouter()).route(routePrefix, createKeyRouter()).route(routePrefix, createToolsRouter(getAgent)).route(routePrefix, createDiscoveryRouter()).route(routePrefix, createModelsRouter()).route(routePrefix, createDextoAuthRouter(getAgent));
+  const resolvedGetAgentConfigPath = getAgentConfigPath ?? ((_ctx) => void 0);
+  const fullApp = app.route("/health", createHealthRouter(getAgent)).route("/", createA2aRouter(getAgentCard)).route("/", createA2AJsonRpcRouter(getAgent, sseSubscriber)).route("/", createA2ATasksRouter(getAgent, sseSubscriber)).route(routePrefix, createGreetingRouter(getAgent)).route(routePrefix, createMessagesRouter(getAgent, approvalCoordinator)).route(routePrefix, createLlmRouter(getAgent)).route(routePrefix, createSessionsRouter(getAgent)).route(routePrefix, createSearchRouter(getAgent)).route(routePrefix, createMcpRouter(getAgent, resolvedGetAgentConfigPath)).route(routePrefix, createWebhooksRouter(getAgent, webhookSubscriber)).route(routePrefix, createPromptsRouter(getAgent)).route(routePrefix, createResourcesRouter(getAgent)).route(routePrefix, createMemoryRouter(getAgent)).route(routePrefix, createWorkspacesRouter(getAgent)).route(routePrefix, createSchedulesRouter(getAgent)).route(routePrefix, createApprovalsRouter(getAgent, approvalCoordinator)).route(
+    routePrefix,
+    createAgentsRouter(
+      getAgent,
+      agentsContext || dummyAgentsContext,
+      resolvedGetAgentConfigPath
+    )
+  ).route(routePrefix, createQueueRouter(getAgent)).route(routePrefix, createOpenRouterRouter()).route(routePrefix, createKeyRouter()).route(routePrefix, createToolsRouter(getAgent)).route(routePrefix, createDiscoveryRouter(resolvedGetAgentConfigPath)).route(routePrefix, createModelsRouter()).route(routePrefix, createDextoAuthRouter(getAgent));
   fullApp.doc("/openapi.json", {
     openapi: "3.0.0",
     info: {
@@ -123,6 +134,10 @@ function createDextoApp(options) {
         name: "sessions",
         description: "Create and manage conversation sessions"
       },
+      {
+        name: "schedules",
+        description: "Create and manage automation schedules"
+      },
       {
         name: "llm",
         description: "Configure and switch between LLM providers and models"
@@ -173,7 +188,7 @@ function createDextoApp(options) {
       },
       {
         name: "tools",
-        description: "List and inspect available tools from internal, custom, and MCP sources"
+        description: "List and inspect available tools from local and MCP sources"
       },
       {
         name: "models",

package/dist/hono/routes/a2a-tasks.d.ts

@@ -69,19 +69,19 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
                     };
                     metadata?: Record<string, any> | undefined;
                     configuration?: {
-                        blocking?: boolean | undefined;
                         acceptedOutputModes?: string[] | undefined;
                         historyLength?: number | undefined;
                         pushNotificationConfig?: {
                             url: string;
                             headers?: Record<string, string> | undefined;
                         } | undefined;
+                        blocking?: boolean | undefined;
                     } | undefined;
                 };
             };
             output: {
                 status: {
-                    state: "unknown" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected";
+                    state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                     message?: {
                         role: "user" | "agent";
                         kind: "message";
@@ -183,7 +183,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
         $get: {
             input: {
                 query: {
-                    status?: "unknown" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected" | undefined;
+                    status?: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected" | undefined;
                     contextId?: string | undefined;
                     pageSize?: string | undefined;
                     historyLength?: string | undefined;
@@ -195,7 +195,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
             output: {
                 tasks: {
                     status: {
-                        state: "unknown" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected";
+                        state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                         message?: {
                             role: "user" | "agent";
                             kind: "message";
@@ -315,7 +315,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
             };
             output: {
                 status: {
-                    state: "unknown" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected";
+                    state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                     message?: {
                         role: "user" | "agent";
                         kind: "message";
@@ -431,7 +431,7 @@ export declare function createA2ATasksRouter(getAgent: GetAgentFn, sseSubscriber
             };
             output: {
                 status: {
-                    state: "unknown" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected";
+                    state: "unknown" | "failed" | "auth-required" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "rejected";
                     message?: {
                         role: "user" | "agent";
                         kind: "message";

package/dist/hono/routes/agents.cjs

@@ -32,6 +32,7 @@ __export(agents_exports, {
 });
 module.exports = __toCommonJS(agents_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
+var import_agent_config = require("@dexto/agent-config");
 var import_core = require("@dexto/core");
 var import_agent_management = require("@dexto/agent-management");
 var import_yaml = require("yaml");
@@ -141,9 +142,16 @@ const SaveConfigResponseSchema = import_zod_openapi.z.object({
   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) {
+function createAgentsRouter(getAgent, context, getAgentConfigPath) {
   const app = new import_zod_openapi.OpenAPIHono();
   const { switchAgentById, switchAgentByPath, resolveAgentInfo, getActiveAgentId } = context;
+  const resolveAgentConfigPath = async (ctx) => {
+    const configPath = await getAgentConfigPath(ctx);
+    if (!configPath) {
+      throw import_core.AgentError.noConfigPath();
+    }
+    return configPath;
+  };
   const listRoute = (0, import_zod_openapi.createRoute)({
     method: "get",
     path: "/agents",
@@ -528,8 +536,7 @@ function createAgentsRouter(getAgent, context) {
       throw installError;
     }
   }).openapi(getPathRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
-    const agentPath = agent.getAgentFilePath();
+    const agentPath = await resolveAgentConfigPath(ctx);
     const relativePath = import_path.default.basename(agentPath);
     const ext = import_path.default.extname(agentPath);
     const name = import_path.default.basename(agentPath, ext);
@@ -540,8 +547,7 @@ function createAgentsRouter(getAgent, context) {
       isDefault: name === "coding-agent"
     });
   }).openapi(getConfigRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
-    const agentPath = agent.getAgentFilePath();
+    const agentPath = await resolveAgentConfigPath(ctx);
     const yamlContent = await import_fs.promises.readFile(agentPath, "utf-8");
     const stats = await import_fs.promises.stat(agentPath);
     return ctx.json({
@@ -560,13 +566,15 @@ function createAgentsRouter(getAgent, context) {
     try {
       parsed = (0, import_yaml.parse)(yaml);
     } catch (parseError) {
+      const message = parseError instanceof Error ? parseError.message : String(parseError);
+      const linePos = typeof parseError === "object" && parseError !== null && "linePos" in parseError ? parseError.linePos : void 0;
       return ctx.json({
         valid: false,
         errors: [
           {
-            line: parseError.linePos?.[0]?.line || 1,
-            column: parseError.linePos?.[0]?.col || 1,
-            message: parseError.message,
+            line: linePos?.[0]?.line ?? 1,
+            column: linePos?.[0]?.col ?? 1,
+            message,
             code: "YAML_PARSE_ERROR"
           }
         ],
@@ -588,7 +596,7 @@ function createAgentsRouter(getAgent, context) {
       });
     }
     const enriched = (0, import_agent_management.enrichAgentConfig)(parsed, void 0);
-    const result = import_core.AgentConfigSchema.safeParse(enriched);
+    const result = import_agent_config.AgentConfigSchema.safeParse(enriched);
     if (!result.success) {
       const issues = (0, import_core.zodToIssues)(result.error);
       const errors = issues.map((issue) => ({
@@ -616,16 +624,16 @@ function createAgentsRouter(getAgent, context) {
       warnings
     });
   }).openapi(saveConfigRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
     const { yaml } = ctx.req.valid("json");
     let parsed;
     try {
       parsed = (0, import_yaml.parse)(yaml);
     } catch (parseError) {
+      const message = parseError instanceof Error ? parseError.message : String(parseError);
       throw new import_core2.DextoValidationError([
         {
           code: import_core2.AgentErrorCode.INVALID_CONFIG,
-          message: `Invalid YAML syntax: ${parseError.message}`,
+          message: `Invalid YAML syntax: ${message}`,
           scope: import_core2.ErrorScope.AGENT,
           type: import_core2.ErrorType.USER,
           severity: "error"
@@ -643,9 +651,9 @@ function createAgentsRouter(getAgent, context) {
         }
       ]);
     }
-    const agentPath = agent.getAgentFilePath();
+    const agentPath = await resolveAgentConfigPath(ctx);
     const enriched = (0, import_agent_management.enrichAgentConfig)(parsed, agentPath);
-    const validationResult = import_core.AgentConfigSchema.safeParse(enriched);
+    const validationResult = import_agent_config.AgentConfigSchema.safeParse(enriched);
     if (!validationResult.success) {
       throw new import_core2.DextoValidationError(
         validationResult.error.errors.map((err) => ({
@@ -661,16 +669,7 @@ function createAgentsRouter(getAgent, context) {
     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 switchAgentByPath(agentPath);
       await import_fs.promises.unlink(backupPath).catch(() => {
       });
       import_core.logger.info(`Agent configuration saved and applied: ${agentPath}`);
@@ -678,9 +677,9 @@ function createAgentsRouter(getAgent, context) {
         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)"
+        restarted: true,
+        changesApplied: ["restart"],
+        message: "Configuration saved and applied successfully (agent restarted)"
       });
     } catch (error) {
       await import_fs.promises.copyFile(backupPath, agentPath).catch(() => {
@@ -690,7 +689,19 @@ function createAgentsRouter(getAgent, context) {
   }).openapi(exportConfigRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
-    const config = agent.getEffectiveConfig(sessionId);
+    const agentPath = await resolveAgentConfigPath(ctx);
+    const fileConfig = await (0, import_agent_management.reloadAgentConfigFromFile)(agentPath);
+    const enrichedConfig = (0, import_agent_management.enrichAgentConfig)(fileConfig, agentPath);
+    const validatedConfig = import_agent_config.AgentConfigSchema.parse(enrichedConfig);
+    const effectiveSettings = agent.getEffectiveConfig(sessionId);
+    const config = {
+      ...validatedConfig,
+      ...effectiveSettings,
+      llm: {
+        ...validatedConfig.llm,
+        ...effectiveSettings.llm
+      }
+    };
     const maskedConfig = {
       ...config,
       llm: {

package/dist/hono/routes/agents.d.ts

@@ -1,6 +1,7 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
 import type { Context } from 'hono';
+import type { GetAgentConfigPathFn } from '../index.js';
 type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
 export type AgentsRouterContext = {
     switchAgentById: (agentId: string) => Promise<{
@@ -18,7 +19,7 @@ export type AgentsRouterContext = {
     ensureAgentAvailable: () => void;
     getActiveAgentId: () => string | undefined;
 };
-export declare function createAgentsRouter(getAgent: GetAgentFn, context: AgentsRouterContext): OpenAPIHono<import("hono").Env, {
+export declare function createAgentsRouter(getAgent: GetAgentFn, context: AgentsRouterContext, getAgentConfigPath: GetAgentConfigPathFn): OpenAPIHono<import("hono").Env, {
     "/agents": {
         $get: {
             input: {};

package/dist/hono/routes/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAsB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA8MrE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/E,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC9C,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6sBpF"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA8MrE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/E,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC9C,CAAC;AAEF,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,mBAAmB,EAC5B,kBAAkB,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6tB3C"}

package/dist/hono/routes/agents.js

@@ -1,10 +1,6 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import {
-  logger,
-  safeStringify,
-  AgentConfigSchema,
-  zodToIssues
-} from "@dexto/core";
+import { AgentConfigSchema } from "@dexto/agent-config";
+import { AgentError, logger, safeStringify, zodToIssues } from "@dexto/core";
 import {
   getPrimaryApiKeyEnvVar,
   saveProviderApiKey,
@@ -120,9 +116,16 @@ const SaveConfigResponseSchema = z.object({
   changesApplied: z.array(z.string()).describe("List of changes that were applied"),
   message: z.string().describe("Success message")
 }).strict().describe("Configuration save result");
-function createAgentsRouter(getAgent, context) {
+function createAgentsRouter(getAgent, context, getAgentConfigPath) {
   const app = new OpenAPIHono();
   const { switchAgentById, switchAgentByPath, resolveAgentInfo, getActiveAgentId } = context;
+  const resolveAgentConfigPath = async (ctx) => {
+    const configPath = await getAgentConfigPath(ctx);
+    if (!configPath) {
+      throw AgentError.noConfigPath();
+    }
+    return configPath;
+  };
   const listRoute = createRoute({
     method: "get",
     path: "/agents",
@@ -507,8 +510,7 @@ function createAgentsRouter(getAgent, context) {
       throw installError;
     }
   }).openapi(getPathRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
-    const agentPath = agent.getAgentFilePath();
+    const agentPath = await resolveAgentConfigPath(ctx);
     const relativePath = path.basename(agentPath);
     const ext = path.extname(agentPath);
     const name = path.basename(agentPath, ext);
@@ -519,8 +521,7 @@ function createAgentsRouter(getAgent, context) {
       isDefault: name === "coding-agent"
     });
   }).openapi(getConfigRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
-    const agentPath = agent.getAgentFilePath();
+    const agentPath = await resolveAgentConfigPath(ctx);
     const yamlContent = await fs.readFile(agentPath, "utf-8");
     const stats = await fs.stat(agentPath);
     return ctx.json({
@@ -539,13 +540,15 @@ function createAgentsRouter(getAgent, context) {
     try {
       parsed = yamlParse(yaml);
     } catch (parseError) {
+      const message = parseError instanceof Error ? parseError.message : String(parseError);
+      const linePos = typeof parseError === "object" && parseError !== null && "linePos" in parseError ? parseError.linePos : void 0;
       return ctx.json({
         valid: false,
         errors: [
           {
-            line: parseError.linePos?.[0]?.line || 1,
-            column: parseError.linePos?.[0]?.col || 1,
-            message: parseError.message,
+            line: linePos?.[0]?.line ?? 1,
+            column: linePos?.[0]?.col ?? 1,
+            message,
             code: "YAML_PARSE_ERROR"
           }
         ],
@@ -595,16 +598,16 @@ function createAgentsRouter(getAgent, context) {
       warnings
     });
   }).openapi(saveConfigRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
     const { yaml } = ctx.req.valid("json");
     let parsed;
     try {
       parsed = yamlParse(yaml);
     } catch (parseError) {
+      const message = parseError instanceof Error ? parseError.message : String(parseError);
       throw new DextoValidationError([
         {
           code: AgentErrorCode.INVALID_CONFIG,
-          message: `Invalid YAML syntax: ${parseError.message}`,
+          message: `Invalid YAML syntax: ${message}`,
           scope: ErrorScope.AGENT,
           type: ErrorType.USER,
           severity: "error"
@@ -622,7 +625,7 @@ function createAgentsRouter(getAgent, context) {
         }
       ]);
     }
-    const agentPath = agent.getAgentFilePath();
+    const agentPath = await resolveAgentConfigPath(ctx);
     const enriched = enrichAgentConfig(parsed, agentPath);
     const validationResult = AgentConfigSchema.safeParse(enriched);
     if (!validationResult.success) {
@@ -640,16 +643,7 @@ function createAgentsRouter(getAgent, context) {
     await fs.copyFile(agentPath, backupPath);
     try {
       await fs.writeFile(agentPath, yaml, "utf-8");
-      const newConfig = await reloadAgentConfigFromFile(agentPath);
-      const enrichedConfig = enrichAgentConfig(newConfig, agentPath);
-      const reloadResult = await agent.reload(enrichedConfig);
-      if (reloadResult.restarted) {
-        logger.info(
-          `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
-        );
-      } else if (reloadResult.changesApplied.length === 0) {
-        logger.info("Configuration saved (no changes detected)");
-      }
+      await switchAgentByPath(agentPath);
       await fs.unlink(backupPath).catch(() => {
       });
       logger.info(`Agent configuration saved and applied: ${agentPath}`);
@@ -657,9 +651,9 @@ function createAgentsRouter(getAgent, context) {
         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)"
+        restarted: true,
+        changesApplied: ["restart"],
+        message: "Configuration saved and applied successfully (agent restarted)"
       });
     } catch (error) {
       await fs.copyFile(backupPath, agentPath).catch(() => {
@@ -669,7 +663,19 @@ function createAgentsRouter(getAgent, context) {
   }).openapi(exportConfigRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
-    const config = agent.getEffectiveConfig(sessionId);
+    const agentPath = await resolveAgentConfigPath(ctx);
+    const fileConfig = await reloadAgentConfigFromFile(agentPath);
+    const enrichedConfig = enrichAgentConfig(fileConfig, agentPath);
+    const validatedConfig = AgentConfigSchema.parse(enrichedConfig);
+    const effectiveSettings = agent.getEffectiveConfig(sessionId);
+    const config = {
+      ...validatedConfig,
+      ...effectiveSettings,
+      llm: {
+        ...validatedConfig.llm,
+        ...effectiveSettings.llm
+      }
+    };
     const maskedConfig = {
       ...config,
       llm: {

package/dist/hono/routes/discovery.cjs

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 discovery_exports = {};
 __export(discovery_exports, {
@@ -22,44 +32,111 @@ __export(discovery_exports, {
 });
 module.exports = __toCommonJS(discovery_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
-var import_core = require("@dexto/core");
-const DiscoveredProviderSchema = import_zod_openapi.z.object({
-  type: import_zod_openapi.z.string().describe("Provider type identifier"),
-  category: import_zod_openapi.z.enum(["blob", "database", "compaction", "customTools"]).describe("Provider category"),
+var import_agent_config = require("@dexto/agent-config");
+var import_agent_management = require("@dexto/agent-management");
+var import_image_local = __toESM(require("@dexto/image-local"), 1);
+const DiscoveredFactorySchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.string().describe("Factory type identifier"),
+  category: import_zod_openapi.z.enum(["blob", "database", "compaction", "tools"]).describe("Factory category"),
   metadata: import_zod_openapi.z.object({
     displayName: import_zod_openapi.z.string().optional().describe("Human-readable display name"),
-    description: import_zod_openapi.z.string().optional().describe("Provider description")
-  }).passthrough().optional().describe("Optional metadata about the provider")
-}).describe("Information about a registered provider");
-const InternalToolSchema = import_zod_openapi.z.object({
-  name: import_zod_openapi.z.string().describe('Internal tool name identifier (e.g., "search_history", "ask_user")'),
+    description: import_zod_openapi.z.string().optional().describe("Factory description")
+  }).passthrough().optional().describe("Optional metadata about the factory")
+}).describe("Information about a registered factory");
+const ToolSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe('Built-in tool name identifier (e.g., "search_history", "ask_user")'),
   description: import_zod_openapi.z.string().describe("Human-readable description of what the tool does")
-}).describe("Information about an internal tool");
+}).describe("Information about a built-in tool");
 const DiscoveryResponseSchema = import_zod_openapi.z.object({
-  blob: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Blob storage providers"),
-  database: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Database providers"),
-  compaction: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Compaction strategy providers"),
-  customTools: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Custom tool providers"),
-  internalTools: import_zod_openapi.z.array(InternalToolSchema).describe("Internal tools available for configuration")
-}).describe("Discovery response with providers grouped by category");
-function createDiscoveryRouter() {
+  blob: import_zod_openapi.z.array(DiscoveredFactorySchema).describe("Blob storage factories"),
+  database: import_zod_openapi.z.array(DiscoveredFactorySchema).describe("Database factories"),
+  compaction: import_zod_openapi.z.array(DiscoveredFactorySchema).describe("Compaction strategy factories"),
+  toolFactories: import_zod_openapi.z.array(DiscoveredFactorySchema).describe("Tool factories"),
+  builtinTools: import_zod_openapi.z.array(ToolSchema).describe("Built-in tools available for configuration")
+}).describe("Discovery response with factories grouped by category");
+function toMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return void 0;
+  }
+  const record = metadata;
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      result[key] = value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+async function resolveImage(options) {
+  const { ctx, getAgentConfigPath } = options;
+  const configPath = await getAgentConfigPath(ctx);
+  if (!configPath) {
+    return import_image_local.default;
+  }
+  const rawConfig = await (0, import_agent_management.loadAgentConfig)(configPath);
+  const imageName = (typeof rawConfig.image === "string" && rawConfig.image.length > 0 ? rawConfig.image : void 0) ?? process.env.DEXTO_IMAGE ?? "@dexto/image-local";
+  if (imageName === "@dexto/image-local") {
+    return import_image_local.default;
+  }
+  try {
+    return await (0, import_agent_config.loadImage)(imageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to load image module '${imageName}'. Ensure it is installed and that the host called setImageImporter(). Original error: ${message}`
+    );
+  }
+}
+async function listDiscoveryFactories(options) {
+  const image = await resolveImage(options);
+  const blob = Object.entries(image.storage.blob).map(([type, factory]) => ({
+    type,
+    category: "blob",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const database = Object.entries(image.storage.database).map(([type, factory]) => ({
+    type,
+    category: "database",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const compaction = Object.entries(image.compaction).map(([type, factory]) => ({
+    type,
+    category: "compaction",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const toolFactories = Object.entries(image.tools);
+  const builtinFactory = toolFactories.find(([type]) => type === "builtin-tools")?.[1];
+  const builtinTools = builtinFactory ? builtinFactory.create(builtinFactory.configSchema.parse({ type: "builtin-tools" })).map((tool) => ({
+    name: tool.id,
+    description: tool.description
+  })) : [];
+  const toolFactoriesList = toolFactories.filter(([type]) => type !== "builtin-tools").map(([type, factory]) => ({
+    type,
+    category: "tools",
+    metadata: toMetadata(factory.metadata)
+  }));
+  return { blob, database, compaction, toolFactories: toolFactoriesList, builtinTools };
+}
+function createDiscoveryRouter(getAgentConfigPath) {
   const app = new import_zod_openapi.OpenAPIHono();
   const discoveryRoute = (0, import_zod_openapi.createRoute)({
     method: "get",
     path: "/discovery",
-    summary: "Discover Available Providers and Tools",
-    description: "Returns all registered providers (blob storage, database, compaction, custom tools) and available internal tools. Useful for building UIs that need to display configurable options.",
+    summary: "Discover Available Factories and Tools",
+    description: "Returns all available factories (storage, compaction, tools) for the currently active image.",
     tags: ["discovery"],
     responses: {
       200: {
-        description: "Available providers grouped by category",
+        description: "Available factories grouped by category",
         content: { "application/json": { schema: DiscoveryResponseSchema } }
       }
     }
   });
   return app.openapi(discoveryRoute, async (ctx) => {
-    const providers = (0, import_core.listAllProviders)();
-    return ctx.json(providers);
+    return ctx.json(await listDiscoveryFactories({ ctx, getAgentConfigPath }));
   });
 }
 // Annotate the CommonJS export names for ESM import in node: