@dexto/server 1.3.0 → 1.5.0

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()
           }
         }
@@ -220,7 +245,7 @@ function createSessionsRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const sessionIds = await agent.listSessions();
     const sessions = await Promise.all(
       sessionIds.map(async (id) => {
@@ -246,7 +271,7 @@ function createSessionsRouter(getAgent) {
     );
     return ctx.json({ sessions });
   }).openapi(createRouteDef, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("json");
     const session = await agent.createSession(sessionId);
     const metadata = await agent.getSessionMetadata(session.id);
@@ -263,7 +288,7 @@ function createSessionsRouter(getAgent) {
       201
     );
   }).openapi(getRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     const metadata = await agent.getSessionMetadata(sessionId);
     const history = await agent.getSessionHistory(sessionId);
@@ -278,31 +303,59 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(historyRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     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 agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     await agent.deleteSession(sessionId);
     return ctx.json({ status: "deleted", sessionId });
   }).openapi(cancelRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     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 agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const sessionIds = await agent.listSessions();
     if (!sessionIds.includes(sessionId)) {
       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,13 +363,14 @@ 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
     );
   }).openapi(patchRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { title } = ctx.req.valid("json");
     await agent.setSessionTitle(sessionId, title);
@@ -331,7 +385,7 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(generateTitleRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const title = await agent.generateSessionTitle(sessionId);
     return ctx.json({ title, sessionId });

package/dist/hono/routes/tools.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tools_exports = {};
+__export(tools_exports, {
+  createToolsRouter: () => createToolsRouter
+});
+module.exports = __toCommonJS(tools_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+const JsonSchemaProperty = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.enum(["string", "number", "integer", "boolean", "object", "array"]).optional().describe("Property type"),
+  description: import_zod_openapi.z.string().optional().describe("Property description"),
+  enum: import_zod_openapi.z.array(import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.number(), import_zod_openapi.z.boolean()])).optional().describe("Enum values"),
+  default: import_zod_openapi.z.any().optional().describe("Default value")
+}).passthrough().describe("JSON Schema property definition");
+const ToolInputSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("object").optional().describe('Schema type, always "object" when present'),
+  properties: import_zod_openapi.z.record(JsonSchemaProperty).optional().describe("Property definitions"),
+  required: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Required property names")
+}).passthrough().describe("JSON Schema for tool input parameters");
+const ToolInfoSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Tool identifier"),
+  name: import_zod_openapi.z.string().describe("Tool name"),
+  description: import_zod_openapi.z.string().describe("Tool description"),
+  source: import_zod_openapi.z.enum(["internal", "custom", "mcp"]).describe("Source of the tool (internal, custom, or mcp)"),
+  serverName: import_zod_openapi.z.string().optional().describe("MCP server name (if source is mcp)"),
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+}).strict().describe("Tool information");
+const AllToolsResponseSchema = import_zod_openapi.z.object({
+  tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of all available tools"),
+  totalCount: import_zod_openapi.z.number().describe("Total number of tools"),
+  internalCount: import_zod_openapi.z.number().describe("Number of internal tools"),
+  customCount: import_zod_openapi.z.number().describe("Number of custom tools"),
+  mcpCount: import_zod_openapi.z.number().describe("Number of MCP tools")
+}).strict().describe("All available tools from all sources");
+function createToolsRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const allToolsRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/tools",
+    summary: "List All Tools",
+    description: "Retrieves all available tools from all sources (internal, custom, and MCP servers)",
+    tags: ["tools"],
+    responses: {
+      200: {
+        description: "All tools",
+        content: { "application/json": { schema: AllToolsResponseSchema } }
+      }
+    }
+  });
+  return app.openapi(allToolsRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const allTools = await agent.getAllTools();
+    const mcpToolsWithServerInfo = agent.getAllMcpToolsWithServerInfo();
+    const toolList = [];
+    let internalCount = 0;
+    let customCount = 0;
+    let mcpCount = 0;
+    for (const [toolName, toolInfo] of Object.entries(allTools)) {
+      let source;
+      let serverName;
+      if (toolName.startsWith("mcp--")) {
+        const mcpToolName = toolName.substring(5);
+        const mcpToolInfo = mcpToolsWithServerInfo.get(mcpToolName);
+        if (mcpToolInfo) {
+          source = "mcp";
+          serverName = mcpToolInfo.serverName;
+          mcpCount++;
+        } else {
+          source = "mcp";
+          mcpCount++;
+        }
+      } else if (toolName.startsWith("internal--")) {
+        source = "internal";
+        internalCount++;
+      } else if (toolName.startsWith("custom--")) {
+        source = "custom";
+        customCount++;
+      } else {
+        source = "internal";
+        internalCount++;
+      }
+      toolList.push({
+        id: toolName,
+        name: toolName,
+        description: toolInfo.description || "No description available",
+        source,
+        serverName,
+        inputSchema: toolInfo.parameters
+      });
+    }
+    toolList.sort((a, b) => {
+      const sourceOrder = { internal: 0, custom: 1, mcp: 2 };
+      if (a.source !== b.source) {
+        return sourceOrder[a.source] - sourceOrder[b.source];
+      }
+      return a.name.localeCompare(b.name);
+    });
+    return ctx.json({
+      tools: toolList,
+      totalCount: toolList.length,
+      internalCount,
+      customCount,
+      mcpCount
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createToolsRouter
+});

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

@@ -0,0 +1,42 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createToolsRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+    "/tools": {
+        $get: {
+            input: {};
+            output: {
+                tools: {
+                    description: string;
+                    id: string;
+                    name: string;
+                    source: "custom" | "mcp" | "internal";
+                    serverName?: string | undefined;
+                    inputSchema?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        type?: "object" | undefined;
+                        properties?: {
+                            [x: string]: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                description?: string | undefined;
+                                default?: any;
+                                type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | undefined;
+                                enum?: (string | number | boolean)[] | undefined;
+                            };
+                        } | undefined;
+                        required?: string[] | undefined;
+                    } | undefined;
+                }[];
+                totalCount: number;
+                internalCount: number;
+                customCount: number;
+                mcpCount: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export {};
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAqDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0FrD"}

package/dist/hono/routes/tools.js

@@ -0,0 +1,102 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+const JsonSchemaProperty = z.object({
+  type: z.enum(["string", "number", "integer", "boolean", "object", "array"]).optional().describe("Property type"),
+  description: z.string().optional().describe("Property description"),
+  enum: z.array(z.union([z.string(), z.number(), z.boolean()])).optional().describe("Enum values"),
+  default: z.any().optional().describe("Default value")
+}).passthrough().describe("JSON Schema property definition");
+const ToolInputSchema = z.object({
+  type: z.literal("object").optional().describe('Schema type, always "object" when present'),
+  properties: z.record(JsonSchemaProperty).optional().describe("Property definitions"),
+  required: z.array(z.string()).optional().describe("Required property names")
+}).passthrough().describe("JSON Schema for tool input parameters");
+const ToolInfoSchema = z.object({
+  id: z.string().describe("Tool identifier"),
+  name: z.string().describe("Tool name"),
+  description: z.string().describe("Tool description"),
+  source: z.enum(["internal", "custom", "mcp"]).describe("Source of the tool (internal, custom, or mcp)"),
+  serverName: z.string().optional().describe("MCP server name (if source is mcp)"),
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+}).strict().describe("Tool information");
+const AllToolsResponseSchema = z.object({
+  tools: z.array(ToolInfoSchema).describe("Array of all available tools"),
+  totalCount: z.number().describe("Total number of tools"),
+  internalCount: z.number().describe("Number of internal tools"),
+  customCount: z.number().describe("Number of custom tools"),
+  mcpCount: z.number().describe("Number of MCP tools")
+}).strict().describe("All available tools from all sources");
+function createToolsRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const allToolsRoute = createRoute({
+    method: "get",
+    path: "/tools",
+    summary: "List All Tools",
+    description: "Retrieves all available tools from all sources (internal, custom, and MCP servers)",
+    tags: ["tools"],
+    responses: {
+      200: {
+        description: "All tools",
+        content: { "application/json": { schema: AllToolsResponseSchema } }
+      }
+    }
+  });
+  return app.openapi(allToolsRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const allTools = await agent.getAllTools();
+    const mcpToolsWithServerInfo = agent.getAllMcpToolsWithServerInfo();
+    const toolList = [];
+    let internalCount = 0;
+    let customCount = 0;
+    let mcpCount = 0;
+    for (const [toolName, toolInfo] of Object.entries(allTools)) {
+      let source;
+      let serverName;
+      if (toolName.startsWith("mcp--")) {
+        const mcpToolName = toolName.substring(5);
+        const mcpToolInfo = mcpToolsWithServerInfo.get(mcpToolName);
+        if (mcpToolInfo) {
+          source = "mcp";
+          serverName = mcpToolInfo.serverName;
+          mcpCount++;
+        } else {
+          source = "mcp";
+          mcpCount++;
+        }
+      } else if (toolName.startsWith("internal--")) {
+        source = "internal";
+        internalCount++;
+      } else if (toolName.startsWith("custom--")) {
+        source = "custom";
+        customCount++;
+      } else {
+        source = "internal";
+        internalCount++;
+      }
+      toolList.push({
+        id: toolName,
+        name: toolName,
+        description: toolInfo.description || "No description available",
+        source,
+        serverName,
+        inputSchema: toolInfo.parameters
+      });
+    }
+    toolList.sort((a, b) => {
+      const sourceOrder = { internal: 0, custom: 1, mcp: 2 };
+      if (a.source !== b.source) {
+        return sourceOrder[a.source] - sourceOrder[b.source];
+      }
+      return a.name.localeCompare(b.name);
+    });
+    return ctx.json({
+      tools: toolList,
+      totalCount: toolList.length,
+      internalCount,
+      customCount,
+      mcpCount
+    });
+  });
+}
+export {
+  createToolsRouter
+};

