@dexto/server 1.5.7 → 1.6.0

package/dist/hono/routes/queue.js

@@ -4,7 +4,8 @@ const QueuedMessageSchema = z.object({
   id: z.string().describe("Unique identifier for the queued message"),
   content: z.array(ContentPartSchema).describe("Message content parts"),
   queuedAt: z.number().describe("Unix timestamp when message was queued"),
-  metadata: z.record(z.unknown()).optional().describe("Optional metadata")
+  metadata: z.record(z.unknown()).optional().describe("Optional metadata"),
+  kind: z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).strict().describe("A message waiting in the queue");
 const TextPartSchema = z.object({
   type: z.literal("text").describe("Content type identifier"),
@@ -23,7 +24,8 @@ const FilePartSchema = z.object({
 }).describe("File content part");
 const QueueContentPartSchema = z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
 const QueueMessageBodySchema = z.object({
-  content: z.union([z.string(), z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal")
+  content: z.union([z.string(), z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  kind: z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).describe("Request body for queueing a message");
 function createQueueRouter(getAgent) {
   const app = new OpenAPIHono();
@@ -149,7 +151,11 @@ function createQueueRouter(getAgent) {
     const { sessionId } = ctx.req.valid("param");
     const { content: rawContent } = ctx.req.valid("json");
     const content = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
-    const result = await agent.queueMessage(sessionId, { content });
+    const { kind } = ctx.req.valid("json");
+    const result = await agent.queueMessage(sessionId, {
+      content,
+      ...kind !== void 0 && { kind }
+    });
     return ctx.json(
       {
         queued: result.queued,

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
+});