@dexto/server 1.3.0 → 1.5.0

package/dist/hono/routes/messages.cjs

@@ -25,25 +25,26 @@ 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({
-  message: import_zod_openapi.z.string().optional().describe("The user message text"),
-  sessionId: import_zod_openapi.z.string().min(1, "Session ID is required").describe("The session to use for this message"),
-  imageData: import_zod_openapi.z.object({
-    image: import_zod_openapi.z.string().describe("Base64-encoded image data"),
-    mimeType: import_zod_openapi.z.string().describe("The MIME type of the image (e.g., image/png)")
-  }).optional().describe("Optional image data to include with the message"),
-  fileData: import_zod_openapi.z.object({
-    data: import_zod_openapi.z.string().describe("Base64-encoded file data"),
-    mimeType: import_zod_openapi.z.string().describe("The MIME type of the file (e.g., application/pdf)"),
-    filename: import_zod_openapi.z.string().optional().describe("The filename")
-  }).optional().describe("Optional file data to include with the message")
-}).refine(
-  (data) => {
-    const msg = (data.message ?? "").trim();
-    return msg.length > 0 || !!data.imageData || !!data.fileData;
-  },
-  { message: "Must provide either message text, image data, or file data" }
-).describe("Request body for sending a message to the agent");
+  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"),
+  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({
   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");
@@ -95,8 +96,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
               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"),
-              router: import_zod_openapi.z.enum(import_core.LLM_ROUTERS).optional().describe("Router used (e.g., vercel)")
+              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
             }).strict()
           }
         }
@@ -131,7 +131,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     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.",
+    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. If the session is busy processing another message, returns 202 with queue information.",
     tags: ["messages"],
     request: {
       body: {
@@ -167,46 +167,39 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
+      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()
+          }
+        }
+      },
       400: { description: "Validation error" }
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
-    const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.data,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
-    if (imageDataInput) agent.logger.info("Image data included in message.");
-    if (fileDataInput) agent.logger.info("File data included in message.");
+    const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
-    agent.run(message || "", imageDataInput, fileDataInput, sessionId, false).catch((error) => {
+    agent.generate(content, sessionId).catch((error) => {
       agent.logger.error(
         `Error in async message processing: ${error instanceof Error ? error.message : String(error)}`
       );
     });
     return ctx.json({ accepted: true, sessionId }, 202);
   }).openapi(messageSyncRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
-    const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.data,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
-    if (imageDataInput) agent.logger.info("Image data included in message.");
-    if (fileDataInput) agent.logger.info("File data included in message.");
+    const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
-    const result = await agent.generate(message || "", {
-      sessionId,
-      imageData: imageDataInput,
-      fileData: fileDataInput
-    });
+    const result = await agent.generate(content, sessionId);
     const llmConfig = agent.stateManager.getLLMConfig(sessionId);
     return ctx.json({
       response: result.content,
@@ -214,34 +207,33 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
       tokenUsage: result.usage,
       reasoning: result.reasoning,
       model: llmConfig.model,
-      provider: llmConfig.provider,
-      router: "vercel"
-      // Hardcoded for now since we only use Vercel AI SDK
+      provider: llmConfig.provider
     });
   }).openapi(resetRoute, async (ctx) => {
-    const agent = getAgent();
+    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 });
   }).openapi(messageStreamRoute, async (ctx) => {
-    const agent = getAgent();
-    const body = ctx.req.valid("json");
-    const { message = "", sessionId, imageData, fileData } = body;
-    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.data,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
+    const agent = await getAgent(ctx);
+    const { content, sessionId } = ctx.req.valid("json");
+    const isBusy = await agent.isSessionBusy(sessionId);
+    if (isBusy) {
+      const queuedMessages = await agent.getQueuedMessages(sessionId);
+      return ctx.json(
+        {
+          busy: true,
+          sessionId,
+          queueLength: queuedMessages.length,
+          hint: "Use POST /api/queue/{sessionId} to queue this message, or wait for the current request to complete."
+        },
+        202
+      );
+    }
     const abortController = new AbortController();
     const { signal } = abortController;
-    const iterator = await agent.stream(message, {
-      sessionId,
-      imageData: imageDataInput,
-      fileData: fileDataInput,
-      signal
-    });
+    const iterator = await agent.stream(content, sessionId, { signal });
     return (0, import_streaming.streamSSE)(ctx, async (stream) => {
       const pendingApprovalEvents = [];
       if (approvalCoordinator) {

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

@@ -1,49 +1,55 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
 import type { ApprovalCoordinator } from '../../approval/approval-coordinator.js';
-export declare function createMessagesRouter(getAgent: () => DextoAgent, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
     "/message": {
         $post: {
             input: {
                 json: {
-                    sessionId: string;
-                    message?: string | undefined;
-                    imageData?: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
                         image: string;
-                        mimeType: string;
-                    } | undefined;
-                    fileData?: {
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
-                    } | undefined;
+                    })[];
+                    sessionId: string;
                 };
             };
-            output: {
-                sessionId: string;
-                accepted: true;
-            };
-            outputFormat: "json";
-            status: 202;
+            output: {};
+            outputFormat: string;
+            status: 400;
         } | {
             input: {
                 json: {
-                    sessionId: string;
-                    message?: string | undefined;
-                    imageData?: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
                         image: string;
-                        mimeType: string;
-                    } | undefined;
-                    fileData?: {
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
-                    } | undefined;
+                    })[];
+                    sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: 400;
+            output: {
+                sessionId: string;
+                accepted: true;
+            };
+            outputFormat: "json";
+            status: 202;
         };
     };
 } & {
@@ -51,17 +57,20 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
         $post: {
             input: {
                 json: {
-                    sessionId: string;
-                    message?: string | undefined;
-                    imageData?: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
                         image: string;
-                        mimeType: string;
-                    } | undefined;
-                    fileData?: {
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
-                    } | undefined;
+                    })[];
+                    sessionId: string;
                 };
             };
             output: {};
