@dexto/server 1.6.20 → 1.6.22

package/dist/hono/routes/messages.cjs

@@ -32,158 +32,166 @@ const MessageBodySchema = import_zod_openapi.z.object({
 const ResetBodySchema = import_zod_openapi.z.object({
   sessionId: import_zod_openapi.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 import_zod_openapi.OpenAPIHono();
-  const messageRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
-              accepted: import_zod_openapi.z.literal(true).describe("Indicates request was accepted"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID used for this message")
-            }).strict()
-          }
+const MessageAcceptedResponseSchema = import_zod_openapi.z.object({
+  accepted: import_zod_openapi.z.literal(true).describe("Indicates request was accepted"),
+  sessionId: import_zod_openapi.z.string().describe("Session ID used for this message")
+}).strict().describe("Asynchronous message acceptance response");
+const MessageSyncResponseSchema = import_zod_openapi.z.object({
+  response: import_zod_openapi.z.string().describe("Agent response text"),
+  sessionId: import_zod_openapi.z.string().describe("Session ID used for this message"),
+  tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
+  messageId: import_zod_openapi.z.string().uuid().optional().describe("Assistant message ID for this response"),
+  usageScopeId: import_zod_openapi.z.string().optional().describe("Optional usage scope identifier for runtime-scoped metering"),
+  estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
+  pricingStatus: import_responses.PricingStatusSchema.optional().describe(
+    "Whether pricing was resolved for this response"
+  ),
+  reasoning: import_zod_openapi.z.string().optional().describe("Extended thinking content from reasoning models"),
+  model: import_zod_openapi.z.string().optional().describe("Model used for this response"),
+  provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
+}).strict().describe("Synchronous message response");
+const ResetResponseSchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.string().describe("Status message indicating reset was initiated"),
+  sessionId: import_zod_openapi.z.string().describe("Session ID that was reset")
+}).strict().describe("Session reset response");
+const MessageStreamBusyResponseSchema = import_zod_openapi.z.object({
+  busy: import_zod_openapi.z.literal(true).describe("Indicates session is busy"),
+  sessionId: import_zod_openapi.z.string().describe("The session ID"),
+  queueLength: import_zod_openapi.z.number().describe("Current number of messages in queue"),
+  hint: import_zod_openapi.z.string().describe("Instructions for the client")
+}).strict().describe("Busy response for streaming requests");
+const messageRoute = (0, import_zod_openapi.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
         }
-      },
-      400: {
-        description: "Validation error",
-        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
       }
-    }
-  });
-  const messageSyncRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
-              response: import_zod_openapi.z.string().describe("Agent response text"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID used for this message"),
-              tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
-              messageId: import_zod_openapi.z.string().uuid().optional().describe("Assistant message ID for this response"),
-              usageScopeId: import_zod_openapi.z.string().optional().describe(
-                "Optional usage scope identifier for runtime-scoped metering"
-              ),
-              estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
-              pricingStatus: import_responses.PricingStatusSchema.optional().describe(
-                "Whether pricing was resolved for this response"
-              ),
-              reasoning: import_zod_openapi.z.string().optional().describe("Extended thinking content from reasoning models"),
-              model: import_zod_openapi.z.string().optional().describe("Model used for this response"),
-              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
-            }).strict()
-          }
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+    },
+    500: import_responses.InternalErrorResponse
+  }
+});
+const messageSyncRoute = (0, import_zod_openapi.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",
-        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
       }
