@dexto/server 1.5.8 → 1.6.0

package/dist/hono/routes/mcp.js

@@ -1,12 +1,16 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
+import { AgentError, logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
 import { updateAgentConfigFile } from "@dexto/agent-management";
 import { ResourceSchema } from "../schemas/responses.js";
 const McpServerRequestSchema = z.object({
   name: z.string().min(1, "Server name is required").describe("A unique name for the server"),
   config: McpServerConfigSchema.describe("The server configuration object"),
   persistToAgent: z.boolean().optional().describe("If true, saves the server to agent configuration file")
-}).describe("Request body for adding or updating an MCP server");
+}).strict().describe("Request body for adding or updating an MCP server");
+const McpServerUpdateSchema = z.object({
+  config: McpServerConfigSchema.describe("The updated server configuration object"),
+  persistToAgent: z.boolean().optional().describe("If true, saves the server to agent configuration file")
+}).strict().describe("Request body for updating an MCP server");
 const ExecuteToolBodySchema = z.record(z.unknown()).describe(
   "Tool execution parameters as JSON object. The specific fields depend on the tool being executed and are defined by the tool's inputSchema."
 );
@@ -37,7 +41,8 @@ const ToolInfoSchema = z.object({
   id: z.string().describe("Tool identifier"),
   name: z.string().describe("Tool name"),
   description: z.string().describe("Tool description"),
-  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters"),
+  _meta: z.record(z.unknown()).optional().describe("Optional tool metadata (e.g., MCP Apps UI resource info)")
 }).strict().describe("Tool information");
 const ToolsListResponseSchema = z.object({
   tools: z.array(ToolInfoSchema).describe("Array of available tools")
@@ -55,6 +60,10 @@ const ToolExecutionResponseSchema = z.object({
   data: z.any().optional().describe("Tool execution result data"),
   error: z.string().optional().describe("Error message if execution failed")
 }).strict().describe("Tool execution response");
+const ServerConfigResponseSchema = z.object({
+  name: z.string().describe("Server name"),
+  config: McpServerConfigSchema.describe("Server configuration")
+}).strict().describe("MCP server configuration response");
 const ResourcesListResponseSchema = z.object({
   success: z.boolean().describe("Success indicator"),
   resources: z.array(ResourceSchema).describe("Array of available resources")
@@ -66,7 +75,7 @@ const ResourceContentResponseSchema = z.object({
   success: z.boolean().describe("Success indicator"),
   data: ResourceContentSchema.describe("Resource content")
 }).strict().describe("Resource content response");
-function createMcpRouter(getAgent) {
+function createMcpRouter(getAgent, getAgentConfigPath) {
   const app = new OpenAPIHono();
   const addServerRoute = createRoute({
     method: "post",
@@ -95,6 +104,41 @@ function createMcpRouter(getAgent) {
       }
     }
   });
+  const getServerConfigRoute = createRoute({
+    method: "get",
+    path: "/mcp/servers/{serverId}/config",
+    summary: "Get MCP Server Config",
+    description: "Retrieves the configuration for a specific MCP server",
+    tags: ["mcp"],
+    request: {
+      params: z.object({ serverId: z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Server configuration",
+        content: { "application/json": { schema: ServerConfigResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const updateServerRoute = createRoute({
+    method: "put",
+    path: "/mcp/servers/{serverId}",
+    summary: "Update MCP Server",
+    description: "Updates configuration for an existing MCP server",
+    tags: ["mcp"],
+    request: {
+      params: z.object({ serverId: z.string().describe("The ID of the MCP server") }),
+      body: { content: { "application/json": { schema: McpServerUpdateSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Server updated",
+        content: { "application/json": { schema: ServerStatusResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
   const toolsRoute = createRoute({
     method: "get",
     path: "/mcp/servers/{serverId}/tools",
@@ -214,6 +258,10 @@ function createMcpRouter(getAgent) {
     );
     if (persistToAgent === true) {
       try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw AgentError.noConfigPath();
+        }
         const currentConfig = agent.getEffectiveConfig();
         const updates = {
           mcpServers: {
@@ -221,16 +269,7 @@ function createMcpRouter(getAgent) {
             [name]: config
           }
         };
-        const newConfig = await updateAgentConfigFile(
-          agent.getAgentFilePath(),
-          updates
-        );
-        const reloadResult = await agent.reload(newConfig);
-        if (reloadResult.restarted) {
-          logger.info(
-            `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
-          );
-        }
+        await updateAgentConfigFile(agentPath, updates);
         logger.info(`Saved server '${name}' to agent configuration file`);
       } catch (saveError) {
         const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
@@ -256,6 +295,48 @@ function createMcpRouter(getAgent) {
       servers.push({ id: name, name, status: "error" });
     }
     return ctx.json({ servers });
+  }).openapi(getServerConfigRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { serverId } = ctx.req.valid("param");
+    const config = agent.getMcpServerConfig(serverId);
+    if (!config) {
+      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+    }
+    return ctx.json({ name: serverId, config }, 200);
+  }).openapi(updateServerRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { serverId } = ctx.req.valid("param");
+    const { config, persistToAgent } = ctx.req.valid("json");
+    const existingConfig = agent.getMcpServerConfig(serverId);
+    if (!existingConfig) {
+      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+    }
+    await agent.updateMcpServer(serverId, config);
+    if (persistToAgent === true) {
+      try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw AgentError.noConfigPath();
+        }
+        const currentConfig = agent.getEffectiveConfig();
+        const updates = {
+          mcpServers: {
+            ...currentConfig.mcpServers || {},
+            [serverId]: config
+          }
+        };
+        await updateAgentConfigFile(agentPath, updates);
+        logger.info(`Saved server '${serverId}' to agent configuration file`);
+      } catch (saveError) {
+        const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
+        logger.warn(
+          `Failed to persist MCP server '${serverId}' update: ${errorMessage}`,
+          { error: saveError }
+        );
+      }
+    }
+    const status = config.enabled === false ? "registered" : "connected";
+    return ctx.json({ status, name: serverId }, 200);
   }).openapi(toolsRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
@@ -268,7 +349,8 @@ function createMcpRouter(getAgent) {
       id: toolName,
       name: toolName,
       description: toolDef.description || "",
-      inputSchema: toolDef.parameters
+      inputSchema: toolDef.parameters,
+      _meta: toolDef._meta
     }));
     return ctx.json({ tools });
   }).openapi(deleteServerRoute, async (ctx) => {

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

@@ -19,8 +19,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 ok: true;
                 memory: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -49,8 +49,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
             output: {
                 memories: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -77,8 +77,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 ok: true;
                 memory: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -113,8 +113,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 ok: true;
                 memory: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;

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

@@ -15,7 +15,7 @@ export declare function createModelsRouter(): OpenAPIHono<import("hono").Env, {
                     displayName: string;
                     filePath: string;
                     sizeBytes: number;
-                    source?: "manual" | "huggingface" | undefined;
+                    source?: "huggingface" | "manual" | undefined;
                     contextLength?: number | undefined;
                 }[];
             };

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

@@ -5,7 +5,6 @@ export declare function createResourcesRouter(getAgent: GetAgentFn): OpenAPIHono
         $get: {
             input: {};
             output: {
-                ok: true;
                 resources: {
                     uri: string;
                     source: "mcp" | "internal";
@@ -19,6 +18,7 @@ export declare function createResourcesRouter(getAgent: GetAgentFn): OpenAPIHono
                     size?: number | undefined;
                     lastModified?: string | undefined;
                 }[];
+                ok: true;
             };
             outputFormat: "json";
             status: 200;

package/dist/hono/routes/schedules.cjs

@@ -0,0 +1,455 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schedules_exports = {};
+__export(schedules_exports, {
+  createSchedulesRouter: () => createSchedulesRouter
+});
+module.exports = __toCommonJS(schedules_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_responses = require("../schemas/responses.js");
+var import_tools_scheduler = require("@dexto/tools-scheduler");
+var import_core = require("@dexto/core");
+const CreateScheduleSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().min(1).describe("Schedule name"),
+  instruction: import_zod_openapi.z.string().min(1).describe("Instruction to run on schedule"),
+  cronExpression: import_zod_openapi.z.string().min(1).describe("Cron expression"),
+  timezone: import_zod_openapi.z.string().optional().describe("Timezone for schedule"),
+  enabled: import_zod_openapi.z.boolean().optional().describe("Whether the schedule is enabled"),
+  workspacePath: import_zod_openapi.z.string().optional().nullable().describe("Optional workspace path for scheduled runs")
+}).strict().describe("Request body for creating a schedule");
+const UpdateScheduleSchema = CreateScheduleSchema.partial().strict().describe("Request body for updating a schedule");
+const isScheduleNotFoundError = (error) => error instanceof import_core.DextoRuntimeError && error.type === import_core.ErrorType.NOT_FOUND && error.code === import_tools_scheduler.SchedulerErrorCode.SCHEDULE_NOT_FOUND;
+const logSchedulerError = (agent, message, error) => {
+  if (!agent?.logger) {
+    return;
+  }
+  agent.logger.error(message, {
+    error: error instanceof Error ? error.message : String(error ?? "Unknown error"),
+    stack: error instanceof Error ? error.stack : void 0,
+    code: error instanceof import_core.DextoRuntimeError ? error.code : void 0
+  });
+};
+const toErrorResponse = (message, code) => ({
+  ok: false,
+  error: {
+    message,
+    ...code ? { code } : {}
+  }
+});
+function createSchedulesRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const resolveScheduler = async (ctx) => {
+    const agent = await getAgent(ctx);
+    const agentId = agent.config?.agentId ?? "default";
+    let scheduler = (0, import_tools_scheduler.getSchedulerManager)(agentId) ?? null;
+    if (!scheduler) {
+      scheduler = await (0, import_tools_scheduler.ensureSchedulerManagerForAgent)(agent);
+    }
+    return { scheduler, agent };
+  };
+  const listRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/schedules",
+    summary: "List Schedules",
+    description: "Retrieves all automation schedules",
+    tags: ["schedules"],
+    responses: {
+      200: {
+        description: "List of schedules",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              schedules: import_zod_openapi.z.array(import_responses.ScheduleSchema).describe("Schedule list")
+            }).strict()
+          }
+        }
+      },
+      500: {
+        description: "Failed to list schedules",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const createRouteDef = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/schedules",
+    summary: "Create Schedule",
+    description: "Creates a new automation schedule",
+    tags: ["schedules"],
+    request: { body: { content: { "application/json": { schema: CreateScheduleSchema } } } },
+    responses: {
+      201: {
+        description: "Created schedule",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({ schedule: import_responses.ScheduleSchema }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Validation error",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      429: {
+        description: "Schedule limit reached",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to create schedule",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const updateRoute = (0, import_zod_openapi.createRoute)({
+    method: "patch",
+    path: "/schedules/{scheduleId}",
+    summary: "Update Schedule",
+    description: "Updates an existing schedule",
+    tags: ["schedules"],
+    request: {
+      params: import_zod_openapi.z.object({
+        scheduleId: import_zod_openapi.z.string().min(1).describe("Schedule ID")
+      }).strict().describe("Schedule identifier params"),
+      body: { content: { "application/json": { schema: UpdateScheduleSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Updated schedule",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({ schedule: import_responses.ScheduleSchema }).strict()
+          }
+        }
+      },
+      400: {
+        description: "Validation error",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      404: {
+        description: "Schedule not found",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to update schedule",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const deleteRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/schedules/{scheduleId}",
+    summary: "Delete Schedule",
+    description: "Deletes an automation schedule",
+    tags: ["schedules"],
+    request: {
+      params: import_zod_openapi.z.object({
+        scheduleId: import_zod_openapi.z.string().min(1).describe("Schedule ID")
+      }).strict().describe("Schedule identifier params")
+    },
+    responses: {
+      200: {
+        description: "Schedule deleted",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              deleted: import_zod_openapi.z.boolean().describe("Whether the schedule was deleted")
+            }).strict().describe("Delete schedule response")
+          }
+        }
+      },
+      404: {
+        description: "Schedule not found",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to delete schedule",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const triggerRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/schedules/{scheduleId}/trigger",
+    summary: "Trigger Schedule",
+    description: "Runs a schedule immediately and waits for execution to complete (bounded by executionTimeout, default 5 minutes). Clients should set timeouts accordingly.",
+    tags: ["schedules"],
+    request: {
+      params: import_zod_openapi.z.object({
+        scheduleId: import_zod_openapi.z.string().min(1).describe("Schedule ID")
+      }).strict().describe("Schedule identifier params")
+    },
+    responses: {
+      200: {
+        description: "Schedule triggered",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              scheduled: import_zod_openapi.z.boolean().describe(
+                "Whether the schedule was queued. Execution is omitted when false."
+              ),
+              execution: import_responses.ExecutionLogSchema.optional().describe(
+                "Execution log (present when scheduled is true)"
+              )
+            }).strict().describe("Trigger schedule response")
+          }
+        }
+      },
+      404: {
+        description: "Schedule not found",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      500: {
+        description: "Failed to trigger schedule",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      },
+      503: {
+        description: "Scheduler tools are not enabled",
+        content: {
+          "application/json": {
+            schema: import_responses.ErrorResponseSchema
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    try {
+      const schedules = await scheduler.listSchedules();
+      return ctx.json({ schedules }, 200);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+      logSchedulerError(agent, "Failed to list schedules", error);
+      if (error instanceof import_core.DextoRuntimeError) {
+        return ctx.json(toErrorResponse(message, String(error.code)), 500);
+      }
+      return ctx.json(toErrorResponse("Failed to list schedules"), 500);
+    }
+  }).openapi(createRouteDef, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const input = ctx.req.valid("json");
+    const createPayload = {
+      name: input.name,
+      instruction: input.instruction,
+      cronExpression: input.cronExpression,
+      ...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+      enabled: input.enabled ?? true,
+      ...input.workspacePath !== void 0 ? { workspacePath: input.workspacePath } : {},
+      sessionMode: "dedicated"
+    };
+    try {
+      const schedule = await scheduler.createSchedule(createPayload);
+      return ctx.json({ schedule }, 201);
+    } catch (error) {
+      if (error instanceof import_core.DextoRuntimeError && error.code === import_tools_scheduler.SchedulerErrorCode.SCHEDULE_INVALID_CRON) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      if (error instanceof import_core.DextoRuntimeError && error.code === import_tools_scheduler.SchedulerErrorCode.SCHEDULE_INVALID_INPUT) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      if (error instanceof import_core.DextoRuntimeError && error.code === import_tools_scheduler.SchedulerErrorCode.SCHEDULE_LIMIT_REACHED) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 429);
+      }
+      logSchedulerError(agent, "Failed to create schedule", error);
+      return ctx.json(toErrorResponse("Failed to create schedule"), 500);
+    }
+  }).openapi(updateRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const { scheduleId } = ctx.req.valid("param");
+    const input = ctx.req.valid("json");
+    const updatePayload = {
+      ...input.name !== void 0 ? { name: input.name } : {},
+      ...input.instruction !== void 0 ? { instruction: input.instruction } : {},
+      ...input.cronExpression !== void 0 ? { cronExpression: input.cronExpression } : {},
+      ...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+      ...input.enabled !== void 0 ? { enabled: input.enabled } : {},
+      ...input.workspacePath !== void 0 ? { workspacePath: input.workspacePath } : {}
+    };
+    try {
+      const schedule = await scheduler.updateSchedule(scheduleId, updatePayload);
+      return ctx.json({ schedule }, 200);
+    } catch (error) {
+      if (isScheduleNotFoundError(error)) {
+        return ctx.json(
+          toErrorResponse(
+            "Schedule not found",
+            import_tools_scheduler.SchedulerErrorCode.SCHEDULE_NOT_FOUND
+          ),
+          404
+        );
+      }
+      if (error instanceof import_core.DextoRuntimeError && error.code === import_tools_scheduler.SchedulerErrorCode.SCHEDULE_INVALID_CRON) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      if (error instanceof import_core.DextoRuntimeError && error.code === import_tools_scheduler.SchedulerErrorCode.SCHEDULE_INVALID_INPUT) {
+        return ctx.json(toErrorResponse(error.message, String(error.code)), 400);
+      }
+      logSchedulerError(agent, "Failed to update schedule", error);
+      return ctx.json(toErrorResponse("Failed to update schedule"), 500);
+    }
+  }).openapi(deleteRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const { scheduleId } = ctx.req.valid("param");
+    try {
+      await scheduler.deleteSchedule(scheduleId);
+      return ctx.json({ deleted: true }, 200);
+    } catch (error) {
+      if (isScheduleNotFoundError(error)) {
+        return ctx.json(
+          toErrorResponse(
+            "Schedule not found",
+            import_tools_scheduler.SchedulerErrorCode.SCHEDULE_NOT_FOUND
+          ),
+          404
+        );
+      }
+      logSchedulerError(agent, "Failed to delete schedule", error);
+      return ctx.json(toErrorResponse("Failed to delete schedule"), 500);
+    }
+  }).openapi(triggerRoute, async (ctx) => {
+    const { scheduler, agent } = await resolveScheduler(ctx);
+    if (!scheduler) {
+      return ctx.json(
+        toErrorResponse("Scheduler tools are not enabled for this agent."),
+        503
+      );
+    }
+    const { scheduleId } = ctx.req.valid("param");
+    try {
+      const execution = await scheduler.triggerScheduleNow(scheduleId);
+      return ctx.json({ scheduled: true, execution }, 200);
+    } catch (error) {
+      if (isScheduleNotFoundError(error)) {
+        return ctx.json(
+          toErrorResponse(
+            "Schedule not found",
+            import_tools_scheduler.SchedulerErrorCode.SCHEDULE_NOT_FOUND
+          ),
+          404
+        );
+      }
+      logSchedulerError(agent, "Failed to trigger schedule", error);
+      return ctx.json(toErrorResponse("Failed to trigger schedule"), 500);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSchedulesRouter
+});