@dexto/server 1.6.18 → 1.6.20

package/dist/hono/routes/queue.js

@@ -1,5 +1,12 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { ContentPartSchema } from "../schemas/responses.js";
+import { DextoRuntimeError, ErrorType } from "@dexto/core";
+import {
+  ApiErrorResponseSchema,
+  ContentPartSchema,
+  RequestContentSchema,
+  toApiContentPart,
+  toContentInput
+} 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"),
@@ -7,24 +14,8 @@ const QueuedMessageSchema = z.object({
   metadata: z.record(z.unknown()).optional().describe("Optional metadata"),
   kind: z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).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"),
+  content: RequestContentSchema,
   kind: z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).describe("Request body for queueing a message");
 function createQueueRouter(getAgent) {
@@ -52,7 +43,10 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session not found" }
+      404: {
+        description: "Session not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const queueMessageRoute = createRoute({
@@ -82,7 +76,10 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session not found" }
+      404: {
+        description: "Session not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const removeQueuedMessageRoute = createRoute({
@@ -109,7 +106,10 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session or message not found" }
+      404: {
+        description: "Session or message not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const clearQueueRoute = createRoute({
@@ -135,22 +135,35 @@ function createQueueRouter(getAgent) {
           }
         }
       },
-      404: { description: "Session not found" }
+      404: {
+        description: "Session not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(getQueueRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const messages = await agent.getQueuedMessages(sessionId);
-    return ctx.json({
-      messages,
-      count: messages.length
-    });
+    const responseMessages = messages.map((message) => ({
+      id: message.id,
+      content: message.content.map(toApiContentPart),
+      queuedAt: message.queuedAt,
+      ...message.metadata !== void 0 ? { metadata: message.metadata } : {},
+      ...message.kind !== void 0 ? { kind: message.kind } : {}
+    }));
+    return ctx.json(
+      {
+        messages: responseMessages,
+        count: responseMessages.length
+      },
+      200
+    );
   }).openapi(queueMessageRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { content: rawContent } = ctx.req.valid("json");
-    const content = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
+    const content = toContentInput(rawContent);
     const { kind } = ctx.req.valid("json");
     const result = await agent.queueMessage(sessionId, {
       content,
@@ -169,14 +182,20 @@ function createQueueRouter(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);
+      throw new DextoRuntimeError(
+        "queued_message_not_found",
+        "queue",
+        ErrorType.NOT_FOUND,
+        "Message not found in queue",
+        { sessionId, messageId }
+      );
     }
-    return ctx.json({ removed: true, id: messageId });
+    return ctx.json({ removed: true, id: messageId }, 200);
   }).openapi(clearQueueRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const count = await agent.clearMessageQueue(sessionId);
-    return ctx.json({ cleared: true, count });
+    return ctx.json({ cleared: true, count }, 200);
   });
 }
 export {

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

@@ -9,11 +9,11 @@ export declare function createResourcesRouter(getAgent: GetAgentFn): OpenAPIHono
                     uri: string;
                     source: "mcp" | "internal";
                     description?: string | undefined;
+                    name?: string | undefined;
                     mimeType?: 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/schedules.d.ts

@@ -6,8 +6,8 @@ export declare function createSchedulesRouter(getAgent: GetAgentFn): OpenAPIHono
             input: {};
             output: {
                 schedules: {
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: number;
                     cronExpression: string;
                     timezone: string;
@@ -115,8 +115,8 @@ export declare function createSchedulesRouter(getAgent: GetAgentFn): OpenAPIHono
             };
             output: {
                 schedule: {
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: number;
                     cronExpression: string;
                     timezone: string;
@@ -279,8 +279,8 @@ export declare function createSchedulesRouter(getAgent: GetAgentFn): OpenAPIHono
             };
             output: {
                 schedule: {
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: number;
                     cronExpression: string;
                     timezone: string;
@@ -458,9 +458,9 @@ export declare function createSchedulesRouter(getAgent: GetAgentFn): OpenAPIHono
                     id: string;
                     scheduleId: string;
                     triggeredAt: number;
+                    error?: string | undefined;
                     completedAt?: number | undefined;
                     duration?: number | undefined;
-                    error?: string | undefined;
                     result?: string | undefined;
                 } | undefined;
             };

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

@@ -46,8 +46,8 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                         })[] | null;
                         role: "system" | "user" | "assistant" | "tool";
                         usageScopeId?: string | undefined;
-                        id?: string | undefined;
                         name?: string | undefined;
+                        id?: string | undefined;
                         timestamp?: number | undefined;
                         reasoning?: string | undefined;
                         tokenUsage?: {
@@ -74,8 +74,8 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                         success?: boolean | undefined;
                     };
                     sessionId: string;
-                    matchedText: string;
                     context: string;
+                    matchedText: string;
                     messageIndex: number;
                 }[];
                 total: number;
@@ -133,8 +133,8 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                             })[] | null;
                             role: "system" | "user" | "assistant" | "tool";
                             usageScopeId?: string | undefined;