@@ -70,17 +79,20 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
         } | {
             input: {
                 json: {
-                    sessionId: string;
-                    message?: string | undefined;
-                    imageData?: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
                         image: string;
-                        mimeType: string;
-                    } | undefined;
-                    fileData?: {
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
-                    } | undefined;
+                    })[];
+                    sessionId: string;
                 };
             };
             output: {
@@ -94,8 +106,7 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     totalTokens?: number | undefined;
                 } | undefined;
                 model?: string | undefined;
-                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                router?: "vercel" | "in-built" | undefined;
+                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
             };
             outputFormat: "json";
             status: 200;
@@ -122,17 +133,20 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
         $post: {
             input: {
                 json: {
-                    sessionId: string;
-                    message?: string | undefined;
-                    imageData?: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
                         image: string;
-                        mimeType: string;
-                    } | undefined;
-                    fileData?: {
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
-                    } | undefined;
+                    })[];
+                    sessionId: string;
                 };
             };
             output: Response;
@@ -141,22 +155,52 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
         } | {
             input: {
                 json: {
-                    sessionId: string;
-                    message?: string | undefined;
-                    imageData?: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
                         image: string;
-                        mimeType: string;
-                    } | undefined;
-                    fileData?: {
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
-                    } | undefined;
+                    })[];
+                    sessionId: string;
                 };
             };
             output: {};
             outputFormat: string;
             status: 400;
+        } | {
+            input: {
+                json: {
+                    content: string | ({
+                        type: "text";
+                        text: string;
+                    } | {
+                        type: "image";
+                        image: string;
+                        mimeType?: string | undefined;
+                    } | {
+                        type: "file";
+                        mimeType: string;
+                        data: string;
+                        filename?: string | undefined;
+                    })[];
+                    sessionId: string;
+                };
+            };
+            output: {
+                sessionId: string;
+                busy: true;
+                queueLength: number;
+                hint: string;
+            };
+            outputFormat: "json";
+            status: 202;
         };
     };
 }, "/">;

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;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA4ClF,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,MAAM,UAAU,EAC1B,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoW5C"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0U5C"}

package/dist/hono/routes/messages.js

