@dexto/server 1.6.19 → 1.6.20

package/dist/hono/routes/messages.cjs

@@ -25,24 +25,8 @@ var import_zod_openapi = require("@hono/zod-openapi");
 var import_streaming = require("hono/streaming");
 var import_core = require("@dexto/core");
 var import_responses = require("../schemas/responses.js");
-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 ContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
 const MessageBodySchema = import_zod_openapi.z.object({
-  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(ContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  content: import_responses.RequestContentSchema,
   sessionId: import_zod_openapi.z.string().min(1, "Session ID is required").describe("The session to use for this message")
 }).describe("Request body for sending a message to the agent");
 const ResetBodySchema = import_zod_openapi.z.object({
@@ -73,7 +57,10 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
-      400: { description: "Validation error" }
+      400: {
+        description: "Validation error",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const messageSyncRoute = (0, import_zod_openapi.createRoute)({
@@ -109,7 +96,10 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
-      400: { description: "Validation error" }
+      400: {
+        description: "Validation error",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const resetRoute = (0, import_zod_openapi.createRoute)({
@@ -188,13 +178,17 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
-      400: { description: "Validation error" }
+      400: {
+        description: "Validation error",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = (0, import_responses.toContentInput)(rawContent);
     agent.logger.info(`Message for session: ${sessionId}`);
     agent.generate(content, sessionId).catch((error) => {
       agent.logger.error(
@@ -205,21 +199,25 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
   }).openapi(messageSyncRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = (0, import_responses.toContentInput)(rawContent);
     agent.logger.info(`Message for session: ${sessionId}`);
     const result = await agent.generate(content, sessionId);
-    return ctx.json({
-      response: result.content,
-      sessionId: result.sessionId,
-      tokenUsage: result.usage,
-      messageId: result.messageId,
-      usageScopeId: result.usageScopeId,
-      estimatedCost: result.estimatedCost,
-      pricingStatus: result.pricingStatus,
-      reasoning: result.reasoning,
-      model: result.model,
-      provider: result.provider
-    });
+    return ctx.json(
+      {
+        response: result.content,
+        sessionId: result.sessionId,
+        tokenUsage: result.usage,
+        messageId: result.messageId,
+        usageScopeId: result.usageScopeId,
+        estimatedCost: result.estimatedCost,
+        pricingStatus: result.pricingStatus,
+        reasoning: result.reasoning,
+        model: result.model,
+        provider: result.provider
+      },
+      200
+    );
   }).openapi(resetRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received request via POST /api/reset");
@@ -228,7 +226,8 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     return ctx.json({ status: "reset initiated", sessionId });
   }).openapi(messageStreamRoute, async (ctx) => {
     const agent = await getAgent(ctx);
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = (0, import_responses.toContentInput)(rawContent);
     const isBusy = await agent.isSessionBusy(sessionId);
     if (isBusy) {
       const queuedMessages = await agent.getQueuedMessages(sessionId);

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

@@ -22,9 +22,12 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: 400;
+            output: {
+                sessionId: string;
+                accepted: true;
+            };
+            outputFormat: "json";
+            status: 202;
         } | {
             input: {
                 json: {
@@ -44,12 +47,9 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     sessionId: string;
                 };
             };
-            output: {
-                sessionId: string;
-                accepted: true;
-            };
+            output: never;
             outputFormat: "json";
-            status: 202;
+            status: 400;
         };
     };
 } & {
@@ -73,8 +73,8 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 400;
         } | {
             input: {
@@ -177,8 +177,8 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 400;
         } | {
             input: {

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

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0D9C,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+V5C"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAGhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAQlF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAqB9C,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8W5C"}

package/dist/hono/routes/messages.js

@@ -1,25 +1,15 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { streamSSE } from "hono/streaming";
 import { LLM_PROVIDERS } from "@dexto/core";
-import { PricingStatusSchema, TokenUsageSchema } from "../schemas/responses.js";
-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 ContentPartSchema = z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
+import {
+  ApiErrorResponseSchema,
+  PricingStatusSchema,
+  RequestContentSchema,
+  TokenUsageSchema,
+  toContentInput
+} from "../schemas/responses.js";
 const MessageBodySchema = z.object({
-  content: z.union([z.string(), z.array(ContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  content: RequestContentSchema,
   sessionId: z.string().min(1, "Session ID is required").describe("The session to use for this message")
 }).describe("Request body for sending a message to the agent");
 const ResetBodySchema = z.object({
@@ -50,7 +40,10 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
-      400: { description: "Validation error" }
+      400: {
+        description: "Validation error",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const messageSyncRoute = createRoute({
@@ -86,7 +79,10 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
-      400: { description: "Validation error" }
+      400: {
+        description: "Validation error",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const resetRoute = createRoute({
@@ -165,13 +161,17 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
-      400: { description: "Validation error" }
+      400: {
+        description: "Validation error",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = toContentInput(rawContent);
     agent.logger.info(`Message for session: ${sessionId}`);
     agent.generate(content, sessionId).catch((error) => {
       agent.logger.error(
@@ -182,21 +182,25 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
   }).openapi(messageSyncRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = toContentInput(rawContent);
     agent.logger.info(`Message for session: ${sessionId}`);
     const result = await agent.generate(content, sessionId);
-    return ctx.json({
-      response: result.content,
-      sessionId: result.sessionId,
-      tokenUsage: result.usage,
-      messageId: result.messageId,
-      usageScopeId: result.usageScopeId,
-      estimatedCost: result.estimatedCost,
-      pricingStatus: result.pricingStatus,
-      reasoning: result.reasoning,
-      model: result.model,
-      provider: result.provider
-    });
+    return ctx.json(
+      {
+        response: result.content,
+        sessionId: result.sessionId,
+        tokenUsage: result.usage,
+        messageId: result.messageId,
+        usageScopeId: result.usageScopeId,
+        estimatedCost: result.estimatedCost,
+        pricingStatus: result.pricingStatus,
+        reasoning: result.reasoning,
+        model: result.model,
+        provider: result.provider
+      },
+      200
+    );
   }).openapi(resetRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received request via POST /api/reset");
@@ -205,7 +209,8 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     return ctx.json({ status: "reset initiated", sessionId });
   }).openapi(messageStreamRoute, async (ctx) => {
     const agent = await getAgent(ctx);
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = toContentInput(rawContent);
     const isBusy = await agent.isSessionBusy(sessionId);
     if (isBusy) {
       const queuedMessages = await agent.getQueuedMessages(sessionId);

package/dist/hono/routes/prompts.cjs

@@ -133,7 +133,10 @@ function createPromptsRouter(getAgent) {
           }
         }
       },
-      404: { description: "Prompt not found" }
+      404: {
+        description: "Prompt not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const resolvePromptRoute = (0, import_zod_openapi.createRoute)({
@@ -158,7 +161,10 @@ function createPromptsRouter(getAgent) {
           }
         }
       },
-      404: { description: "Prompt not found" }
+      404: {
+        description: "Prompt not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(listRoute, async (ctx) => {
@@ -200,7 +206,7 @@ function createPromptsRouter(getAgent) {
     const { name } = ctx.req.valid("param");
     const definition = await agent.getPromptDefinition(name);
     if (!definition) throw import_core.PromptError.notFound(name);
-    return ctx.json({ definition });
+    return ctx.json({ definition }, 200);
   }).openapi(resolvePromptRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
@@ -219,7 +225,7 @@ function createPromptsRouter(getAgent) {
     if (context !== void 0) options.context = context;
     if (parsedArgs !== void 0) options.args = parsedArgs;
     const result = await agent.resolvePrompt(name, options);
-    return ctx.json({ text: result.text, resources: result.resources });
+    return ctx.json({ text: result.text, resources: result.resources }, 200);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -88,8 +88,8 @@ export declare function createPromptsRouter(getAgent: GetAgentFn): OpenAPIHono<i
                     name: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -126,8 +126,8 @@ export declare function createPromptsRouter(getAgent: GetAgentFn): OpenAPIHono<i
                     args?: string | undefined;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {

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;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"}
+{"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;AAO9C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmOvD"}

package/dist/hono/routes/prompts.js

@@ -1,6 +1,10 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { PromptError } from "@dexto/core";
-import { PromptInfoSchema, PromptDefinitionSchema } from "../schemas/responses.js";
+import {
+  ApiErrorResponseSchema,
+  PromptDefinitionSchema,
+  PromptInfoSchema
+} from "../schemas/responses.js";
 const CustomPromptRequestSchema = z.object({
   name: z.string().min(1, "Prompt name is required").describe("Unique name for the custom prompt"),
   title: z.string().optional().describe("Display title for the prompt"),
@@ -110,7 +114,10 @@ function createPromptsRouter(getAgent) {
           }
         }
       },
-      404: { description: "Prompt not found" }
+      404: {
+        description: "Prompt not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const resolvePromptRoute = createRoute({
@@ -135,7 +142,10 @@ function createPromptsRouter(getAgent) {
           }
         }
       },
-      404: { description: "Prompt not found" }
+      404: {
+        description: "Prompt not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(listRoute, async (ctx) => {
@@ -177,7 +187,7 @@ function createPromptsRouter(getAgent) {
     const { name } = ctx.req.valid("param");
     const definition = await agent.getPromptDefinition(name);
     if (!definition) throw PromptError.notFound(name);
-    return ctx.json({ definition });
+    return ctx.json({ definition }, 200);
   }).openapi(resolvePromptRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
@@ -196,7 +206,7 @@ function createPromptsRouter(getAgent) {
     if (context !== void 0) options.context = context;
     if (parsedArgs !== void 0) options.args = parsedArgs;
     const result = await agent.resolvePrompt(name, options);
-    return ctx.json({ text: result.text, resources: result.resources });
+    return ctx.json({ text: result.text, resources: result.resources }, 200);
   });
 }
 export {

package/dist/hono/routes/queue.cjs

@@ -22,6 +22,7 @@ __export(queue_exports, {
 });
 module.exports = __toCommonJS(queue_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
 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"),
@@ -30,24 +31,8 @@ const QueuedMessageSchema = import_zod_openapi.z.object({
   metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional metadata"),
   kind: import_zod_openapi.z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).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"),
+  content: import_responses.RequestContentSchema,
   kind: import_zod_openapi.z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).describe("Request body for queueing a message");
 function createQueueRouter(getAgent) {
@@ -75,7 +60,10 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session not found" }
+      404: {
+        description: "Session not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const queueMessageRoute = (0, import_zod_openapi.createRoute)({
@@ -105,7 +93,10 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session not found" }
+      404: {
+        description: "Session not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const removeQueuedMessageRoute = (0, import_zod_openapi.createRoute)({
@@ -132,7 +123,10 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session or message not found" }
+      404: {
+        description: "Session or message not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const clearQueueRoute = (0, import_zod_openapi.createRoute)({
@@ -158,22 +152,35 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session not found" }
+      404: {
+        description: "Session not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   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
-    });
+    const responseMessages = messages.map((message) => ({
+      id: message.id,
+      content: message.content.map(import_responses.toApiContentPart),
+      queuedAt: message.queuedAt,
+      ...message.metadata !== void 0 ? { metadata: message.metadata } : {},
+      ...message.kind !== void 0 ? { kind: message.kind } : {}
+    }));
+    return ctx.json(
+      {
+        messages: responseMessages,
+        count: responseMessages.length
+      },
+      200
+    );
   }).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 content = (0, import_responses.toContentInput)(rawContent);
     const { kind } = ctx.req.valid("json");
     const result = await agent.queueMessage(sessionId, {
       content,
@@ -192,14 +199,20 @@ function createQueueRouter(getAgent) {
     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);
+      throw new import_core.DextoRuntimeError(
+        "queued_message_not_found",
+        "queue",
+        import_core.ErrorType.NOT_FOUND,
+        "Message not found in queue",
+        { sessionId, messageId }
+      );
     }
-    return ctx.json({ removed: true, id: messageId });
+    return ctx.json({ removed: true, id: messageId }, 200);
   }).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 });
+    return ctx.json({ cleared: true, count }, 200);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1,5 +1,5 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
+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, {
@@ -10,8 +10,8 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -85,8 +85,8 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                     kind?: "default" | "background" | undefined;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -129,8 +129,8 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                     messageId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -155,8 +155,8 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {

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

@@ -1 +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;AAuDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwLrD"}
+{"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,EAAgC,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAQ5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAsBrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6MrD"}