package/dist/hono/routes/webhooks.cjs

@@ -148,7 +148,7 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
     }
   });
   return app.openapi(registerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { url, secret, description } = ctx.req.valid("json");
     const webhookId = `wh_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
     const webhook = {
@@ -193,8 +193,8 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
         createdAt: webhook.createdAt
       }
     });
-  }).openapi(deleteRoute, (ctx) => {
-    const agent = getAgent();
+  }).openapi(deleteRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const removed = webhookSubscriber.removeWebhook(webhookId);
     if (!removed) {
@@ -203,7 +203,7 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
     agent.logger.info(`Webhook removed: ${webhookId}`);
     return ctx.json({ status: "removed", webhookId });
   }).openapi(testRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const webhook = webhookSubscriber.getWebhook(webhookId);
     if (!webhook) {

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

@@ -1,7 +1,9 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
 import { WebhookEventSubscriber } from '../../events/webhook-subscriber.js';
-export declare function createWebhooksRouter(getAgent: () => DextoAgent, webhookSubscriber: WebhookEventSubscriber): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createWebhooksRouter(getAgent: GetAgentFn, webhookSubscriber: WebhookEventSubscriber): OpenAPIHono<import("hono").Env, {
     "/webhooks": {
         $post: {
             input: {
@@ -124,4 +126,5 @@ export declare function createWebhooksRouter(getAgent: () => DextoAgent, webhook
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=webhooks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/webhooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAmC5E,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,MAAM,UAAU,EAC1B,iBAAiB,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0N5C"}
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/webhooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAE5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAkCrE,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,iBAAiB,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0N5C"}

package/dist/hono/routes/webhooks.js

@@ -125,7 +125,7 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
     }
   });
   return app.openapi(registerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { url, secret, description } = ctx.req.valid("json");
     const webhookId = `wh_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
     const webhook = {
@@ -170,8 +170,8 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
         createdAt: webhook.createdAt
       }
     });