-    }
-  });
-  const resetRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
-              status: import_zod_openapi.z.string().describe("Status message indicating reset was initiated"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID that was reset")
-            }).strict()
-          }
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+    },
+    500: import_responses.InternalErrorResponse
+  }
+});
+const resetRoute = (0, import_zod_openapi.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 = (0, import_zod_openapi.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: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const messageStreamRoute = (0, import_zod_openapi.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: import_zod_openapi.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: import_zod_openapi.z.object({
-              busy: import_zod_openapi.z.literal(true).describe("Indicates session is busy"),
-              sessionId: import_zod_openapi.z.string().describe("The session ID"),
-              queueLength: import_zod_openapi.z.number().describe("Current number of messages in queue"),
-              hint: import_zod_openapi.z.string().describe("Instructions for the client")
-            }).strict()
-          }
+      content: {
+        "text/event-stream": {
+          schema: import_zod_openapi.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",
-        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
       }
-    }
-  });
+    },
+    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: import_responses.ApiErrorResponseSchema } }
+    },
+    500: import_responses.InternalErrorResponse
+  }
+});
+function createMessagesRouter(getAgent, _approvalCoordinator) {
+  const app = new import_zod_openapi.OpenAPIHono();
   return app.openapi(messageRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
@@ -223,7 +231,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     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: rawContent, sessionId } = ctx.req.valid("json");
@@ -243,42 +251,43 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     }
     const abortController = new AbortController();
     const { signal } = abortController;
-    const iterator = await agent.stream(content, sessionId, { signal });
+    const requestDisconnectSignal = ctx.req.raw.signal;
+    const streamWithDisconnectSignal = agent.stream.bind(agent);
+    const iterator = await streamWithDisconnectSignal(content, sessionId, {
+      disconnectSignal: signal
+    });
     return (0, import_streaming.streamSSE)(ctx, async (stream) => {
-      const pendingApprovalEvents = [];
-      if (approvalCoordinator) {
-        approvalCoordinator.onRequest(
-          (request) => {
-            if (request.sessionId === sessionId) {
-              pendingApprovalEvents.push({
-                event: "approval:request",
-                data: request
-              });
-            }
-          },
-          { signal }
-        );
-        approvalCoordinator.onResponse(
-          (response) => {
-            if (response.sessionId === sessionId) {
-              pendingApprovalEvents.push({
-                event: "approval:response",
-                data: response
-              });
-            }
-          },
-          { signal }
-        );
+      const abortOnDisconnect = () => {
+        abortController.abort();
+      };
+      stream.onAbort(abortOnDisconnect);
+      requestDisconnectSignal.addEventListener("abort", abortOnDisconnect, {
+        once: true
+      });
+      if (requestDisconnectSignal.aborted) {
+        abortOnDisconnect();
       }
+      let writeChain = Promise.resolve();
+      const enqueueSSEWrite = (event, data) => {
+        writeChain = writeChain.then(async () => {
+          if (signal.aborted) {
+            return;
+          }
+          await stream.writeSSE({
+            event,
+            data: JSON.stringify(data)
+          });
+        }).catch((error) => {
+          if (!signal.aborted) {
+            agent.logger.warn(
+              `Failed to write SSE event '${event}': ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        });
+        return writeChain;
+      };
       try {
         for await (const event of iterator) {
-          while (pendingApprovalEvents.length > 0) {
-            const approvalEvent = pendingApprovalEvents.shift();
-            await stream.writeSSE({
-              event: approvalEvent.event,
-              data: JSON.stringify(approvalEvent.data)
-            });
-          }
           const eventData = event.name === "llm:error" && event.error instanceof Error ? {
             ...event,
             error: {
@@ -287,31 +296,20 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               stack: event.error.stack
             }
           } : event;
-          await stream.writeSSE({
-            event: event.name,
-            data: JSON.stringify(eventData)
-          });
-        }
-        while (pendingApprovalEvents.length > 0) {
-          const approvalEvent = pendingApprovalEvents.shift();
-          await stream.writeSSE({
-            event: approvalEvent.event,
-            data: JSON.stringify(approvalEvent.data)
-          });
+          await enqueueSSEWrite(event.name, eventData);
         }
       } catch (error) {
-        await stream.writeSSE({
-          event: "llm:error",
-          data: JSON.stringify({
-            error: {
-              message: error instanceof Error ? error.message : String(error)
-            },
-            recoverable: false,
-            sessionId
-          })
+        await enqueueSSEWrite("llm:error", {
+          error: {
+            message: error instanceof Error ? error.message : String(error)
+          },
+          recoverable: false,
+          sessionId
         });
       } finally {
+        requestDisconnectSignal.removeEventListener("abort", abortOnDisconnect);
         abortController.abort();
+        await writeChain;
       }
     });
   });