-                            id?: string | undefined;
                             name?: string | undefined;
+                            id?: string | undefined;
                             timestamp?: number | undefined;
                             reasoning?: string | undefined;
                             tokenUsage?: {
@@ -161,8 +161,8 @@ export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<im
                             success?: boolean | undefined;
                         };
                         sessionId: string;
-                        matchedText: string;
                         context: string;
+                        matchedText: string;
                         messageIndex: number;
                     };
                 }[];

package/dist/hono/routes/sessions.cjs

@@ -476,7 +476,12 @@ function createSessionsRouter(getAgent) {
         }
       },
       404: {
-        description: "Session not found (error format handled by middleware)"
+        description: "Session not found",
+        content: {
+          "application/json": {
+            schema: import_responses.StandardErrorEnvelopeSchema
+          }
+        }
       }
     }
   });
@@ -695,7 +700,7 @@ function createSessionsRouter(getAgent) {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const title = await agent.generateSessionTitle(sessionId);
-    return ctx.json({ title, sessionId });
+    return ctx.json({ title, sessionId }, 200);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -101,6 +101,15 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
 } & {
     "/sessions/:sessionId/fork": {
         $post: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 400;
+        } | {
             input: {
                 param: {
                     sessionId: string;
@@ -147,15 +156,6 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
             };
             outputFormat: "json";
             status: 201;
-        } | {
-            input: {
-                param: {
-                    sessionId: string;
-                };
-            };
-            output: never;
-            outputFormat: "json";
-            status: 400;
         } | {
             input: {
                 param: {
@@ -257,8 +257,8 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                     })[] | null;
                     role: "system" | "user" | "assistant" | "tool";
                     usageScopeId?: string | undefined;
-                    id?: string | undefined;
                     name?: string | undefined;
+                    id?: string | undefined;
                     timestamp?: number | undefined;
                     reasoning?: string | undefined;
                     tokenUsage?: {
@@ -611,8 +611,8 @@ export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {

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;AAehE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwF9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAowBxD"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAehE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwF9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAywBxD"}

package/dist/hono/routes/sessions.js

@@ -464,7 +464,12 @@ function createSessionsRouter(getAgent) {
         }
       },
       404: {
-        description: "Session not found (error format handled by middleware)"
+        description: "Session not found",
+        content: {
+          "application/json": {
+            schema: StandardErrorEnvelopeSchema
+          }
+        }
       }
     }
   });