@@ -1,26 +1,27 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { streamSSE } from "hono/streaming";
-import { LLM_PROVIDERS, LLM_ROUTERS } from "@dexto/core";
+import { LLM_PROVIDERS } from "@dexto/core";
 import { 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");
 const MessageBodySchema = z.object({
-  message: z.string().optional().describe("The user message text"),
-  sessionId: z.string().min(1, "Session ID is required").describe("The session to use for this message"),
-  imageData: z.object({
-    image: z.string().describe("Base64-encoded image data"),
-    mimeType: z.string().describe("The MIME type of the image (e.g., image/png)")
-  }).optional().describe("Optional image data to include with the message"),
-  fileData: z.object({
-    data: z.string().describe("Base64-encoded file data"),
-    mimeType: z.string().describe("The MIME type of the file (e.g., application/pdf)"),
-    filename: z.string().optional().describe("The filename")
-  }).optional().describe("Optional file data to include with the message")
-}).refine(
-  (data) => {
-    const msg = (data.message ?? "").trim();
-    return msg.length > 0 || !!data.imageData || !!data.fileData;
-  },
-  { message: "Must provide either message text, image data, or file data" }
-).describe("Request body for sending a message to the agent");
+  content: z.union([z.string(), z.array(ContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  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");
@@ -72,8 +73,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               tokenUsage: TokenUsageSchema.optional().describe("Token usage statistics"),
               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"),
-              router: z.enum(LLM_ROUTERS).optional().describe("Router used (e.g., vercel)")
+              provider: z.enum(LLM_PROVIDERS).optional().describe("LLM provider")
             }).strict()
           }
         }
@@ -108,7 +108,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     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.",
+    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. If the session is busy processing another message, returns 202 with queue information.",
     tags: ["messages"],
     request: {
       body: {
@@ -144,46 +144,39 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
+      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()
+          }
+        }
+      },
       400: { description: "Validation error" }
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
-    const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.data,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
-    if (imageDataInput) agent.logger.info("Image data included in message.");
-    if (fileDataInput) agent.logger.info("File data included in message.");
+    const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
-    agent.run(message || "", imageDataInput, fileDataInput, sessionId, false).catch((error) => {
+    agent.generate(content, sessionId).catch((error) => {
       agent.logger.error(
         `Error in async message processing: ${error instanceof Error ? error.message : String(error)}`
       );
     });
     return ctx.json({ accepted: true, sessionId }, 202);
   }).openapi(messageSyncRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
-    const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.data,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
-    if (imageDataInput) agent.logger.info("Image data included in message.");
-    if (fileDataInput) agent.logger.info("File data included in message.");
+    const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
-    const result = await agent.generate(message || "", {
-      sessionId,
-      imageData: imageDataInput,
-      fileData: fileDataInput
-    });
+    const result = await agent.generate(content, sessionId);
     const llmConfig = agent.stateManager.getLLMConfig(sessionId);
     return ctx.json({
       response: result.content,
@@ -191,34 +184,33 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
       tokenUsage: result.usage,
       reasoning: result.reasoning,
       model: llmConfig.model,
-      provider: llmConfig.provider,
-      router: "vercel"
-      // Hardcoded for now since we only use Vercel AI SDK
+      provider: llmConfig.provider
     });
   }).openapi(resetRoute, async (ctx) => {
-    const agent = getAgent();
+    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 });
   }).openapi(messageStreamRoute, async (ctx) => {
-    const agent = getAgent();
-    const body = ctx.req.valid("json");
-    const { message = "", sessionId, imageData, fileData } = body;
-    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.data,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
+    const agent = await getAgent(ctx);
+    const { content, sessionId } = ctx.req.valid("json");
+    const isBusy = await agent.isSessionBusy(sessionId);
+    if (isBusy) {
+      const queuedMessages = await agent.getQueuedMessages(sessionId);
+      return ctx.json(
+        {
+          busy: true,
+          sessionId,
+          queueLength: queuedMessages.length,
+          hint: "Use POST /api/queue/{sessionId} to queue this message, or wait for the current request to complete."
+        },
+        202
+      );
+    }
     const abortController = new AbortController();
     const { signal } = abortController;
-    const iterator = await agent.stream(message, {
-      sessionId,
-      imageData: imageDataInput,
-      fileData: fileDataInput,
-      signal
-    });
+    const iterator = await agent.stream(content, sessionId, { signal });
     return streamSSE(ctx, async (stream) => {
       const pendingApprovalEvents = [];
       if (approvalCoordinator) {