-  }).openapi(deleteRoute, (ctx) => {
-    const agent = getAgent();
+  }).openapi(deleteRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const removed = webhookSubscriber.removeWebhook(webhookId);
     if (!removed) {
@@ -180,7 +180,7 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
     agent.logger.info(`Webhook removed: ${webhookId}`);
     return ctx.json({ status: "removed", webhookId });
   }).openapi(testRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const webhook = webhookSubscriber.getWebhook(webhookId);
     if (!webhook) {

package/dist/hono/schemas/responses.cjs

@@ -55,6 +55,7 @@ __export(responses_exports, {
   ToolCallSchema: () => ToolCallSchema,
   ToolConfirmationConfigSchema: () => import_core6.ToolConfirmationConfigSchema,
   ToolSchema: () => ToolSchema,
+  UIResourcePartSchema: () => UIResourcePartSchema,
   WebhookSchema: () => WebhookSchema
 });
 module.exports = __toCommonJS(responses_exports);
@@ -81,7 +82,26 @@ const FilePartSchema = import_zod.z.object({
   mimeType: import_zod.z.string().describe("MIME type of the file"),
   filename: import_zod.z.string().optional().describe("Optional filename")
 }).strict().describe("File content part");
-const ContentPartSchema = import_zod.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Message content part (text, image, or file)");
+const UIResourcePartSchema = import_zod.z.object({
+  type: import_zod.z.literal("ui-resource").describe("Part type: ui-resource"),
+  uri: import_zod.z.string().describe("URI identifying the UI resource (must start with ui://)"),
+  mimeType: import_zod.z.string().describe("MIME type: text/html, text/uri-list, or application/vnd.mcp-ui.remote-dom"),
+  content: import_zod.z.string().optional().describe("Inline HTML content or URL"),
+  blob: import_zod.z.string().optional().describe("Base64-encoded content (alternative to content)"),
+  metadata: import_zod.z.object({
+    title: import_zod.z.string().optional().describe("Display title for the UI resource"),
+    preferredSize: import_zod.z.object({
+      width: import_zod.z.number().describe("Preferred width in pixels"),
+      height: import_zod.z.number().describe("Preferred height in pixels")
+    }).strict().optional().describe("Preferred rendering size")
+  }).strict().optional().describe("Optional metadata for the UI resource")
+}).strict().describe("UI Resource content part for MCP-UI interactive components");
+const ContentPartSchema = import_zod.z.discriminatedUnion("type", [
+  TextPartSchema,
+  ImagePartSchema,
+  FilePartSchema,
+  UIResourcePartSchema
+]).describe("Message content part (text, image, file, or UI resource)");
 const ToolCallSchema = import_zod.z.object({
   id: import_zod.z.string().describe("Unique identifier for this tool call"),
   type: import_zod.z.literal("function").describe("Tool call type (currently only function is supported)"),
@@ -105,10 +125,10 @@ const InternalMessageSchema = import_zod.z.object({
   tokenUsage: TokenUsageSchema.optional().describe("Optional token usage accounting"),
   model: import_zod.z.string().optional().describe("Model identifier for assistant messages"),
   provider: import_zod.z.enum(import_core.LLM_PROVIDERS).optional().describe("Provider identifier for assistant messages"),
-  router: import_zod.z.enum(import_core.LLM_ROUTERS).optional().describe("Router metadata for assistant messages"),
   toolCalls: import_zod.z.array(ToolCallSchema).optional().describe("Tool calls made by the assistant"),
   toolCallId: import_zod.z.string().optional().describe("ID of the tool call this message responds to"),
-  name: import_zod.z.string().optional().describe("Name of the tool that produced this result")
+  name: import_zod.z.string().optional().describe("Name of the tool that produced this result"),
+  success: import_zod.z.boolean().optional().describe("Whether tool execution succeeded (present for role=tool messages)")
 }).strict().describe("Internal message representation");
 const LLMConfigResponseSchema = import_core.LLMConfigBaseSchema.omit({ apiKey: true }).extend({
   hasApiKey: import_zod.z.boolean().optional().describe("Whether an API key is configured")
@@ -163,7 +183,6 @@ const CatalogModelInfoSchema = import_zod.z.object({
   maxInputTokens: import_zod.z.number().int().positive().describe("Maximum input tokens"),
   default: import_zod.z.boolean().optional().describe("Whether this is a default model"),
   supportedFileTypes: import_zod.z.array(import_zod.z.enum(["audio", "pdf", "image"])).describe("File types this model supports"),
-  supportedRouters: import_zod.z.array(import_zod.z.enum(["vercel", "in-built"])).optional().describe("Routing strategies this model supports"),
   displayName: import_zod.z.string().optional().describe("Human-readable display name"),
   pricing: import_zod.z.object({
     inputPerM: import_zod.z.number().describe("Input cost per million tokens (USD)"),
@@ -178,7 +197,6 @@ const ProviderCatalogSchema = import_zod.z.object({
   name: import_zod.z.string().describe("Provider display name"),
   hasApiKey: import_zod.z.boolean().describe("Whether API key is configured"),
   primaryEnvVar: import_zod.z.string().describe("Primary environment variable for API key"),
-  supportedRouters: import_zod.z.array(import_zod.z.enum(["vercel", "in-built"])).describe("Routing strategies supported by this provider"),
   supportsBaseURL: import_zod.z.boolean().describe("Whether custom base URLs are supported"),
   models: import_zod.z.array(CatalogModelInfoSchema).describe("Models available from this provider"),
   supportedFileTypes: import_zod.z.array(import_zod.z.enum(["audio", "pdf", "image"])).describe("Provider-level file type support")
@@ -295,5 +313,6 @@ const DeleteResponseSchema = import_zod.z.object({
   ToolCallSchema,
   ToolConfirmationConfigSchema,
   ToolSchema,
+  UIResourcePartSchema,
   WebhookSchema
 });