@dexto/server 1.6.19 → 1.6.21

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,EAAe,KAAK,0BAA0B,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAEjG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAWlF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQyC,CAAC;AAEjE,QAAA,MAAM,eAAe;;;;;;EAOqC,CAAC;AAwD3D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB,CAAC;AAEH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBpB,CAAC;AAEH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBd,CAAC;AAEH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DtB,CAAC;AAEH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2K5C;AAED,KAAK,kBAAkB,GAAG,QAAQ,CAC9B,MAAM,EACN,UAAU,EACV;IAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;CAAE,EAC3C,0BAA0B,CAAC,OAAO,YAAY,CAAC,CAClD,CAAC;AAEF,KAAK,sBAAsB,GAAG,QAAQ,CAClC,MAAM,EACN,eAAe,EACf;IAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;CAAE,EAC3C,0BAA0B,CAAC,OAAO,gBAAgB,CAAC,CACtD,CAAC;AAEF,KAAK,gBAAgB,GAAG,QAAQ,CAC5B,MAAM,EACN,QAAQ,EACR;IAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;CAAE,EACzC,0BAA0B,CAAC,OAAO,UAAU,CAAC,CAChD,CAAC;AAEF,KAAK,wBAAwB,GAAG,QAAQ,CACpC,MAAM,EACN,iBAAiB,EACjB;IAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;CAAE,EAC3C,0BAA0B,CAAC,OAAO,kBAAkB,CAAC,CACxD,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC1B,kBAAkB,GAClB,sBAAsB,GACtB,gBAAgB,GAChB,wBAAwB,CAAC"}

package/dist/hono/routes/messages.js

@@ -1,177 +1,188 @@
 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,
+  BadRequestErrorResponse,
+  InternalErrorResponse,
+  NotFoundErrorResponse,
+  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({
   sessionId: z.string().min(1, "Session ID is required").describe("The ID of the session to reset")
 }).describe("Request body for resetting a conversation");
