@dexto/server 1.2.5

package/dist/hono/routes/memory.cjs

@@ -0,0 +1,192 @@
+"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 memory_exports = {};
+__export(memory_exports, {
+  createMemoryRouter: () => createMemoryRouter
+});
+module.exports = __toCommonJS(memory_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_responses = require("../schemas/responses.js");
+const MemoryIdParamSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().min(1, "Memory ID is required").describe("Memory unique identifier")
+}).describe("Path parameters for memory endpoints");
+const ListMemoriesQuerySchema = import_zod_openapi.z.object({
+  tags: import_zod_openapi.z.string().optional().transform((val) => val ? val.split(",").map((t) => t.trim()) : void 0).describe("Comma-separated list of tags to filter by"),
+  source: import_zod_openapi.z.enum(["user", "system"]).optional().describe("Filter by source (user or system)"),
+  pinned: import_zod_openapi.z.string().optional().transform((val) => val === "true" ? true : val === "false" ? false : void 0).describe("Filter by pinned status (true or false)"),
+  limit: import_zod_openapi.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).describe("Maximum number of memories to return"),
+  offset: import_zod_openapi.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).describe("Number of memories to skip")
+}).describe("Query parameters for listing and filtering memories");
+const MemoryResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(true).describe("Indicates successful response"),
+  memory: import_responses.MemorySchema.describe("The created or retrieved memory")
+}).strict().describe("Single memory response");
+const MemoriesListResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(true).describe("Indicates successful response"),
+  memories: import_zod_openapi.z.array(import_responses.MemorySchema).describe("List of memories")
+}).strict().describe("Multiple memories response");
+const MemoryDeleteResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(true).describe("Indicates successful response"),
+  message: import_zod_openapi.z.string().describe("Deletion confirmation message")
+}).strict().describe("Memory deletion response");
+function createMemoryRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const createMemoryRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/memory",
+    summary: "Create Memory",
+    description: "Creates a new memory",
+    tags: ["memory"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: import_core.CreateMemoryInputSchema
+          }
+        }
+      }
+    },
+    responses: {
+      201: {
+        description: "Memory created",
+        content: { "application/json": { schema: MemoryResponseSchema } }
+      }
+    }
+  });
+  const listRoute = (0, import_zod_openapi.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 = (0, import_zod_openapi.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 } }
+      }
+    }
+  });
+  const updateRoute = (0, import_zod_openapi.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: import_core.UpdateMemoryInputSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Memory updated",
+        content: { "application/json": { schema: MemoryResponseSchema } }
+      }
+    }
+  });
+  const deleteRoute = (0, import_zod_openapi.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 } }
+      }
+    }
+  });
+  return app.openapi(createMemoryRoute, async (ctx) => {
+    const input = ctx.req.valid("json");
+    const createInput = {
+      content: input.content
+    };
+    if (input.tags !== void 0 && Array.isArray(input.tags)) {
+      createInput.tags = input.tags;
+    }
+    if (input.metadata !== void 0) {
+      createInput.metadata = input.metadata;
+    }
+    const agent = getAgent();
+    const memory = await agent.memoryManager.create(createInput);
+    return ctx.json({ ok: true, memory }, 201);
+  }).openapi(listRoute, async (ctx) => {
+    const query = ctx.req.valid("query");
+    const options = {};
+    if (query.tags !== void 0) options.tags = query.tags;
+    if (query.source !== void 0) options.source = query.source;
+    if (query.pinned !== void 0) options.pinned = query.pinned;
+    if (query.limit !== void 0) options.limit = query.limit;
+    if (query.offset !== void 0) options.offset = query.offset;
+    const agent = getAgent();
+    const memories = await agent.memoryManager.list(options);
+    return ctx.json({ ok: true, memories });
+  }).openapi(getRoute, async (ctx) => {
+    const { id } = ctx.req.valid("param");
+    const agent = getAgent();
+    const memory = await agent.memoryManager.get(id);
+    return ctx.json({ ok: true, memory });
+  }).openapi(updateRoute, async (ctx) => {
+    const { id } = ctx.req.valid("param");
+    const updatesRaw = ctx.req.valid("json");
+    const updates = {};
+    if (updatesRaw.content !== void 0) updates.content = updatesRaw.content;
+    if (updatesRaw.metadata !== void 0) updates.metadata = updatesRaw.metadata;
+    if (updatesRaw.tags !== void 0) updates.tags = updatesRaw.tags;
+    const agent = getAgent();
+    const memory = await agent.memoryManager.update(id, updates);
+    return ctx.json({ ok: true, memory });
+  }).openapi(deleteRoute, async (ctx) => {
+    const { id } = ctx.req.valid("param");
+    const agent = getAgent();
+    await agent.memoryManager.delete(id);
+    return ctx.json({ ok: true, message: "Memory deleted successfully" });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMemoryRouter
+});

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

@@ -0,0 +1,146 @@
+import { OpenAPIHono, z } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createMemoryRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/memory": {
+        $post: {
+            input: {
+                json: {
+                    content: string;
+                    metadata?: z.objectInputType<{
+                        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+                        pinned: z.ZodOptional<z.ZodBoolean>;
+                    }, z.ZodTypeAny, "passthrough"> | undefined;
+                    tags?: string[] | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                memory: {
+                    content: string;
+                    id: string;
+                    createdAt: number;
+                    updatedAt: number;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        source?: "system" | "user" | undefined;
+                        pinned?: boolean | undefined;
+                    } | undefined;
+                    tags?: string[] | undefined | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/memory": {
+        $get: {
+            input: {
+                query: {
+                    tags?: string | undefined;
+                    source?: "system" | "user" | undefined;
+                    limit?: string | undefined;
+                    offset?: string | undefined;
+                    pinned?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                memories: {
+                    content: string;
+                    id: string;
+                    createdAt: number;
+                    updatedAt: number;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        source?: "system" | "user" | undefined;
+                        pinned?: boolean | undefined;
+                    } | undefined;
+                    tags?: string[] | undefined | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/memory/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                ok: true;
+                memory: {
+                    content: string;
+                    id: string;
+                    createdAt: number;
+                    updatedAt: number;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        source?: "system" | "user" | undefined;
+                        pinned?: boolean | undefined;
+                    } | undefined;
+                    tags?: string[] | undefined | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/memory/:id": {
+        $put: {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    metadata?: z.objectInputType<{
+                        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+                        pinned: z.ZodOptional<z.ZodBoolean>;
+                    }, z.ZodTypeAny, "passthrough"> | undefined;
+                    content?: string | undefined;
+                    tags?: string[] | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                memory: {
+                    content: string;
+                    id: string;
+                    createdAt: number;
+                    updatedAt: number;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        source?: "system" | "user" | undefined;
+                        pinned?: boolean | undefined;
+                    } | undefined;
+                    tags?: string[] | undefined | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/memory/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                message: string;
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +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;AA6D9C,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwK5D"}

package/dist/hono/routes/memory.js

@@ -0,0 +1,168 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { CreateMemoryInputSchema, UpdateMemoryInputSchema } from "@dexto/core";
+import { MemorySchema } 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");
+const ListMemoriesQuerySchema = z.object({
+  tags: z.string().optional().transform((val) => val ? val.split(",").map((t) => t.trim()) : void 0).describe("Comma-separated list of tags to filter by"),
+  source: z.enum(["user", "system"]).optional().describe("Filter by source (user or system)"),
+  pinned: z.string().optional().transform((val) => val === "true" ? true : val === "false" ? false : void 0).describe("Filter by pinned status (true or false)"),
+  limit: z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).describe("Maximum number of memories to return"),
+  offset: z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).describe("Number of memories to skip")
+}).describe("Query parameters for listing and filtering memories");
+const MemoryResponseSchema = z.object({
+  ok: z.literal(true).describe("Indicates successful response"),
+  memory: MemorySchema.describe("The created or retrieved memory")
+}).strict().describe("Single memory response");
+const MemoriesListResponseSchema = z.object({
+  ok: z.literal(true).describe("Indicates successful response"),
+  memories: z.array(MemorySchema).describe("List of memories")
+}).strict().describe("Multiple memories response");
+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
+          }
+        }
+      }
+    },
+    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: {
+      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
+          }
+        }
+      }
+    },
+    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
+    },
+    responses: {
+      200: {
+        description: "Memory deleted",
+        content: { "application/json": { schema: MemoryDeleteResponseSchema } }
+      }
+    }
+  });
+  return app.openapi(createMemoryRoute, async (ctx) => {
+    const input = ctx.req.valid("json");
+    const createInput = {
+      content: input.content
+    };
+    if (input.tags !== void 0 && Array.isArray(input.tags)) {
+      createInput.tags = input.tags;
+    }
+    if (input.metadata !== void 0) {
+      createInput.metadata = input.metadata;
+    }
+    const agent = getAgent();
+    const memory = await agent.memoryManager.create(createInput);
+    return ctx.json({ ok: true, memory }, 201);
+  }).openapi(listRoute, async (ctx) => {
+    const query = ctx.req.valid("query");
+    const options = {};
+    if (query.tags !== void 0) options.tags = query.tags;
+    if (query.source !== void 0) options.source = query.source;
+    if (query.pinned !== void 0) options.pinned = query.pinned;
+    if (query.limit !== void 0) options.limit = query.limit;
+    if (query.offset !== void 0) options.offset = query.offset;
+    const agent = getAgent();
+    const memories = await agent.memoryManager.list(options);
+    return ctx.json({ ok: true, memories });
+  }).openapi(getRoute, async (ctx) => {
+    const { id } = ctx.req.valid("param");
+    const agent = getAgent();
+    const memory = await agent.memoryManager.get(id);
+    return ctx.json({ ok: true, memory });
+  }).openapi(updateRoute, async (ctx) => {
+    const { id } = ctx.req.valid("param");
+    const updatesRaw = ctx.req.valid("json");
+    const updates = {};
+    if (updatesRaw.content !== void 0) updates.content = updatesRaw.content;
+    if (updatesRaw.metadata !== void 0) updates.metadata = updatesRaw.metadata;
+    if (updatesRaw.tags !== void 0) updates.tags = updatesRaw.tags;
+    const agent = getAgent();
+    const memory = await agent.memoryManager.update(id, updates);
+    return ctx.json({ ok: true, memory });
+  }).openapi(deleteRoute, async (ctx) => {
+    const { id } = ctx.req.valid("param");
+    const agent = getAgent();
+    await agent.memoryManager.delete(id);
+    return ctx.json({ ok: true, message: "Memory deleted successfully" });
+  });
+}
+export {
+  createMemoryRouter
+};