@dexto/server 1.6.19 → 1.6.21

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

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAe,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA2DrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwKtD"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAe,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAO/E,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAElE,QAAA,MAAM,mBAAmB;;;;;;EAI4B,CAAC;AAEtD,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;EAwBuC,CAAC;AA2BrE,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBrB,CAAC;AAEH,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeb,CAAC;AAEH,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBZ,CAAC;AAEH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBf,CAAC;AAEH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBf,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwEtD;AAED,KAAK,kBAAkB,GAAG;IAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;CAAE,CAAC;AAEzE,KAAK,uBAAuB,GAAG,kBAAkB,CAC7C,OAAO,iBAAiB,EACxB;IAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;CAAE,CACpD,CAAC;AACF,KAAK,eAAe,GAAG,kBAAkB,CACrC,OAAO,SAAS,EAChB;IAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;CAAE,CACrD,CAAC;AACF,KAAK,cAAc,GAAG,kBAAkB,CAAC,OAAO,QAAQ,EAAE,kBAAkB,CAAC,CAAC;AAC9E,KAAK,iBAAiB,GAAG,kBAAkB,CACvC,OAAO,WAAW,EAClB,kBAAkB,GAAG;IAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;CAAE,CACzE,CAAC;AACF,KAAK,iBAAiB,GAAG,kBAAkB,CAAC,OAAO,WAAW,EAAE,kBAAkB,CAAC,CAAC;AAEpF,MAAM,MAAM,kBAAkB,GACxB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,iBAAiB,GACjB,iBAAiB,CAAC"}

package/dist/hono/routes/memory.js

@@ -1,6 +1,11 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { CreateMemoryInputSchema, UpdateMemoryInputSchema } from "@dexto/core";
-import { MemorySchema } from "../schemas/responses.js";
+import {
+  BadRequestErrorResponse,
+  InternalErrorResponse,
+  MemorySchema,
+  NotFoundErrorResponse
+} from "../schemas/responses.js";
 const MemoryIdParamSchema = z.object({
   id: z.string().min(1, "Memory ID is required").describe("Memory unique identifier")
 }).describe("Path parameters for memory endpoints");
@@ -23,99 +28,112 @@ const MemoryDeleteResponseSchema = z.object({
   ok: z.literal(true).describe("Indicates successful response"),
   message: z.string().describe("Deletion confirmation message")
 }).strict().describe("Memory deletion response");
-function createMemoryRouter(getAgent) {
-  const app = new OpenAPIHono();
-  const createMemoryRoute = createRoute({
-    method: "post",
-    path: "/memory",
-    summary: "Create Memory",
-    description: "Creates a new memory",
-    tags: ["memory"],
-    request: {
-      body: {
-        content: {
-          "application/json": {
-            schema: CreateMemoryInputSchema
-          }
+const createMemoryRoute = createRoute({
+  method: "post",
+  path: "/memory",
+  summary: "Create Memory",
+  description: "Creates a new memory",
+  tags: ["memory"],
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: CreateMemoryInputSchema
         }
       }
-    },
-    responses: {
-      201: {
-        description: "Memory created",
-        content: { "application/json": { schema: MemoryResponseSchema } }
-      }
     }
-  });
-  const listRoute = createRoute({
-    method: "get",
-    path: "/memory",
-    summary: "List Memories",
-    description: "Retrieves a list of all memories with optional filtering",
-    tags: ["memory"],
-    request: { query: ListMemoriesQuerySchema },
-    responses: {
-      200: {
-        description: "List memories",
-        content: { "application/json": { schema: MemoriesListResponseSchema } }
-      }
-    }
-  });
-  const getRoute = createRoute({
-    method: "get",
-    path: "/memory/{id}",
-    summary: "Get Memory by ID",
-    description: "Retrieves a specific memory by its unique identifier",
-    tags: ["memory"],
-    request: {
-      params: MemoryIdParamSchema
+  },
+  responses: {
+    201: {
+      description: "Memory created",
+      content: { "application/json": { schema: MemoryResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Memory details",
-        content: { "application/json": { schema: MemoryResponseSchema } }
-      }
-    }
-  });
-  const updateRoute = createRoute({
-    method: "put",
-    path: "/memory/{id}",
-    summary: "Update Memory",
-    description: "Updates an existing memory. Only provided fields will be updated",
-    tags: ["memory"],
-    request: {
-      params: MemoryIdParamSchema,
-      body: {
-        content: {
-          "application/json": {
-            schema: UpdateMemoryInputSchema
-          }
-        }
-      }
+    400: BadRequestErrorResponse,
+    500: InternalErrorResponse
+  }
+});
+const listRoute = createRoute({
+  method: "get",
+  path: "/memory",
+  summary: "List Memories",
+  description: "Retrieves a list of all memories with optional filtering",
+  tags: ["memory"],
+  request: { query: ListMemoriesQuerySchema },
+  responses: {
+    200: {
+      description: "List memories",
+      content: { "application/json": { schema: MemoriesListResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Memory updated",
-        content: { "application/json": { schema: MemoryResponseSchema } }
-      }
-    }
-  });
-  const deleteRoute = createRoute({
-    method: "delete",
-    path: "/memory/{id}",
-    summary: "Delete Memory",
-    description: "Permanently deletes a memory. This action cannot be undone",
-    tags: ["memory"],
-    request: {
-      params: MemoryIdParamSchema
+    400: BadRequestErrorResponse,
+    500: InternalErrorResponse
+  }
+});
+const getRoute = createRoute({
+  method: "get",
+  path: "/memory/{id}",
+  summary: "Get Memory by ID",
+  description: "Retrieves a specific memory by its unique identifier",
+  tags: ["memory"],
+  request: {
+    params: MemoryIdParamSchema
+  },
+  responses: {
+    200: {
+      description: "Memory details",
+      content: { "application/json": { schema: MemoryResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Memory deleted",
-        content: { "application/json": { schema: MemoryDeleteResponseSchema } }
+    400: BadRequestErrorResponse,
+    404: NotFoundErrorResponse,
+    500: InternalErrorResponse
+  }
+});
+const updateRoute = createRoute({
+  method: "put",
+  path: "/memory/{id}",
+  summary: "Update Memory",
+  description: "Updates an existing memory. Only provided fields will be updated",
+  tags: ["memory"],
+  request: {
+    params: MemoryIdParamSchema,
+    body: {
+      content: {
+        "application/json": {
+          schema: UpdateMemoryInputSchema
+        }
       }
     }
-  });
+  },
+  responses: {
+    200: {
+      description: "Memory updated",
+      content: { "application/json": { schema: MemoryResponseSchema } }
+    },
+    400: BadRequestErrorResponse,
+    404: NotFoundErrorResponse,
+    500: InternalErrorResponse
+  }
+});
+const deleteRoute = createRoute({
+  method: "delete",
+  path: "/memory/{id}",
+  summary: "Delete Memory",
+  description: "Permanently deletes a memory. This action cannot be undone",
+  tags: ["memory"],
+  request: {
+    params: MemoryIdParamSchema
+  },
+  responses: {
+    200: {
+      description: "Memory deleted",
+      content: { "application/json": { schema: MemoryDeleteResponseSchema } }
+    },
+    400: BadRequestErrorResponse,
+    404: NotFoundErrorResponse,
+    500: InternalErrorResponse
+  }
+});
+function createMemoryRouter(getAgent) {
+  const app = new OpenAPIHono();
   return app.openapi(createMemoryRoute, async (ctx) => {
     const input = ctx.req.valid("json");
     const createInput = {
@@ -140,12 +158,12 @@ function createMemoryRouter(getAgent) {
     if (query.offset !== void 0) options.offset = query.offset;
     const agent = await getAgent(ctx);
     const memories = await agent.memoryManager.list(options);
-    return ctx.json({ ok: true, memories });
+    return ctx.json({ ok: true, memories }, 200);
   }).openapi(getRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
     const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.get(id);
-    return ctx.json({ ok: true, memory });
+    return ctx.json({ ok: true, memory }, 200);
   }).openapi(updateRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
     const updatesRaw = ctx.req.valid("json");
@@ -155,12 +173,12 @@ function createMemoryRouter(getAgent) {
     if (updatesRaw.tags !== void 0) updates.tags = updatesRaw.tags;
     const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.update(id, updates);
-    return ctx.json({ ok: true, memory });
+    return ctx.json({ ok: true, memory }, 200);
   }).openapi(deleteRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
     const agent = await getAgent(ctx);
     await agent.memoryManager.delete(id);
-    return ctx.json({ ok: true, message: "Memory deleted successfully" });
+    return ctx.json({ ok: true, message: "Memory deleted successfully" }, 200);
   });
 }
 export {

package/dist/hono/routes/messages.cjs

@@ -25,176 +25,178 @@ 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({
-  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"),
+  content: import_responses.RequestContentSchema,
   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");
-function createMessagesRouter(getAgent, approvalCoordinator) {
-  const app = new import_zod_openapi.OpenAPIHono();
-  const messageRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/message",
-    summary: "Send Message (async)",
-    description: "Sends a message and returns immediately. The full response will be sent over SSE",
-    tags: ["messages"],
-    request: {
-      body: {
-        content: { "application/json": { schema: MessageBodySchema } }
+const MessageAcceptedResponseSchema = import_zod_openapi.z.object({
+  accepted: import_zod_openapi.z.literal(true).describe("Indicates request was accepted"),
+  sessionId: import_zod_openapi.z.string().describe("Session ID used for this message")
+}).strict().describe("Asynchronous message acceptance response");
+const MessageSyncResponseSchema = import_zod_openapi.z.object({
+  response: import_zod_openapi.z.string().describe("Agent response text"),
+  sessionId: import_zod_openapi.z.string().describe("Session ID used for this message"),
+  tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
+  messageId: import_zod_openapi.z.string().uuid().optional().describe("Assistant message ID for this response"),
+  usageScopeId: import_zod_openapi.z.string().optional().describe("Optional usage scope identifier for runtime-scoped metering"),
+  estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
+  pricingStatus: import_responses.PricingStatusSchema.optional().describe(
+    "Whether pricing was resolved for this response"
+  ),
+  reasoning: import_zod_openapi.z.string().optional().describe("Extended thinking content from reasoning models"),
+  model: import_zod_openapi.z.string().optional().describe("Model used for this response"),
+  provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
+}).strict().describe("Synchronous message response");
+const ResetResponseSchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.string().describe("Status message indicating reset was initiated"),
+  sessionId: import_zod_openapi.z.string().describe("Session ID that was reset")
+}).strict().describe("Session reset response");
+const MessageStreamBusyResponseSchema = import_zod_openapi.z.object({
+  busy: import_zod_openapi.z.literal(true).describe("Indicates session is busy"),
+  sessionId: import_zod_openapi.z.string().describe("The session ID"),
+  queueLength: import_zod_openapi.z.number().describe("Current number of messages in queue"),
+  hint: import_zod_openapi.z.string().describe("Instructions for the client")
+}).strict().describe("Busy response for streaming requests");
+const messageRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/message",
+  summary: "Send Message (async)",
+  description: "Sends a message and returns immediately. The full response will be sent over SSE",
+  tags: ["messages"],
+  request: {
+    body: {
+      content: { "application/json": { schema: MessageBodySchema } }
+    }
+  },
+  responses: {
+    202: {
+      description: "Message accepted for async processing; subscribe to SSE for results",
+      content: {
+        "application/json": {
+          schema: MessageAcceptedResponseSchema
+        }
       }
     },
-    responses: {
-      202: {
-        description: "Message accepted for async processing; subscribe to SSE for results",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              accepted: import_zod_openapi.z.literal(true).describe("Indicates request was accepted"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID used for this message")
-            }).strict()
-          }
-        }
-      },
-      400: { description: "Validation error" }
-    }
-  });
-  const messageSyncRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/message-sync",
-    summary: "Send Message (sync)",
-    description: "Sends a message and waits for the full response",
-    tags: ["messages"],
-    request: {
-      body: { content: { "application/json": { schema: MessageBodySchema } } }
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Synchronous response",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              response: import_zod_openapi.z.string().describe("Agent response text"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID used for this message"),
-              tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
-              messageId: import_zod_openapi.z.string().uuid().optional().describe("Assistant message ID for this response"),
-              usageScopeId: import_zod_openapi.z.string().optional().describe(
-                "Optional usage scope identifier for runtime-scoped metering"
-              ),
-              estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
-              pricingStatus: import_responses.PricingStatusSchema.optional().describe(
-                "Whether pricing was resolved for this response"
-              ),
-              reasoning: import_zod_openapi.z.string().optional().describe("Extended thinking content from reasoning models"),
-              model: import_zod_openapi.z.string().optional().describe("Model used for this response"),
-              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
-            }).strict()
-          }
+    500: import_responses.InternalErrorResponse
+  }
+});
+const messageSyncRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/message-sync",
+  summary: "Send Message (sync)",
+  description: "Sends a message and waits for the full response",
+  tags: ["messages"],
+  request: {
+    body: { content: { "application/json": { schema: MessageBodySchema } } }
+  },
+  responses: {
+    200: {
+      description: "Synchronous response",
+      content: {
+        "application/json": {
+          schema: MessageSyncResponseSchema
         }
-      },
-      400: { description: "Validation error" }
-    }
-  });
-  const resetRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/reset",
-    summary: "Reset Conversation",
-    description: "Resets the conversation history for a given session",
-    tags: ["messages"],
-    request: {
-      body: { content: { "application/json": { schema: ResetBodySchema } } }
+      }
     },