-function createMessagesRouter(getAgent, approvalCoordinator) {
-  const app = new OpenAPIHono();
-  const messageRoute = createRoute({
-    method: "post",
-    path: "/message",
-    summary: "Send Message (async)",
-    description: "Sends a message and returns immediately. The full response will be sent over SSE",
-    tags: ["messages"],
-    request: {
-      body: {
-        content: { "application/json": { schema: MessageBodySchema } }
+const MessageAcceptedResponseSchema = z.object({
+  accepted: z.literal(true).describe("Indicates request was accepted"),
+  sessionId: z.string().describe("Session ID used for this message")
+}).strict().describe("Asynchronous message acceptance response");
+const MessageSyncResponseSchema = z.object({
+  response: z.string().describe("Agent response text"),
+  sessionId: z.string().describe("Session ID used for this message"),
+  tokenUsage: TokenUsageSchema.optional().describe("Token usage statistics"),
+  messageId: z.string().uuid().optional().describe("Assistant message ID for this response"),
+  usageScopeId: z.string().optional().describe("Optional usage scope identifier for runtime-scoped metering"),
+  estimatedCost: z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
+  pricingStatus: PricingStatusSchema.optional().describe(
+    "Whether pricing was resolved for this response"
+  ),
+  reasoning: z.string().optional().describe("Extended thinking content from reasoning models"),
+  model: z.string().optional().describe("Model used for this response"),
+  provider: z.enum(LLM_PROVIDERS).optional().describe("LLM provider")
+}).strict().describe("Synchronous message response");
+const ResetResponseSchema = z.object({
+  status: z.string().describe("Status message indicating reset was initiated"),
+  sessionId: z.string().describe("Session ID that was reset")
+}).strict().describe("Session reset response");
+const MessageStreamBusyResponseSchema = z.object({
+  busy: z.literal(true).describe("Indicates session is busy"),
+  sessionId: z.string().describe("The session ID"),
+  queueLength: z.number().describe("Current number of messages in queue"),
+  hint: z.string().describe("Instructions for the client")
+}).strict().describe("Busy response for streaming requests");
+const messageRoute = createRoute({
+  method: "post",
+  path: "/message",
+  summary: "Send Message (async)",
+  description: "Sends a message and returns immediately. The full response will be sent over SSE",
+  tags: ["messages"],
+  request: {
+    body: {
+      content: { "application/json": { schema: MessageBodySchema } }
+    }
+  },
+  responses: {
+    202: {
+      description: "Message accepted for async processing; subscribe to SSE for results",
+      content: {
+        "application/json": {
+          schema: MessageAcceptedResponseSchema
+        }
       }
     },
-    responses: {
-      202: {
-        description: "Message accepted for async processing; subscribe to SSE for results",
-        content: {
-          "application/json": {
-            schema: z.object({
-              accepted: z.literal(true).describe("Indicates request was accepted"),
-              sessionId: z.string().describe("Session ID used for this message")
-            }).strict()
-          }
-        }
-      },
-      400: { description: "Validation error" }
-    }
-  });
-  const messageSyncRoute = createRoute({
-    method: "post",
-    path: "/message-sync",
-    summary: "Send Message (sync)",
-    description: "Sends a message and waits for the full response",
-    tags: ["messages"],
-    request: {
-      body: { content: { "application/json": { schema: MessageBodySchema } } }
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ApiErrorResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Synchronous response",
-        content: {
-          "application/json": {
-            schema: z.object({
-              response: z.string().describe("Agent response text"),
-              sessionId: z.string().describe("Session ID used for this message"),
-              tokenUsage: TokenUsageSchema.optional().describe("Token usage statistics"),
-              messageId: z.string().uuid().optional().describe("Assistant message ID for this response"),
-              usageScopeId: z.string().optional().describe(
-                "Optional usage scope identifier for runtime-scoped metering"
-              ),
-              estimatedCost: z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
-              pricingStatus: PricingStatusSchema.optional().describe(
-                "Whether pricing was resolved for this response"
-              ),
-              reasoning: z.string().optional().describe("Extended thinking content from reasoning models"),
-              model: z.string().optional().describe("Model used for this response"),
-              provider: z.enum(LLM_PROVIDERS).optional().describe("LLM provider")
-            }).strict()
-          }
+    500: InternalErrorResponse
+  }
+});
+const messageSyncRoute = createRoute({
+  method: "post",
+  path: "/message-sync",
+  summary: "Send Message (sync)",
+  description: "Sends a message and waits for the full response",
+  tags: ["messages"],
+  request: {
+    body: { content: { "application/json": { schema: MessageBodySchema } } }
+  },
+  responses: {
+    200: {
+      description: "Synchronous response",
+      content: {
+        "application/json": {
+          schema: MessageSyncResponseSchema
         }
-      },
-      400: { description: "Validation error" }
-    }
-  });
-  const resetRoute = createRoute({
-    method: "post",
-    path: "/reset",
-    summary: "Reset Conversation",
-    description: "Resets the conversation history for a given session",
-    tags: ["messages"],
-    request: {
-      body: { content: { "application/json": { schema: ResetBodySchema } } }
+      }
     },
-    responses: {
-      200: {
-        description: "Reset initiated",
-        content: {
-          "application/json": {
-            schema: z.object({
-              status: z.string().describe("Status message indicating reset was initiated"),
-              sessionId: z.string().describe("Session ID that was reset")
-            }).strict()
-          }
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ApiErrorResponseSchema } }
+    },
+    500: InternalErrorResponse
+  }
+});
+const resetRoute = createRoute({
+  method: "post",
+  path: "/reset",
+  summary: "Reset Conversation",
+  description: "Resets the conversation history for a given session",
+  tags: ["messages"],
+  request: {
+    body: { content: { "application/json": { schema: ResetBodySchema } } }
+  },
+  responses: {
+    200: {
+      description: "Reset initiated",
+      content: {
+        "application/json": {
+          schema: ResetResponseSchema
         }
       }
-    }
-  });
-  const messageStreamRoute = createRoute({
-    method: "post",
-    path: "/message-stream",
-    summary: "Stream message response",
-    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. Final llm:response events include token usage, assistant message ID, and pricing metadata when available. If the session is busy processing another message, returns 202 with queue information.",
-    tags: ["messages"],
-    request: {
-      body: {
-        content: { "application/json": { schema: MessageBodySchema } }
-      }
     },
-    responses: {
-      200: {
-        description: "SSE stream of agent events. Standard SSE format with event type and JSON data.",
-        headers: {
-          "Content-Type": {
-            description: "SSE content type",
-            schema: { type: "string", example: "text/event-stream" }
-          },
-          "Cache-Control": {
-            description: "Disable caching for stream",
-            schema: { type: "string", example: "no-cache" }
-          },
-          Connection: {
-            description: "Keep connection alive for streaming",
-            schema: { type: "string", example: "keep-alive" }
-          },
-          "X-Accel-Buffering": {
-            description: "Disable nginx buffering",
-            schema: { type: "string", example: "no" }
-          }
+    400: BadRequestErrorResponse,
+    404: NotFoundErrorResponse,
+    500: InternalErrorResponse
+  }
+});
+const messageStreamRoute = createRoute({
+  method: "post",
+  path: "/message-stream",
+  summary: "Stream message response",
+  description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. Final llm:response events include token usage, assistant message ID, and pricing metadata when available. If the session is busy processing another message, returns 202 with queue information.",
+  tags: ["messages"],
+  request: {
+    body: {
+      content: { "application/json": { schema: MessageBodySchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "SSE stream of agent events. Standard SSE format with event type and JSON data.",
+      headers: {
+        "Content-Type": {
+          description: "SSE content type",
+          schema: { type: "string", example: "text/event-stream" }
         },
-        content: {
-          "text/event-stream": {
-            schema: z.string().describe(
-              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors). Final llm:response payloads include token usage, assistant message ID, and pricing metadata when available."
-            )
-          }
+        "Cache-Control": {
+          description: "Disable caching for stream",
+          schema: { type: "string", example: "no-cache" }
+        },
+        Connection: {
+          description: "Keep connection alive for streaming",
+          schema: { type: "string", example: "keep-alive" }
+        },
+        "X-Accel-Buffering": {
+          description: "Disable nginx buffering",
+          schema: { type: "string", example: "no" }
         }
       },
-      202: {
-        description: "Session is busy processing another message. Use the queue endpoints to manage pending messages.",
-        content: {
-          "application/json": {
-            schema: z.object({
-              busy: z.literal(true).describe("Indicates session is busy"),
-              sessionId: z.string().describe("The session ID"),
-              queueLength: z.number().describe("Current number of messages in queue"),
-              hint: z.string().describe("Instructions for the client")
-            }).strict()
-          }
+      content: {
+        "text/event-stream": {
+          schema: z.string().describe(
+            "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors). Final llm:response payloads include token usage, assistant message ID, and pricing metadata when available."
+          )
         }
-      },
-      400: { description: "Validation error" }
-    }
-  });
+      }
+    },
+    202: {
+      description: "Session is busy processing another message. Use the queue endpoints to manage pending messages.",
+      content: {
+        "application/json": {
+          schema: MessageStreamBusyResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ApiErrorResponseSchema } }
+    },
+    500: InternalErrorResponse
+  }
+});
+function createMessagesRouter(getAgent, approvalCoordinator) {
+  const app = new OpenAPIHono();
   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,30 +193,35 @@ 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");
     const { sessionId } = ctx.req.valid("json");
     await agent.resetConversation(sessionId);
-    return ctx.json({ status: "reset initiated", sessionId });
+    return ctx.json({ status: "reset initiated", sessionId }, 200);
   }).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/models.cjs

@@ -25,6 +25,7 @@ var import_zod_openapi = require("@hono/zod-openapi");
 var import_fs = require("fs");
 var import_core = require("@dexto/core");
 var import_agent_management = require("@dexto/agent-management");
+var import_responses = require("../schemas/responses.js");
 const LocalModelSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Model identifier"),
   displayName: import_zod_openapi.z.string().describe("Human-readable model name"),
@@ -63,7 +64,8 @@ const listLocalModelsRoute = (0, import_zod_openapi.createRoute)({
           })
         }
       }
-    }
+    },
+    500: import_responses.InternalErrorResponse
   }
 });
 const listOllamaModelsRoute = (0, import_zod_openapi.createRoute)({
@@ -90,7 +92,9 @@ const listOllamaModelsRoute = (0, import_zod_openapi.createRoute)({
           })
         }
       }
-    }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    500: import_responses.InternalErrorResponse
   }
 });
 const validateLocalFileRoute = (0, import_zod_openapi.createRoute)({
@@ -116,7 +120,9 @@ const validateLocalFileRoute = (0, import_zod_openapi.createRoute)({
           schema: ValidateFileResponseSchema
         }
       }
-    }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    500: import_responses.InternalErrorResponse
   }
 });
 const DeleteModelRequestSchema = import_zod_openapi.z.object({
@@ -163,7 +169,9 @@ const deleteLocalModelRoute = (0, import_zod_openapi.createRoute)({
           schema: DeleteModelResponseSchema
         }
       }
-    }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    500: import_responses.InternalErrorResponse
   }
 });
 function createModelsRouter() {
@@ -181,82 +189,112 @@ function createModelsRouter() {
         source: model.source
       };
     });