@@ -683,7 +688,7 @@ function createSessionsRouter(getAgent) {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const title = await agent.generateSessionTitle(sessionId);
-    return ctx.json({ title, sessionId });
+    return ctx.json({ title, sessionId }, 200);
   });
 }
 export {

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

@@ -9,8 +9,8 @@ export declare function createToolsRouter(getAgent: GetAgentFn): OpenAPIHono<imp
             output: {
                 tools: {
                     description: string;
-                    id: string;
                     name: string;
+                    id: string;
                     source: "local" | "mcp";
                     serverName?: string | undefined;
                     inputSchema?: {

package/dist/hono/routes/webhooks.cjs

@@ -22,6 +22,8 @@ __export(webhooks_exports, {
 });
 module.exports = __toCommonJS(webhooks_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_responses = require("../schemas/responses.js");
 const WebhookResponseSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Unique webhook identifier"),
   url: import_zod_openapi.z.string().url().describe("Webhook URL"),
@@ -100,7 +102,10 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
           }
         }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const deleteRoute = (0, import_zod_openapi.createRoute)({
@@ -122,7 +127,10 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
           }
         }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   const testRoute = (0, import_zod_openapi.createRoute)({
@@ -144,7 +152,10 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
           }
         }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(registerRoute, async (ctx) => {
@@ -183,43 +194,67 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
     const { webhookId } = ctx.req.valid("param");
     const webhook = webhookSubscriber.getWebhook(webhookId);
     if (!webhook) {
-      return ctx.json({ error: "Webhook not found" }, 404);
+      throw new import_core.DextoRuntimeError(
+        "webhook_not_found",
+        "webhook",
+        import_core.ErrorType.NOT_FOUND,
+        "Webhook not found",
+        { webhookId }
+      );
     }
-    return ctx.json({
-      webhook: {
-        id: webhook.id,
-        url: webhook.url,
-        description: webhook.description,
-        createdAt: webhook.createdAt
-      }
-    });
+    return ctx.json(
+      {
+        webhook: {
+          id: webhook.id,
+          url: webhook.url,
+          description: webhook.description,
+          createdAt: webhook.createdAt
+        }
+      },
+      200
+    );
   }).openapi(deleteRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const removed = webhookSubscriber.removeWebhook(webhookId);
     if (!removed) {
-      return ctx.json({ error: "Webhook not found" }, 404);
+      throw new import_core.DextoRuntimeError(
+        "webhook_not_found",
+        "webhook",
+        import_core.ErrorType.NOT_FOUND,
+        "Webhook not found",
+        { webhookId }
+      );
     }
     agent.logger.info(`Webhook removed: ${webhookId}`);
-    return ctx.json({ status: "removed", webhookId });
+    return ctx.json({ status: "removed", webhookId }, 200);
   }).openapi(testRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const webhook = webhookSubscriber.getWebhook(webhookId);
     if (!webhook) {
-      return ctx.json({ error: "Webhook not found" }, 404);
+      throw new import_core.DextoRuntimeError(
+        "webhook_not_found",
+        "webhook",
+        import_core.ErrorType.NOT_FOUND,
+        "Webhook not found",
+        { webhookId }
+      );
     }
     agent.logger.info(`Testing webhook: ${webhookId}`);
     const result = await webhookSubscriber.testWebhook(webhookId);
-    return ctx.json({
-      test: "completed",
-      result: {
-        success: result.success,
-        statusCode: result.statusCode,
-        responseTime: result.responseTime,
-        error: result.error
-      }
-    });
+    return ctx.json(
+      {
+        test: "completed",
+        result: {
+          success: result.success,
+          statusCode: result.statusCode,
+          responseTime: result.responseTime,
+          error: result.error
+        }
+      },
+      200
+    );
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1,5 +1,5 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
+import { type DextoAgent } from '@dexto/core';
 import { WebhookEventSubscriber } from '../../events/webhook-subscriber.js';
 import type { Context } from 'hono';
 type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
@@ -49,8 +49,8 @@ export declare function createWebhooksRouter(getAgent: GetAgentFn, webhookSubscr
                     webhookId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -78,8 +78,8 @@ export declare function createWebhooksRouter(getAgent: GetAgentFn, webhookSubscr
                     webhookId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -103,8 +103,8 @@ export declare function createWebhooksRouter(getAgent: GetAgentFn, webhookSubscr
                     webhookId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {

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;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"}
+{"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,EAAgC,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAG5E,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2P5C"}

package/dist/hono/routes/webhooks.js

@@ -1,4 +1,6 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { DextoRuntimeError, ErrorType } from "@dexto/core";
+import { ApiErrorResponseSchema } from "../schemas/responses.js";
 const WebhookResponseSchema = z.object({
   id: z.string().describe("Unique webhook identifier"),
   url: z.string().url().describe("Webhook URL"),
@@ -77,7 +79,10 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
           }
         }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const deleteRoute = createRoute({
@@ -99,7 +104,10 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
           }
         }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const testRoute = createRoute({
@@ -121,7 +129,10 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
           }
         }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(registerRoute, async (ctx) => {
@@ -160,43 +171,67 @@ function createWebhooksRouter(getAgent, webhookSubscriber) {
     const { webhookId } = ctx.req.valid("param");
     const webhook = webhookSubscriber.getWebhook(webhookId);
     if (!webhook) {
-      return ctx.json({ error: "Webhook not found" }, 404);
+      throw new DextoRuntimeError(
+        "webhook_not_found",
+        "webhook",
+        ErrorType.NOT_FOUND,
+        "Webhook not found",
+        { webhookId }
+      );
     }
-    return ctx.json({
-      webhook: {
-        id: webhook.id,
-        url: webhook.url,
-        description: webhook.description,
-        createdAt: webhook.createdAt
-      }
-    });
+    return ctx.json(
+      {
+        webhook: {
+          id: webhook.id,
+          url: webhook.url,
+          description: webhook.description,
+          createdAt: webhook.createdAt
+        }
+      },
+      200
+    );
   }).openapi(deleteRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const removed = webhookSubscriber.removeWebhook(webhookId);
     if (!removed) {
-      return ctx.json({ error: "Webhook not found" }, 404);
+      throw new DextoRuntimeError(
+        "webhook_not_found",
+        "webhook",
+        ErrorType.NOT_FOUND,
+        "Webhook not found",
+        { webhookId }
+      );
     }
     agent.logger.info(`Webhook removed: ${webhookId}`);
-    return ctx.json({ status: "removed", webhookId });
+    return ctx.json({ status: "removed", webhookId }, 200);
   }).openapi(testRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { webhookId } = ctx.req.valid("param");
     const webhook = webhookSubscriber.getWebhook(webhookId);
     if (!webhook) {
-      return ctx.json({ error: "Webhook not found" }, 404);
+      throw new DextoRuntimeError(
+        "webhook_not_found",
+        "webhook",
+        ErrorType.NOT_FOUND,
+        "Webhook not found",
+        { webhookId }
+      );
     }
     agent.logger.info(`Testing webhook: ${webhookId}`);
     const result = await webhookSubscriber.testWebhook(webhookId);
-    return ctx.json({
-      test: "completed",
-      result: {
-        success: result.success,
-        statusCode: result.statusCode,
-        responseTime: result.responseTime,
-        error: result.error
-      }
-    });
+    return ctx.json(
+      {
+        test: "completed",
+        result: {
+          success: result.success,
+          statusCode: result.statusCode,
+          responseTime: result.responseTime,
+          error: result.error
+        }
+      },
+      200
+    );
   });
 }
 export {