@dexto/server 1.3.0 → 1.5.0

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

@@ -1,6 +1,8 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createPromptsRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/prompts": {
         $get: {
             input: {};
@@ -10,14 +12,14 @@ export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPI
                     source: "config" | "custom" | "mcp";
                     description?: string | undefined;
                     title?: string | undefined;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
                     arguments?: {
                         name: string;
                         description?: string | undefined;
                         required?: boolean | undefined;
                     }[] | undefined;
-                    metadata?: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | undefined;
                 }[];
             };
             outputFormat: "json";
@@ -51,14 +53,14 @@ export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPI
                     source: "config" | "custom" | "mcp";
                     description?: string | undefined;
                     title?: string | undefined;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
                     arguments?: {
                         name: string;
                         description?: string | undefined;
                         required?: boolean | undefined;
                     }[] | undefined;
-                    metadata?: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | undefined;
                 };
             };
             outputFormat: "json";
@@ -147,4 +149,5 @@ export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPI
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=prompts.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAqE9C,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6N7D"}
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAmErE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6NvD"}

package/dist/hono/routes/prompts.js

@@ -139,12 +139,12 @@ function createPromptsRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const prompts = await agent.listPrompts();
     const list = Object.values(prompts);
     return ctx.json({ prompts: list });
   }).openapi(createCustomRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const payload = ctx.req.valid("json");
     const promptArguments = payload.arguments?.map((arg) => ({
       name: arg.name,
@@ -168,18 +168,18 @@ function createPromptsRouter(getAgent) {
     const prompt = await agent.createCustomPrompt(createPayload);
     return ctx.json({ prompt }, 201);
   }).openapi(deleteCustomRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
     await agent.deleteCustomPrompt(name);
     return ctx.body(null, 204);
   }).openapi(getPromptRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
     const definition = await agent.getPromptDefinition(name);
     if (!definition) throw PromptError.notFound(name);
     return ctx.json({ definition });
   }).openapi(resolvePromptRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
     const { context, args: argsString } = ctx.req.valid("query");
     let parsedArgs;

package/dist/hono/routes/queue.cjs

@@ -0,0 +1,202 @@
+"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 queue_exports = {};
+__export(queue_exports, {
+  createQueueRouter: () => createQueueRouter
+});
+module.exports = __toCommonJS(queue_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_responses = require("../schemas/responses.js");
+const QueuedMessageSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique identifier for the queued message"),
+  content: import_zod_openapi.z.array(import_responses.ContentPartSchema).describe("Message content parts"),
+  queuedAt: import_zod_openapi.z.number().describe("Unix timestamp when message was queued"),
+  metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional metadata")
+}).strict().describe("A message waiting in the queue");
+const TextPartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("text").describe("Content type identifier"),
+  text: import_zod_openapi.z.string().describe("Text content")
+}).describe("Text content part");
+const ImagePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("image").describe("Content type identifier"),
+  image: import_zod_openapi.z.string().describe("Base64-encoded image data or URL"),
+  mimeType: import_zod_openapi.z.string().optional().describe("MIME type (e.g., image/png)")
+}).describe("Image content part");
+const FilePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("file").describe("Content type identifier"),
+  data: import_zod_openapi.z.string().describe("Base64-encoded file data or URL"),
+  mimeType: import_zod_openapi.z.string().describe("MIME type (e.g., application/pdf)"),
+  filename: import_zod_openapi.z.string().optional().describe("Optional filename")
+}).describe("File content part");
+const QueueContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
+const QueueMessageBodySchema = import_zod_openapi.z.object({
+  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal")
+}).describe("Request body for queueing a message");
+function createQueueRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const getQueueRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/queue/{sessionId}",
+    summary: "Get queued messages",
+    description: "Returns all messages waiting in the queue for a session",
+    tags: ["queue"],
+    request: {
+      params: import_zod_openapi.z.object({
+        sessionId: import_zod_openapi.z.string().min(1).describe("Session ID")
+      })
+    },
+    responses: {
+      200: {
+        description: "List of queued messages",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              messages: import_zod_openapi.z.array(QueuedMessageSchema).describe("Queued messages"),
+              count: import_zod_openapi.z.number().describe("Number of messages in queue")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session not found" }
+    }
+  });
+  const queueMessageRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/queue/{sessionId}",
+    summary: "Queue a message",
+    description: "Adds a message to the queue for processing when the session is no longer busy",
+    tags: ["queue"],
+    request: {
+      params: import_zod_openapi.z.object({
+        sessionId: import_zod_openapi.z.string().min(1).describe("Session ID")
+      }),
+      body: {
+        content: { "application/json": { schema: QueueMessageBodySchema } }
+      }
+    },
+    responses: {
+      201: {
+        description: "Message queued successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              queued: import_zod_openapi.z.literal(true).describe("Indicates message was queued"),
+              id: import_zod_openapi.z.string().describe("ID of the queued message"),
+              position: import_zod_openapi.z.number().describe("Position in the queue (1-based)")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session not found" }
+    }
+  });
+  const removeQueuedMessageRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/queue/{sessionId}/{messageId}",
+    summary: "Remove queued message",
+    description: "Removes a specific message from the queue",
+    tags: ["queue"],
+    request: {
+      params: import_zod_openapi.z.object({
+        sessionId: import_zod_openapi.z.string().min(1).describe("Session ID"),
+        messageId: import_zod_openapi.z.string().min(1).describe("ID of the queued message to remove")
+      })
+    },
+    responses: {
+      200: {
+        description: "Message removed successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              removed: import_zod_openapi.z.literal(true).describe("Indicates message was removed"),
+              id: import_zod_openapi.z.string().describe("ID of the removed message")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session or message not found" }
+    }
+  });
+  const clearQueueRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/queue/{sessionId}",
+    summary: "Clear message queue",
+    description: "Removes all messages from the queue for a session",
+    tags: ["queue"],
+    request: {
+      params: import_zod_openapi.z.object({
+        sessionId: import_zod_openapi.z.string().min(1).describe("Session ID")
+      })
+    },
+    responses: {
+      200: {
+        description: "Queue cleared successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              cleared: import_zod_openapi.z.literal(true).describe("Indicates queue was cleared"),
+              count: import_zod_openapi.z.number().describe("Number of messages that were removed")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session not found" }
+    }
+  });
+  return app.openapi(getQueueRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    const messages = await agent.getQueuedMessages(sessionId);
+    return ctx.json({
+      messages,
+      count: messages.length
+    });
+  }).openapi(queueMessageRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    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 });
+    return ctx.json(
+      {
+        queued: result.queued,
+        id: result.id,
+        position: result.position
+      },
+      201
+    );
+  }).openapi(removeQueuedMessageRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId, messageId } = ctx.req.valid("param");
+    const removed = await agent.removeQueuedMessage(sessionId, messageId);
+    if (!removed) {
+      return ctx.json({ error: "Message not found in queue" }, 404);
+    }
+    return ctx.json({ removed: true, id: messageId });
+  }).openapi(clearQueueRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    const count = await agent.clearMessageQueue(sessionId);
+    return ctx.json({ cleared: true, count });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createQueueRouter
+});

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

@@ -0,0 +1,174 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+    "/queue/:sessionId": {
+        $get: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                messages: {
+                    content: ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
+                        image: string;
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
+                        mimeType: string;
+                        data: string;
+                        filename?: string | undefined;
+                    } | {
+                        type: "ui-resource";
+                        mimeType: string;
+                        uri: string;
+                        content?: string | undefined;
+                        blob?: string | undefined;
+                        metadata?: {
+                            title?: string | undefined;
+                            preferredSize?: {
+                                width: number;
+                                height: number;
+                            } | undefined;
+                        } | undefined;
+                    })[];
+                    id: string;
+                    queuedAt: number;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
+                }[];
+                count: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/queue/:sessionId": {
+        $post: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            } & {
+                json: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
+                        image: string;
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
+                        mimeType: string;
+                        data: string;
+                        filename?: string | undefined;
+                    })[];
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            } & {
+                json: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
+                        image: string;
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
+                        mimeType: string;
+                        data: string;
+                        filename?: string | undefined;
+                    })[];
+                };
+            };
+            output: {
+                id: string;
+                queued: true;
+                position: number;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/queue/:sessionId/:messageId": {
+        $delete: {
+            input: {
+                param: {
+                    sessionId: string;
+                    messageId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    sessionId: string;
+                    messageId: string;
+                };
+            };
+            output: {
+                id: string;
+                removed: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/queue/:sessionId": {
+        $delete: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                count: number;
+                cleared: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export {};
+//# sourceMappingURL=queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAqDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoLrD"}

package/dist/hono/routes/queue.js

@@ -0,0 +1,178 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ContentPartSchema } from "../schemas/responses.js";
+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")
+}).strict().describe("A message waiting in the queue");
+const TextPartSchema = z.object({
+  type: z.literal("text").describe("Content type identifier"),
+  text: z.string().describe("Text content")
+}).describe("Text content part");
+const ImagePartSchema = z.object({
+  type: z.literal("image").describe("Content type identifier"),
+  image: z.string().describe("Base64-encoded image data or URL"),
+  mimeType: z.string().optional().describe("MIME type (e.g., image/png)")
+}).describe("Image content part");
+const FilePartSchema = z.object({
+  type: z.literal("file").describe("Content type identifier"),
+  data: z.string().describe("Base64-encoded file data or URL"),
+  mimeType: z.string().describe("MIME type (e.g., application/pdf)"),
+  filename: z.string().optional().describe("Optional filename")
+}).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")
+}).describe("Request body for queueing a message");
+function createQueueRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const getQueueRoute = createRoute({
+    method: "get",
+    path: "/queue/{sessionId}",
+    summary: "Get queued messages",
+    description: "Returns all messages waiting in the queue for a session",
+    tags: ["queue"],
+    request: {
+      params: z.object({
+        sessionId: z.string().min(1).describe("Session ID")
+      })
+    },
+    responses: {
+      200: {
+        description: "List of queued messages",
+        content: {
+          "application/json": {
+            schema: z.object({
+              messages: z.array(QueuedMessageSchema).describe("Queued messages"),
+              count: z.number().describe("Number of messages in queue")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session not found" }
+    }
+  });
+  const queueMessageRoute = createRoute({
+    method: "post",
+    path: "/queue/{sessionId}",
+    summary: "Queue a message",
+    description: "Adds a message to the queue for processing when the session is no longer busy",
+    tags: ["queue"],
+    request: {
+      params: z.object({
+        sessionId: z.string().min(1).describe("Session ID")
+      }),
+      body: {
+        content: { "application/json": { schema: QueueMessageBodySchema } }
+      }
+    },
+    responses: {
+      201: {
+        description: "Message queued successfully",
+        content: {
+          "application/json": {
+            schema: z.object({
+              queued: z.literal(true).describe("Indicates message was queued"),
+              id: z.string().describe("ID of the queued message"),
+              position: z.number().describe("Position in the queue (1-based)")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session not found" }
+    }
+  });
+  const removeQueuedMessageRoute = createRoute({
+    method: "delete",
+    path: "/queue/{sessionId}/{messageId}",
+    summary: "Remove queued message",
+    description: "Removes a specific message from the queue",
+    tags: ["queue"],
+    request: {
+      params: z.object({
+        sessionId: z.string().min(1).describe("Session ID"),
+        messageId: z.string().min(1).describe("ID of the queued message to remove")
+      })
+    },
+    responses: {
+      200: {
+        description: "Message removed successfully",
+        content: {
+          "application/json": {
+            schema: z.object({
+              removed: z.literal(true).describe("Indicates message was removed"),
+              id: z.string().describe("ID of the removed message")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session or message not found" }
+    }
+  });
+  const clearQueueRoute = createRoute({
+    method: "delete",
+    path: "/queue/{sessionId}",
+    summary: "Clear message queue",
+    description: "Removes all messages from the queue for a session",
+    tags: ["queue"],
+    request: {
+      params: z.object({
+        sessionId: z.string().min(1).describe("Session ID")
+      })
+    },
+    responses: {
+      200: {
+        description: "Queue cleared successfully",
+        content: {
+          "application/json": {
+            schema: z.object({
+              cleared: z.literal(true).describe("Indicates queue was cleared"),
+              count: z.number().describe("Number of messages that were removed")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Session not found" }
+    }
+  });
+  return app.openapi(getQueueRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    const messages = await agent.getQueuedMessages(sessionId);
+    return ctx.json({
+      messages,
+      count: messages.length
+    });
+  }).openapi(queueMessageRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    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 });
+    return ctx.json(
+      {
+        queued: result.queued,
+        id: result.id,
+        position: result.position
+      },
+      201
+    );
+  }).openapi(removeQueuedMessageRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId, messageId } = ctx.req.valid("param");
+    const removed = await agent.removeQueuedMessage(sessionId, messageId);
+    if (!removed) {
+      return ctx.json({ error: "Message not found in queue" }, 404);
+    }
+    return ctx.json({ removed: true, id: messageId });
+  }).openapi(clearQueueRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { sessionId } = ctx.req.valid("param");
+    const count = await agent.clearMessageQueue(sessionId);
+    return ctx.json({ cleared: true, count });
+  });
+}
+export {
+  createQueueRouter
+};

package/dist/hono/routes/resources.cjs

@@ -89,16 +89,16 @@ function createResourcesRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const resources = await agent.listResources();
     return ctx.json({ ok: true, resources: Object.values(resources) });
   }).openapi(getContentRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { resourceId } = ctx.req.valid("param");
     const content = await agent.readResource(resourceId);
     return ctx.json({ ok: true, content });
   }).openapi(headRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { resourceId } = ctx.req.valid("param");
     const exists = await agent.hasResource(resourceId);
     return ctx.body(null, exists ? 200 : 404);