@dexto/core 1.1.10 → 1.2.0

package/dist/memory/index.cjs

@@ -0,0 +1,43 @@
+"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, {
+  CreateMemoryInputSchema: () => import_schemas.CreateMemoryInputSchema,
+  ListMemoriesOptionsSchema: () => import_schemas.ListMemoriesOptionsSchema,
+  MemoryError: () => import_errors.MemoryError,
+  MemoryErrorCode: () => import_error_codes.MemoryErrorCode,
+  MemoryManager: () => import_manager.MemoryManager,
+  MemorySchema: () => import_schemas.MemorySchema,
+  UpdateMemoryInputSchema: () => import_schemas.UpdateMemoryInputSchema
+});
+module.exports = __toCommonJS(memory_exports);
+var import_manager = require("./manager.js");
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateMemoryInputSchema,
+  ListMemoriesOptionsSchema,
+  MemoryError,
+  MemoryErrorCode,
+  MemoryManager,
+  MemorySchema,
+  UpdateMemoryInputSchema
+});

package/dist/memory/index.d.ts

@@ -0,0 +1,6 @@
+export { MemoryManager } from './manager.js';
+export type { Memory, CreateMemoryInput, UpdateMemoryInput, ListMemoriesOptions, MemorySource, } from './types.js';
+export { MemorySchema, CreateMemoryInputSchema, UpdateMemoryInputSchema, ListMemoriesOptionsSchema, type ValidatedMemory, type ValidatedCreateMemoryInput, type ValidatedUpdateMemoryInput, type ValidatedListMemoriesOptions, } from './schemas.js';
+export { MemoryError } from './errors.js';
+export { MemoryErrorCode } from './error-codes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EACR,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,YAAY,EACZ,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,GACpC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/memory/index.js

@@ -0,0 +1,19 @@
+import "../chunk-C6A6W6XS.js";
+import { MemoryManager } from "./manager.js";
+import {
+  MemorySchema,
+  CreateMemoryInputSchema,
+  UpdateMemoryInputSchema,
+  ListMemoriesOptionsSchema
+} from "./schemas.js";
+import { MemoryError } from "./errors.js";
+import { MemoryErrorCode } from "./error-codes.js";
+export {
+  CreateMemoryInputSchema,
+  ListMemoriesOptionsSchema,
+  MemoryError,
+  MemoryErrorCode,
+  MemoryManager,
+  MemorySchema,
+  UpdateMemoryInputSchema
+};

package/dist/memory/manager.cjs

@@ -0,0 +1,214 @@
+"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 manager_exports = {};
+__export(manager_exports, {
+  MemoryManager: () => MemoryManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+var import_DextoRuntimeError = require("../errors/DextoRuntimeError.js");
+var import_logger = require("../logger/index.js");
+var import_nanoid = require("nanoid");
+const MEMORY_KEY_PREFIX = "memory:item:";
+class MemoryManager {
+  constructor(database) {
+    this.database = database;
+    import_logger.logger.debug("MemoryManager initialized");
+  }
+  /**
+   * Create a new memory
+   */
+  async create(input) {
+    const validatedInput = import_schemas.CreateMemoryInputSchema.parse(input);
+    const id = (0, import_nanoid.nanoid)(12);
+    const now = Date.now();
+    const memory = {
+      id,
+      content: validatedInput.content,
+      createdAt: now,
+      updatedAt: now,
+      tags: validatedInput.tags,
+      metadata: validatedInput.metadata
+    };
+    const validatedMemory = import_schemas.MemorySchema.parse(memory);
+    try {
+      await this.database.set(this.toKey(id), validatedMemory);
+      import_logger.logger.info(`Created memory: ${id}`);
+      return validatedMemory;
+    } catch (error) {
+      throw import_errors.MemoryError.storageError(
+        `Failed to store memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Get a memory by ID
+   */
+  async get(id) {
+    if (!id || typeof id !== "string") {
+      throw import_errors.MemoryError.invalidId(id);
+    }
+    try {
+      const memory = await this.database.get(this.toKey(id));
+      if (!memory) {
+        throw import_errors.MemoryError.notFound(id);
+      }
+      return memory;
+    } catch (error) {
+      if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.MemoryErrorCode.MEMORY_NOT_FOUND) {
+        throw error;
+      }
+      throw import_errors.MemoryError.retrievalError(
+        `Failed to retrieve memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Update an existing memory
+   */
+  async update(id, input) {
+    if (!id || typeof id !== "string") {
+      throw import_errors.MemoryError.invalidId(id);
+    }
+    const validatedInput = import_schemas.UpdateMemoryInputSchema.parse(input);
+    const existing = await this.get(id);
+    const updated = {
+      ...existing,
+      content: validatedInput.content !== void 0 ? validatedInput.content : existing.content,
+      tags: validatedInput.tags !== void 0 ? validatedInput.tags : existing.tags,
+      updatedAt: Date.now()
+    };
+    if (validatedInput.metadata) {
+      updated.metadata = {
+        ...existing.metadata || {},
+        ...validatedInput.metadata
+      };
+    }
+    const validatedMemory = import_schemas.MemorySchema.parse(updated);
+    try {
+      await this.database.set(this.toKey(id), validatedMemory);
+      import_logger.logger.info(`Updated memory: ${id}`);
+      return validatedMemory;
+    } catch (error) {
+      throw import_errors.MemoryError.storageError(
+        `Failed to update memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Delete a memory by ID
+   */
+  async delete(id) {
+    if (!id || typeof id !== "string") {
+      throw import_errors.MemoryError.invalidId(id);
+    }
+    await this.get(id);
+    try {
+      await this.database.delete(this.toKey(id));
+      import_logger.logger.info(`Deleted memory: ${id}`);
+    } catch (error) {
+      throw import_errors.MemoryError.deleteError(
+        `Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * List all memories with optional filtering
+   */
+  async list(options = {}) {
+    const validatedOptions = import_schemas.ListMemoriesOptionsSchema.parse(options);
+    try {
+      const keys = await this.database.list(MEMORY_KEY_PREFIX);
+      const memories = [];
+      for (const key of keys) {
+        try {
+          const memory = await this.database.get(key);
+          if (memory) {
+            memories.push(memory);
+          }
+        } catch (error) {
+          import_logger.logger.warn(
+            `Failed to retrieve memory from key ${key}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      let filtered = memories;
+      if (validatedOptions.tags && validatedOptions.tags.length > 0) {
+        filtered = filtered.filter(
+          (m) => m.tags?.some((tag) => validatedOptions.tags.includes(tag))
+        );
+      }
+      if (validatedOptions.source) {
+        filtered = filtered.filter((m) => m.metadata?.source === validatedOptions.source);
+      }
+      if (validatedOptions.pinned !== void 0) {
+        filtered = filtered.filter((m) => m.metadata?.pinned === validatedOptions.pinned);
+      }
+      filtered.sort((a, b) => b.updatedAt - a.updatedAt);
+      if (validatedOptions.offset !== void 0 || validatedOptions.limit !== void 0) {
+        const start = validatedOptions.offset ?? 0;
+        const end = validatedOptions.limit ? start + validatedOptions.limit : void 0;
+        filtered = filtered.slice(start, end);
+      }
+      return filtered;
+    } catch (error) {
+      throw import_errors.MemoryError.retrievalError(
+        `Failed to list memories: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Check if a memory exists
+   */
+  async has(id) {
+    try {
+      await this.get(id);
+      return true;
+    } catch (error) {
+      if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.MemoryErrorCode.MEMORY_NOT_FOUND) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get count of total memories
+   */
+  async count(options = {}) {
+    const memories = await this.list(options);
+    return memories.length;
+  }
+  /**
+   * Convert memory ID to database key
+   */
+  toKey(id) {
+    return `${MEMORY_KEY_PREFIX}${id}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryManager
+});

package/dist/memory/manager.d.ts

@@ -0,0 +1,56 @@
+import type { Database } from '../storage/database/types.js';
+import type { Memory, CreateMemoryInput, UpdateMemoryInput, ListMemoriesOptions } from './types.js';
+/**
+ * MemoryManager handles CRUD operations for user memories
+ *
+ * Responsibilities:
+ * - Store and retrieve memories from the database
+ * - Validate memory data
+ * - Generate unique IDs for memories
+ * - Filter and search memories
+ *
+ * Storage format:
+ * - Key: `memory:item:{id}`
+ * - Value: Memory object
+ *
+ * TODO: Expand to support multi-scope memories (user, agent, entity, session)
+ * with namespaced keys (e.g., `memory:user:{userId}:item:{id}`) and
+ * context-aware retrieval.
+ */
+export declare class MemoryManager {
+    private database;
+    constructor(database: Database);
+    /**
+     * Create a new memory
+     */
+    create(input: CreateMemoryInput): Promise<Memory>;
+    /**
+     * Get a memory by ID
+     */
+    get(id: string): Promise<Memory>;
+    /**
+     * Update an existing memory
+     */
+    update(id: string, input: UpdateMemoryInput): Promise<Memory>;
+    /**
+     * Delete a memory by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List all memories with optional filtering
+     */
+    list(options?: ListMemoriesOptions): Promise<Memory[]>;
+    /**
+     * Check if a memory exists
+     */
+    has(id: string): Promise<boolean>;
+    /**
+     * Get count of total memories
+     */
+    count(options?: ListMemoriesOptions): Promise<number>;
+    /**
+     * Convert memory ID to database key
+     */
+    private toKey;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/memory/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/memory/manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAepG;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,aAAa;IACV,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,QAAQ;IAItC;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiCvD;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAyBtC;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IA2CnE;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvC;;OAEG;IACG,IAAI,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA8DhE;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAevC;;OAEG;IACG,KAAK,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/D;;OAEG;IACH,OAAO,CAAC,KAAK;CAGhB"}

package/dist/memory/manager.js

@@ -0,0 +1,196 @@
+import "../chunk-C6A6W6XS.js";
+import {
+  MemorySchema,
+  CreateMemoryInputSchema,
+  UpdateMemoryInputSchema,
+  ListMemoriesOptionsSchema
+} from "./schemas.js";
+import { MemoryError } from "./errors.js";
+import { MemoryErrorCode } from "./error-codes.js";
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
+import { logger } from "../logger/index.js";
+import { nanoid } from "nanoid";
+const MEMORY_KEY_PREFIX = "memory:item:";
+class MemoryManager {
+  constructor(database) {
+    this.database = database;
+    logger.debug("MemoryManager initialized");
+  }
+  /**
+   * Create a new memory
+   */
+  async create(input) {
+    const validatedInput = CreateMemoryInputSchema.parse(input);
+    const id = nanoid(12);
+    const now = Date.now();
+    const memory = {
+      id,
+      content: validatedInput.content,
+      createdAt: now,
+      updatedAt: now,
+      tags: validatedInput.tags,
+      metadata: validatedInput.metadata
+    };
+    const validatedMemory = MemorySchema.parse(memory);
+    try {
+      await this.database.set(this.toKey(id), validatedMemory);
+      logger.info(`Created memory: ${id}`);
+      return validatedMemory;
+    } catch (error) {
+      throw MemoryError.storageError(
+        `Failed to store memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Get a memory by ID
+   */
+  async get(id) {
+    if (!id || typeof id !== "string") {
+      throw MemoryError.invalidId(id);
+    }
+    try {
+      const memory = await this.database.get(this.toKey(id));
+      if (!memory) {
+        throw MemoryError.notFound(id);
+      }
+      return memory;
+    } catch (error) {
+      if (error instanceof DextoRuntimeError && error.code === MemoryErrorCode.MEMORY_NOT_FOUND) {
+        throw error;
+      }
+      throw MemoryError.retrievalError(
+        `Failed to retrieve memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Update an existing memory
+   */
+  async update(id, input) {
+    if (!id || typeof id !== "string") {
+      throw MemoryError.invalidId(id);
+    }
+    const validatedInput = UpdateMemoryInputSchema.parse(input);
+    const existing = await this.get(id);
+    const updated = {
+      ...existing,
+      content: validatedInput.content !== void 0 ? validatedInput.content : existing.content,
+      tags: validatedInput.tags !== void 0 ? validatedInput.tags : existing.tags,
+      updatedAt: Date.now()
+    };
+    if (validatedInput.metadata) {
+      updated.metadata = {
+        ...existing.metadata || {},
+        ...validatedInput.metadata
+      };
+    }
+    const validatedMemory = MemorySchema.parse(updated);
+    try {
+      await this.database.set(this.toKey(id), validatedMemory);
+      logger.info(`Updated memory: ${id}`);
+      return validatedMemory;
+    } catch (error) {
+      throw MemoryError.storageError(
+        `Failed to update memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Delete a memory by ID
+   */
+  async delete(id) {
+    if (!id || typeof id !== "string") {
+      throw MemoryError.invalidId(id);
+    }
+    await this.get(id);
+    try {
+      await this.database.delete(this.toKey(id));
+      logger.info(`Deleted memory: ${id}`);
+    } catch (error) {
+      throw MemoryError.deleteError(
+        `Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * List all memories with optional filtering
+   */
+  async list(options = {}) {
+    const validatedOptions = ListMemoriesOptionsSchema.parse(options);
+    try {
+      const keys = await this.database.list(MEMORY_KEY_PREFIX);
+      const memories = [];
+      for (const key of keys) {
+        try {
+          const memory = await this.database.get(key);
+          if (memory) {
+            memories.push(memory);
+          }
+        } catch (error) {
+          logger.warn(
+            `Failed to retrieve memory from key ${key}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      let filtered = memories;
+      if (validatedOptions.tags && validatedOptions.tags.length > 0) {
+        filtered = filtered.filter(
+          (m) => m.tags?.some((tag) => validatedOptions.tags.includes(tag))
+        );
+      }
+      if (validatedOptions.source) {
+        filtered = filtered.filter((m) => m.metadata?.source === validatedOptions.source);
+      }
+      if (validatedOptions.pinned !== void 0) {
+        filtered = filtered.filter((m) => m.metadata?.pinned === validatedOptions.pinned);
+      }
+      filtered.sort((a, b) => b.updatedAt - a.updatedAt);
+      if (validatedOptions.offset !== void 0 || validatedOptions.limit !== void 0) {
+        const start = validatedOptions.offset ?? 0;
+        const end = validatedOptions.limit ? start + validatedOptions.limit : void 0;
+        filtered = filtered.slice(start, end);
+      }
+      return filtered;
+    } catch (error) {
+      throw MemoryError.retrievalError(
+        `Failed to list memories: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Check if a memory exists
+   */
+  async has(id) {
+    try {
+      await this.get(id);
+      return true;
+    } catch (error) {
+      if (error instanceof DextoRuntimeError && error.code === MemoryErrorCode.MEMORY_NOT_FOUND) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get count of total memories
+   */
+  async count(options = {}) {
+    const memories = await this.list(options);
+    return memories.length;
+  }
+  /**
+   * Convert memory ID to database key
+   */
+  toKey(id) {
+    return `${MEMORY_KEY_PREFIX}${id}`;
+  }
+}
+export {
+  MemoryManager
+};

package/dist/memory/schemas.cjs

@@ -0,0 +1,82 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  CreateMemoryInputSchema: () => CreateMemoryInputSchema,
+  ListMemoriesOptionsSchema: () => ListMemoriesOptionsSchema,
+  MemoryMetadataSchema: () => MemoryMetadataSchema,
+  MemorySchema: () => MemorySchema,
+  MemorySourceSchema: () => MemorySourceSchema,
+  UpdateMemoryInputSchema: () => UpdateMemoryInputSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const MAX_CONTENT_LENGTH = 1e4;
+const MAX_TAG_LENGTH = 50;
+const MAX_TAGS = 10;
+const MemorySourceSchema = import_zod.z.enum(["user", "system"]).describe("Source of the memory");
+const MemoryMetadataSchema = import_zod.z.object({
+  source: MemorySourceSchema.optional().describe("Source of the memory"),
+  pinned: import_zod.z.boolean().optional().describe("Whether this memory is pinned for auto-loading")
+}).passthrough().describe("Memory metadata");
+const MemorySchema = import_zod.z.object({
+  id: import_zod.z.string().min(1).describe("Unique identifier for the memory"),
+  content: import_zod.z.string().min(1, "Memory content cannot be empty").max(
+    MAX_CONTENT_LENGTH,
+    `Memory content cannot exceed ${MAX_CONTENT_LENGTH} characters`
+  ).describe("The actual memory content"),
+  createdAt: import_zod.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
+  updatedAt: import_zod.z.number().int().positive().describe("Last update timestamp (Unix ms)"),
+  tags: import_zod.z.array(import_zod.z.string().min(1).max(MAX_TAG_LENGTH)).max(MAX_TAGS).optional().describe("Optional tags for categorization"),
+  metadata: MemoryMetadataSchema.optional().describe("Additional metadata")
+}).strict().describe("Memory item stored in the system");
+const CreateMemoryInputSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1, "Memory content cannot be empty").max(
+    MAX_CONTENT_LENGTH,
+    `Memory content cannot exceed ${MAX_CONTENT_LENGTH} characters`
+  ).describe("The memory content"),
+  tags: import_zod.z.array(import_zod.z.string().min(1).max(MAX_TAG_LENGTH)).max(MAX_TAGS).optional().describe("Optional tags"),
+  metadata: MemoryMetadataSchema.optional().describe("Optional metadata")
+}).strict().describe("Input for creating a new memory");
+const UpdateMemoryInputSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1, "Memory content cannot be empty").max(
+    MAX_CONTENT_LENGTH,
+    `Memory content cannot exceed ${MAX_CONTENT_LENGTH} characters`
+  ).optional().describe("Updated content"),
+  tags: import_zod.z.array(import_zod.z.string().min(1).max(MAX_TAG_LENGTH)).max(MAX_TAGS).optional().describe("Updated tags (replaces existing)"),
+  metadata: MemoryMetadataSchema.optional().describe(
+    "Updated metadata (merges with existing)"
+  )
+}).strict().describe("Input for updating an existing memory");
+const ListMemoriesOptionsSchema = import_zod.z.object({
+  tags: import_zod.z.array(import_zod.z.string()).optional().describe("Filter by tags"),
+  source: MemorySourceSchema.optional().describe("Filter by source"),
+  pinned: import_zod.z.boolean().optional().describe("Filter by pinned status"),
+  limit: import_zod.z.number().int().positive().optional().describe("Limit number of results"),
+  offset: import_zod.z.number().int().nonnegative().optional().describe("Skip first N results")
+}).strict().describe("Options for listing memories");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateMemoryInputSchema,
+  ListMemoriesOptionsSchema,
+  MemoryMetadataSchema,
+  MemorySchema,
+  MemorySourceSchema,
+  UpdateMemoryInputSchema
+});