-    responses: {
-      200: {
-        description: "Reset initiated",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              status: import_zod_openapi.z.string().describe("Status message indicating reset was initiated"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID that was reset")
-            }).strict()
-          }
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+    },
+    500: import_responses.InternalErrorResponse
+  }
+});
+const resetRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/reset",
+  summary: "Reset Conversation",
+  description: "Resets the conversation history for a given session",
+  tags: ["messages"],
+  request: {
+    body: { content: { "application/json": { schema: ResetBodySchema } } }
+  },
+  responses: {
+    200: {
+      description: "Reset initiated",
+      content: {
+        "application/json": {
+          schema: ResetResponseSchema
         }
       }
-    }
-  });
-  const messageStreamRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/message-stream",
-    summary: "Stream message response",
-    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. Final llm:response events include token usage, assistant message ID, and pricing metadata when available. If the session is busy processing another message, returns 202 with queue information.",
-    tags: ["messages"],
-    request: {
-      body: {
-        content: { "application/json": { schema: MessageBodySchema } }
-      }
     },
-    responses: {
-      200: {
-        description: "SSE stream of agent events. Standard SSE format with event type and JSON data.",
-        headers: {
-          "Content-Type": {
-            description: "SSE content type",
-            schema: { type: "string", example: "text/event-stream" }
-          },
-          "Cache-Control": {
-            description: "Disable caching for stream",
-            schema: { type: "string", example: "no-cache" }
-          },
-          Connection: {
-            description: "Keep connection alive for streaming",
-            schema: { type: "string", example: "keep-alive" }
-          },
-          "X-Accel-Buffering": {
-            description: "Disable nginx buffering",
-            schema: { type: "string", example: "no" }
-          }
+    400: import_responses.BadRequestErrorResponse,
+    404: import_responses.NotFoundErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const messageStreamRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/message-stream",
+  summary: "Stream message response",
+  description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. Final llm:response events include token usage, assistant message ID, and pricing metadata when available. If the session is busy processing another message, returns 202 with queue information.",
+  tags: ["messages"],
+  request: {
+    body: {
+      content: { "application/json": { schema: MessageBodySchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "SSE stream of agent events. Standard SSE format with event type and JSON data.",
+      headers: {
+        "Content-Type": {
+          description: "SSE content type",
+          schema: { type: "string", example: "text/event-stream" }
         },
-        content: {
-          "text/event-stream": {
-            schema: import_zod_openapi.z.string().describe(
-              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors). Final llm:response payloads include token usage, assistant message ID, and pricing metadata when available."
-            )
-          }
+        "Cache-Control": {
+          description: "Disable caching for stream",
+          schema: { type: "string", example: "no-cache" }
+        },
+        Connection: {
+          description: "Keep connection alive for streaming",
+          schema: { type: "string", example: "keep-alive" }
+        },
+        "X-Accel-Buffering": {
+          description: "Disable nginx buffering",
+          schema: { type: "string", example: "no" }
         }
       },
-      202: {
-        description: "Session is busy processing another message. Use the queue endpoints to manage pending messages.",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              busy: import_zod_openapi.z.literal(true).describe("Indicates session is busy"),
-              sessionId: import_zod_openapi.z.string().describe("The session ID"),
-              queueLength: import_zod_openapi.z.number().describe("Current number of messages in queue"),
-              hint: import_zod_openapi.z.string().describe("Instructions for the client")
-            }).strict()
-          }
+      content: {
+        "text/event-stream": {
+          schema: import_zod_openapi.z.string().describe(
+            "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors). Final llm:response payloads include token usage, assistant message ID, and pricing metadata when available."
+          )
         }
-      },
-      400: { description: "Validation error" }
-    }
-  });
+      }
+    },
+    202: {
+      description: "Session is busy processing another message. Use the queue endpoints to manage pending messages.",
+      content: {
+        "application/json": {
+          schema: MessageStreamBusyResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+    },
+    500: import_responses.InternalErrorResponse
+  }
+});
+function createMessagesRouter(getAgent, approvalCoordinator) {
+  const app = new import_zod_openapi.OpenAPIHono();
   return app.openapi(messageRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = (0, import_responses.toContentInput)(rawContent);
     agent.logger.info(`Message for session: ${sessionId}`);
     agent.generate(content, sessionId).catch((error) => {
       agent.logger.error(
@@ -205,30 +207,35 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
   }).openapi(messageSyncRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = (0, import_responses.toContentInput)(rawContent);
     agent.logger.info(`Message for session: ${sessionId}`);
     const result = await agent.generate(content, sessionId);
-    return ctx.json({
-      response: result.content,
-      sessionId: result.sessionId,
-      tokenUsage: result.usage,
-      messageId: result.messageId,
-      usageScopeId: result.usageScopeId,
-      estimatedCost: result.estimatedCost,
-      pricingStatus: result.pricingStatus,
-      reasoning: result.reasoning,
-      model: result.model,
-      provider: result.provider
-    });
+    return ctx.json(
+      {
+        response: result.content,
+        sessionId: result.sessionId,
+        tokenUsage: result.usage,
+        messageId: result.messageId,
+        usageScopeId: result.usageScopeId,
+        estimatedCost: result.estimatedCost,
+        pricingStatus: result.pricingStatus,
+        reasoning: result.reasoning,
+        model: result.model,
+        provider: result.provider
+      },
+      200
+    );
   }).openapi(resetRoute, async (ctx) => {
     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 });
+    return ctx.json({ status: "reset initiated", sessionId }, 200);
   }).openapi(messageStreamRoute, async (ctx) => {
     const agent = await getAgent(ctx);
-    const { content, sessionId } = ctx.req.valid("json");
+    const { content: rawContent, sessionId } = ctx.req.valid("json");
+    const content = (0, import_responses.toContentInput)(rawContent);
     const isBusy = await agent.isSessionBusy(sessionId);
     if (isBusy) {
       const queuedMessages = await agent.getQueuedMessages(sessionId);