-    return ctx.json({ models });
+    return ctx.json({ models }, 200);
   }).openapi(listOllamaModelsRoute, async (ctx) => {
     const { baseURL } = ctx.req.valid("query");
     const ollamaURL = baseURL || import_core.DEFAULT_OLLAMA_URL;
     try {
       const status = await (0, import_core.checkOllamaStatus)(ollamaURL);
       if (!status.running) {
-        return ctx.json({
-          available: false,
-          models: [],
-          error: "Ollama server is not running"
-        });
+        return ctx.json(
+          {
+            available: false,
+            models: [],
+            error: "Ollama server is not running"
+          },
+          200
+        );
       }
       const ollamaModels = await (0, import_core.listOllamaModels)(ollamaURL);
-      return ctx.json({
-        available: true,
-        version: status.version,
-        models: ollamaModels.map((m) => ({
-          name: m.name,
-          size: m.size,
-          digest: m.digest,
-          modifiedAt: m.modifiedAt
-        }))
-      });
+      return ctx.json(
+        {
+          available: true,
+          version: status.version,
+          models: ollamaModels.map((m) => ({
+            name: m.name,
+            size: m.size,
+            digest: m.digest,
+            modifiedAt: m.modifiedAt
+          }))
+        },
+        200
+      );
     } catch (error) {
-      return ctx.json({
-        available: false,
-        models: [],
-        error: error instanceof Error ? error.message : "Failed to connect to Ollama server"
-      });
+      return ctx.json(
+        {
+          available: false,
+          models: [],
+          error: error instanceof Error ? error.message : "Failed to connect to Ollama server"
+        },
+        200
+      );
     }
   }).openapi(validateLocalFileRoute, async (ctx) => {
     const { filePath } = ctx.req.valid("json");
     if (!filePath.startsWith("/")) {
-      return ctx.json({
-        valid: false,
-        error: "File path must be absolute (start with /)"
-      });
+      return ctx.json(
+        {
+          valid: false,
+          error: "File path must be absolute (start with /)"
+        },
+        200
+      );
     }
     if (!filePath.endsWith(".gguf")) {
-      return ctx.json({
-        valid: false,
-        error: "File must have .gguf extension"
-      });
+      return ctx.json(
+        {
+          valid: false,
+          error: "File must have .gguf extension"
+        },
+        200
+      );
     }
     try {
       const stats = await import_fs.promises.stat(filePath);
       if (!stats.isFile()) {
-        return ctx.json({
-          valid: false,
-          error: "Path is not a file"
-        });
+        return ctx.json(
+          {
+            valid: false,
+            error: "Path is not a file"
+          },
+          200
+        );
       }
       await import_fs.promises.access(filePath, import_fs.promises.constants.R_OK);
-      return ctx.json({
-        valid: true,
-        sizeBytes: stats.size
-      });
+      return ctx.json(
+        {
+          valid: true,
+          sizeBytes: stats.size
+        },
+        200
+      );
     } catch (error) {
       const nodeError = error;
       if (nodeError.code === "ENOENT") {
-        return ctx.json({
-          valid: false,
-          error: "File not found"
-        });
+        return ctx.json(
+          {
+            valid: false,
+            error: "File not found"
+          },
+          200
+        );
       }
       if (nodeError.code === "EACCES") {
-        return ctx.json({
-          valid: false,
-          error: "File is not readable (permission denied)"
-        });
+        return ctx.json(
+          {
+            valid: false,
+            error: "File is not readable (permission denied)"
+          },
+          200
+        );
       }
-      return ctx.json({
-        valid: false,
-        error: error instanceof Error ? error.message : "Failed to access file"
-      });
+      return ctx.json(
+        {
+          valid: false,
+          error: error instanceof Error ? error.message : "Failed to access file"
+        },
+        200
+      );
     }
   }).openapi(deleteLocalModelRoute, async (ctx) => {
     const { modelId } = ctx.req.valid("param");
@@ -299,18 +337,22 @@ function createModelsRouter() {
     }
     const removed = await (0, import_agent_management.removeInstalledModel)(modelId);
     if (!removed) {
-      return ctx.json({
-        success: false,
-        modelId,
-        fileDeleted,
-        error: "Failed to remove model from state"
-      });
+      throw new import_core.DextoRuntimeError(
+        "model_state_remove_failed",
+        "model",
+        import_core.ErrorType.SYSTEM,
+        "Failed to remove model from state",
+        { modelId, fileDeleted }
+      );
     }
-    return ctx.json({
-      success: true,
-      modelId,
-      fileDeleted
-    });
+    return ctx.json(
+      {
+        success: true,
+        modelId,
+        fileDeleted
+      },
+      200
+    );
   });
 }
 // Annotate the CommonJS export names for ESM import in node: