@dexto/server 1.3.0 → 1.4.0

package/dist/hono/routes/queue.js

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

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

@@ -11,10 +11,10 @@ export declare function createResourcesRouter(getAgent: () => DextoAgent): OpenA
                     source: "mcp" | "internal";
                     description?: string | undefined;
                     mimeType?: string | undefined;
-                    name?: string | undefined;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | undefined;
+                    name?: string | undefined;
                     serverName?: string | undefined;
                     size?: number | undefined;
                     lastModified?: string | undefined;

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

@@ -28,6 +28,19 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             mimeType: string;
                             data: string;
                             filename?: string | undefined;
+                        } | {
+                            type: "ui-resource";
+                            mimeType: string;
+                            uri: string;
+                            content?: string | undefined;
+                            blob?: string | undefined;
+                            metadata?: {
+                                title?: string | undefined;
+                                preferredSize?: {
+                                    width: number;
+                                    height: number;
+                                } | undefined;
+                            } | undefined;
                         })[] | null;
                         role: "system" | "user" | "assistant" | "tool";
                         id?: string | undefined;
@@ -42,7 +55,6 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                         } | undefined;
                         model?: string | undefined;
                         provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                        router?: "vercel" | "in-built" | undefined;
                         toolCalls?: {
                             function: {
                                 name: string;
@@ -52,6 +64,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             id: string;
                         }[] | undefined;
                         toolCallId?: string | undefined;
+                        success?: boolean | undefined;
                     };
                     sessionId: string;
                     matchedText: string;
@@ -77,6 +90,11 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                 query: string;
                 results: {
                     sessionId: string;
+                    metadata: {
+                        createdAt: number;
+                        lastActivity: number;
+                        messageCount: number;
+                    };
                     matchCount: number;
                     firstMatch: {
                         message: {
@@ -92,6 +110,19 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 mimeType: string;
                                 data: string;
                                 filename?: string | undefined;
+                            } | {
+                                type: "ui-resource";
+                                mimeType: string;
+                                uri: string;
+                                content?: string | undefined;
+                                blob?: string | undefined;
+                                metadata?: {
+                                    title?: string | undefined;
+                                    preferredSize?: {
+                                        width: number;
+                                        height: number;
+                                    } | undefined;
+                                } | undefined;
                             })[] | null;
                             role: "system" | "user" | "assistant" | "tool";
                             id?: string | undefined;
@@ -106,7 +137,6 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             } | undefined;
                             model?: string | undefined;
                             provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                            router?: "vercel" | "in-built" | undefined;
                             toolCalls?: {
                                 function: {
                                     name: string;
@@ -116,17 +146,13 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 id: string;
                             }[] | undefined;
                             toolCallId?: string | undefined;
+                            success?: boolean | undefined;
                         };
                         sessionId: string;
                         matchedText: string;
                         context: string;
                         messageIndex: number;
                     };
-                    metadata: {
-                        createdAt: number;
-                        lastActivity: number;
-                        messageCount: number;
-                    };
                 }[];
                 total: number;
                 hasMore: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA2B9C,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwD5D"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA2B9C,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwD5D"}

package/dist/hono/routes/sessions.cjs

@@ -95,7 +95,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/history",
     summary: "Get Session History",
-    description: "Retrieves the conversation history for a session",
+    description: "Retrieves the conversation history for a session along with processing status",
     tags: ["sessions"],
     request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
     responses: {
@@ -104,7 +104,10 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: import_zod_openapi.z.object({
-              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history")
+              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history"),
+              isBusy: import_zod_openapi.z.boolean().describe(
+                "Whether the session is currently processing a message"
+              )
             }).strict()
           }
         }
@@ -136,9 +139,23 @@ function createSessionsRouter(getAgent) {
     method: "post",
     path: "/sessions/{sessionId}/cancel",
     summary: "Cancel Session Run",
-    description: "Cancels an in-flight agent run for the specified session",
+    description: "Cancels an in-flight agent run for the specified session. By default (soft cancel), only the current LLM call is cancelled and queued messages continue processing. Set clearQueue=true for hard cancel to also clear any queued messages.",
     tags: ["sessions"],
-    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }),
+      body: {
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              clearQueue: import_zod_openapi.z.boolean().optional().default(false).describe(
+                "If true (hard cancel), clears queued messages. If false (soft cancel, default), queued messages continue processing."
+              )
+            }).strict()
+          }
+        },
+        required: false
+      }
+    },
     responses: {
       200: {
         description: "Cancel operation result",
@@ -146,7 +163,11 @@ function createSessionsRouter(getAgent) {
           "application/json": {
             schema: import_zod_openapi.z.object({
               cancelled: import_zod_openapi.z.boolean().describe("Whether a run was cancelled"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID")
+              sessionId: import_zod_openapi.z.string().describe("Session ID"),
+              queueCleared: import_zod_openapi.z.boolean().describe("Whether queued messages were cleared"),
+              clearedCount: import_zod_openapi.z.number().describe(
+                "Number of queued messages cleared (0 if soft cancel)"
+              )
             }).strict()
           }
         }
@@ -157,7 +178,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/load",
     summary: "Load Session",
-    description: "Validates and retrieves session information. The client should track the active session.",
+    description: "Validates and retrieves session information including processing status. The client should track the active session.",
     tags: ["sessions"],
     request: {
       params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") })
@@ -168,7 +189,11 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: import_zod_openapi.z.object({
-              session: import_responses.SessionMetadataSchema.describe("Session metadata")
+              session: import_responses.SessionMetadataSchema.extend({
+                isBusy: import_zod_openapi.z.boolean().describe(
+                  "Whether the session is currently processing a message"
+                )
+              }).describe("Session metadata with processing status")
             }).strict()
           }
         }
@@ -303,8 +328,14 @@ function createSessionsRouter(getAgent) {
   }).openapi(historyRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
-    const history = await agent.getSessionHistory(sessionId);
-    return ctx.json({ history });
+    const [history, isBusy] = await Promise.all([
+      agent.getSessionHistory(sessionId),
+      agent.isSessionBusy(sessionId)
+    ]);
+    return ctx.json({
+      history,
+      isBusy
+    });
   }).openapi(deleteRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
@@ -313,11 +344,32 @@ function createSessionsRouter(getAgent) {
   }).openapi(cancelRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
+    let clearQueue = false;
+    try {
+      const body = ctx.req.valid("json");
+      clearQueue = body?.clearQueue ?? false;
+    } catch {
+    }
+    let clearedCount = 0;
+    if (clearQueue) {
+      try {
+        clearedCount = await agent.clearMessageQueue(sessionId);
+        agent.logger.debug(
+          `Hard cancel: cleared ${clearedCount} queued message(s) for session: ${sessionId}`
+        );
+      } catch {
+      }
+    }
     const cancelled = await agent.cancel(sessionId);
     if (!cancelled) {
       agent.logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
     }
-    return ctx.json({ cancelled, sessionId });
+    return ctx.json({
+      cancelled,
+      sessionId,
+      queueCleared: clearQueue,
+      clearedCount
+    });
   }).openapi(loadRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
@@ -326,6 +378,7 @@ function createSessionsRouter(getAgent) {
       return ctx.json({ error: `Session not found: ${sessionId}` }, 404);
     }
     const metadata = await agent.getSessionMetadata(sessionId);
+    const isBusy = await agent.isSessionBusy(sessionId);
     return ctx.json(
       {
         session: {
@@ -333,7 +386,8 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || null,
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          isBusy
         }
       },
       200

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

@@ -82,6 +82,19 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         mimeType: string;
                         data: string;
                         filename?: string | undefined;
+                    } | {
+                        type: "ui-resource";
+                        mimeType: string;
+                        uri: string;
+                        content?: string | undefined;
+                        blob?: string | undefined;
+                        metadata?: {
+                            title?: string | undefined;
+                            preferredSize?: {
+                                width: number;
+                                height: number;
+                            } | undefined;
+                        } | undefined;
                     })[] | null;
                     role: "system" | "user" | "assistant" | "tool";
                     id?: string | undefined;
@@ -96,7 +109,6 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                     } | undefined;
                     model?: string | undefined;
                     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                    router?: "vercel" | "in-built" | undefined;
                     toolCalls?: {
                         function: {
                             name: string;
@@ -106,7 +118,9 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         id: string;
                     }[] | undefined;
                     toolCallId?: string | undefined;
+                    success?: boolean | undefined;
                 }[];
+                isBusy: boolean;
             };
             outputFormat: "json";
             status: 200;
@@ -135,10 +149,16 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                 param: {
                     sessionId: string;
                 };
+            } & {
+                json: {
+                    clearQueue?: boolean | undefined;
+                };
             };
             output: {
                 sessionId: string;
                 cancelled: boolean;
+                queueCleared: boolean;
+                clearedCount: number;
             };
             outputFormat: "json";
             status: 200;
@@ -158,6 +178,7 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                     createdAt: number | null;
                     lastActivity: number | null;
                     messageCount: number;
+                    isBusy: boolean;
                     title?: string | null | undefined;
                 };
             };

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

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAS9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgZ9D"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAS9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAie9D"}

package/dist/hono/routes/sessions.js

@@ -72,7 +72,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/history",
     summary: "Get Session History",
-    description: "Retrieves the conversation history for a session",
+    description: "Retrieves the conversation history for a session along with processing status",
     tags: ["sessions"],
     request: { params: z.object({ sessionId: z.string().describe("Session identifier") }) },
     responses: {
@@ -81,7 +81,10 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: z.object({
-              history: z.array(InternalMessageSchema).describe("Array of messages in conversation history")
+              history: z.array(InternalMessageSchema).describe("Array of messages in conversation history"),
+              isBusy: z.boolean().describe(
+                "Whether the session is currently processing a message"
+              )
             }).strict()
           }
         }
@@ -113,9 +116,23 @@ function createSessionsRouter(getAgent) {
     method: "post",
     path: "/sessions/{sessionId}/cancel",
     summary: "Cancel Session Run",
-    description: "Cancels an in-flight agent run for the specified session",
+    description: "Cancels an in-flight agent run for the specified session. By default (soft cancel), only the current LLM call is cancelled and queued messages continue processing. Set clearQueue=true for hard cancel to also clear any queued messages.",
     tags: ["sessions"],
-    request: { params: z.object({ sessionId: z.string().describe("Session identifier") }) },
+    request: {
+      params: z.object({ sessionId: z.string().describe("Session identifier") }),
+      body: {
+        content: {
+          "application/json": {
+            schema: z.object({
+              clearQueue: z.boolean().optional().default(false).describe(
+                "If true (hard cancel), clears queued messages. If false (soft cancel, default), queued messages continue processing."
+              )
+            }).strict()
+          }
+        },
+        required: false
+      }
+    },
     responses: {
       200: {
         description: "Cancel operation result",
@@ -123,7 +140,11 @@ function createSessionsRouter(getAgent) {
           "application/json": {
             schema: z.object({
               cancelled: z.boolean().describe("Whether a run was cancelled"),
-              sessionId: z.string().describe("Session ID")
+              sessionId: z.string().describe("Session ID"),
+              queueCleared: z.boolean().describe("Whether queued messages were cleared"),
+              clearedCount: z.number().describe(
+                "Number of queued messages cleared (0 if soft cancel)"
+              )
             }).strict()
           }
         }
@@ -134,7 +155,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/load",
     summary: "Load Session",
-    description: "Validates and retrieves session information. The client should track the active session.",
+    description: "Validates and retrieves session information including processing status. The client should track the active session.",
     tags: ["sessions"],
     request: {
       params: z.object({ sessionId: z.string().describe("Session identifier") })
@@ -145,7 +166,11 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: z.object({
-              session: SessionMetadataSchema.describe("Session metadata")
+              session: SessionMetadataSchema.extend({
+                isBusy: z.boolean().describe(
+                  "Whether the session is currently processing a message"
+                )
+              }).describe("Session metadata with processing status")
             }).strict()
           }
         }
@@ -280,8 +305,14 @@ function createSessionsRouter(getAgent) {
   }).openapi(historyRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
-    const history = await agent.getSessionHistory(sessionId);
-    return ctx.json({ history });
+    const [history, isBusy] = await Promise.all([
+      agent.getSessionHistory(sessionId),
+      agent.isSessionBusy(sessionId)
+    ]);
+    return ctx.json({
+      history,
+      isBusy
+    });
   }).openapi(deleteRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
@@ -290,11 +321,32 @@ function createSessionsRouter(getAgent) {
   }).openapi(cancelRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
+    let clearQueue = false;
+    try {
+      const body = ctx.req.valid("json");
+      clearQueue = body?.clearQueue ?? false;
+    } catch {
+    }
+    let clearedCount = 0;
+    if (clearQueue) {
+      try {
+        clearedCount = await agent.clearMessageQueue(sessionId);
+        agent.logger.debug(
+          `Hard cancel: cleared ${clearedCount} queued message(s) for session: ${sessionId}`
+        );
+      } catch {
+      }
+    }
     const cancelled = await agent.cancel(sessionId);
     if (!cancelled) {
       agent.logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
     }
-    return ctx.json({ cancelled, sessionId });
+    return ctx.json({
+      cancelled,
+      sessionId,
+      queueCleared: clearQueue,
+      clearedCount
+    });
   }).openapi(loadRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
@@ -303,6 +355,7 @@ function createSessionsRouter(getAgent) {
       return ctx.json({ error: `Session not found: ${sessionId}` }, 404);
     }
     const metadata = await agent.getSessionMetadata(sessionId);
+    const isBusy = await agent.isSessionBusy(sessionId);
     return ctx.json(
       {
         session: {
@@ -310,7 +363,8 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || null,
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          isBusy
         }
       },
       200