@langchain/langgraph-checkpoint 1.1.4 → 1.1.6

package/dist/index.cjs

@@ -37,3 +37,4 @@ exports.maxChannelVersion = require_base.maxChannelVersion;
 exports.tokenizePath = require_base$1.tokenizePath;
 exports.uuid5 = require_id.uuid5;
 exports.uuid6 = require_id.uuid6;
+exports.validateNamespace = require_base$1.validateNamespace;

package/dist/index.d.cts

@@ -4,9 +4,9 @@ import { BaseCheckpointSaver, ChannelVersions, Checkpoint, CheckpointListOptions
 import { MemorySaver } from "./memory.cjs";
 import { uuid5, uuid6 } from "./id.cjs";
 import { ChannelProtocol, ConstructorRecord, DeltaSnapshot, ERROR, INTERRUPT, RESUME, SCHEDULED, SendProtocol, TASKS, isDeltaSnapshot } from "./serde/types.cjs";
-import { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath } from "./store/base.cjs";
+import { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath, validateNamespace } from "./store/base.cjs";
 import { AsyncBatchedStore } from "./store/batch.cjs";
 import { InMemoryStore, MemoryStore } from "./store/memory.cjs";
 import { BaseCache, CacheFullKey, CacheNamespace } from "./cache/base.cjs";
 import { InMemoryCache } from "./cache/memory.cjs";
-export { All, AsyncBatchedStore, BaseCache, BaseCheckpointSaver, BaseStore, CacheFullKey, CacheNamespace, ChannelProtocol, ChannelVersions, Checkpoint, CheckpointListOptions, CheckpointMetadata, CheckpointPendingWrite, CheckpointTuple, ConstructorRecord, DeltaChannelHistory, DeltaSnapshot, ERROR, EXCLUDED_METADATA_KEYS, GetOperation, INTERRUPT, InMemoryCache, InMemoryStore, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, MemorySaver, MemoryStore, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PendingWrite, PendingWriteValue, PutOperation, RESUME, ReadonlyCheckpoint, SCHEDULED, SearchItem, SearchOperation, SendProtocol, SerializerProtocol, TASKS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, getTextAtPath, isDeltaSnapshot, maxChannelVersion, tokenizePath, uuid5, uuid6 };
+export { All, AsyncBatchedStore, BaseCache, BaseCheckpointSaver, BaseStore, CacheFullKey, CacheNamespace, ChannelProtocol, ChannelVersions, Checkpoint, CheckpointListOptions, CheckpointMetadata, CheckpointPendingWrite, CheckpointTuple, ConstructorRecord, DeltaChannelHistory, DeltaSnapshot, ERROR, EXCLUDED_METADATA_KEYS, GetOperation, INTERRUPT, InMemoryCache, InMemoryStore, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, MemorySaver, MemoryStore, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PendingWrite, PendingWriteValue, PutOperation, RESUME, ReadonlyCheckpoint, SCHEDULED, SearchItem, SearchOperation, SendProtocol, SerializerProtocol, TASKS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, getTextAtPath, isDeltaSnapshot, maxChannelVersion, tokenizePath, uuid5, uuid6, validateNamespace };

package/dist/index.d.ts

@@ -4,9 +4,9 @@ import { BaseCheckpointSaver, ChannelVersions, Checkpoint, CheckpointListOptions
 import { MemorySaver } from "./memory.js";
 import { uuid5, uuid6 } from "./id.js";
 import { ChannelProtocol, ConstructorRecord, DeltaSnapshot, ERROR, INTERRUPT, RESUME, SCHEDULED, SendProtocol, TASKS, isDeltaSnapshot } from "./serde/types.js";
-import { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath } from "./store/base.js";
+import { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath, validateNamespace } from "./store/base.js";
 import { AsyncBatchedStore } from "./store/batch.js";
 import { InMemoryStore, MemoryStore } from "./store/memory.js";
 import { BaseCache, CacheFullKey, CacheNamespace } from "./cache/base.js";
 import { InMemoryCache } from "./cache/memory.js";
-export { All, AsyncBatchedStore, BaseCache, BaseCheckpointSaver, BaseStore, CacheFullKey, CacheNamespace, ChannelProtocol, ChannelVersions, Checkpoint, CheckpointListOptions, CheckpointMetadata, CheckpointPendingWrite, CheckpointTuple, ConstructorRecord, DeltaChannelHistory, DeltaSnapshot, ERROR, EXCLUDED_METADATA_KEYS, GetOperation, INTERRUPT, InMemoryCache, InMemoryStore, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, MemorySaver, MemoryStore, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PendingWrite, PendingWriteValue, PutOperation, RESUME, ReadonlyCheckpoint, SCHEDULED, SearchItem, SearchOperation, SendProtocol, SerializerProtocol, TASKS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, getTextAtPath, isDeltaSnapshot, maxChannelVersion, tokenizePath, uuid5, uuid6 };
+export { All, AsyncBatchedStore, BaseCache, BaseCheckpointSaver, BaseStore, CacheFullKey, CacheNamespace, ChannelProtocol, ChannelVersions, Checkpoint, CheckpointListOptions, CheckpointMetadata, CheckpointPendingWrite, CheckpointTuple, ConstructorRecord, DeltaChannelHistory, DeltaSnapshot, ERROR, EXCLUDED_METADATA_KEYS, GetOperation, INTERRUPT, InMemoryCache, InMemoryStore, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, MemorySaver, MemoryStore, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PendingWrite, PendingWriteValue, PutOperation, RESUME, ReadonlyCheckpoint, SCHEDULED, SearchItem, SearchOperation, SendProtocol, SerializerProtocol, TASKS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, getTextAtPath, isDeltaSnapshot, maxChannelVersion, tokenizePath, uuid5, uuid6, validateNamespace };

package/dist/index.js

@@ -2,10 +2,10 @@ import { uuid5, uuid6 } from "./id.js";
 import { DeltaSnapshot, ERROR, INTERRUPT, RESUME, SCHEDULED, TASKS, isDeltaSnapshot } from "./serde/types.js";
 import { BaseCheckpointSaver, EXCLUDED_METADATA_KEYS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, maxChannelVersion } from "./base.js";
 import { MemorySaver } from "./memory.js";
-import { BaseStore, InvalidNamespaceError, getTextAtPath, tokenizePath } from "./store/base.js";
+import { BaseStore, InvalidNamespaceError, getTextAtPath, tokenizePath, validateNamespace } from "./store/base.js";
 import { AsyncBatchedStore } from "./store/batch.js";
 import { InMemoryStore, MemoryStore } from "./store/memory.js";
 import { BaseCache } from "./cache/base.js";
 import { InMemoryCache } from "./cache/memory.js";
 import "./cache/index.js";
-export { AsyncBatchedStore, BaseCache, BaseCheckpointSaver, BaseStore, DeltaSnapshot, ERROR, EXCLUDED_METADATA_KEYS, INTERRUPT, InMemoryCache, InMemoryStore, InvalidNamespaceError, MemorySaver, MemoryStore, RESUME, SCHEDULED, TASKS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, getTextAtPath, isDeltaSnapshot, maxChannelVersion, tokenizePath, uuid5, uuid6 };
+export { AsyncBatchedStore, BaseCache, BaseCheckpointSaver, BaseStore, DeltaSnapshot, ERROR, EXCLUDED_METADATA_KEYS, INTERRUPT, InMemoryCache, InMemoryStore, InvalidNamespaceError, MemorySaver, MemoryStore, RESUME, SCHEDULED, TASKS, WRITES_IDX_MAP, compareChannelVersions, copyCheckpoint, deepCopy, emptyCheckpoint, getCheckpointId, getTextAtPath, isDeltaSnapshot, maxChannelVersion, tokenizePath, uuid5, uuid6, validateNamespace };

package/dist/store/base.cjs

@@ -11,16 +11,24 @@ var InvalidNamespaceError = class extends Error {
 /**
 * Validates the provided namespace.
 * @param namespace The namespace to validate.
+* @param options.allowEmpty When true, an empty namespace is permitted
+*   (`search([])` means "search everything"). Put still rejects empty.
+* @param options.allowReservedRoot When true, the `langgraph` root label is
+*   permitted. Put still rejects it; search may read a namespace written via
+*   `batch()` which bypasses put validation.
 * @throws {InvalidNamespaceError} If the namespace is invalid.
 */
-function validateNamespace(namespace) {
-	if (namespace.length === 0) throw new InvalidNamespaceError("Namespace cannot be empty.");
+function validateNamespace(namespace, options = {}) {
+	if (namespace.length === 0) {
+		if (options.allowEmpty) return;
+		throw new InvalidNamespaceError("Namespace cannot be empty.");
+	}
 	for (const label of namespace) {
 		if (typeof label !== "string") throw new InvalidNamespaceError(`Invalid namespace label '${label}' found in ${namespace}. Namespace labels must be strings, but got ${typeof label}.`);
 		if (label.includes(".")) throw new InvalidNamespaceError(`Invalid namespace label '${label}' found in ${namespace}. Namespace labels cannot contain periods ('.').`);
 		if (label === "") throw new InvalidNamespaceError(`Namespace labels cannot be empty strings. Got ${label} in ${namespace}`);
 	}
-	if (namespace[0] === "langgraph") throw new InvalidNamespaceError(`Root label for namespace cannot be "langgraph". Got: ${namespace}`);
+	if (namespace[0] === "langgraph" && !options.allowReservedRoot) throw new InvalidNamespaceError(`Root label for namespace cannot be "langgraph". Got: ${namespace}`);
 }
 /**
 * Utility function to get text at a specific JSON path
@@ -101,6 +109,10 @@ var BaseStore = class {
 	* });
 	*/
 	async search(namespacePrefix, options = {}) {
+		validateNamespace(namespacePrefix, {
+			allowEmpty: true,
+			allowReservedRoot: true
+		});
 		const { filter, limit = 10, offset = 0, query } = options;
 		return (await this.batch([{
 			namespacePrefix,
@@ -207,5 +219,6 @@ exports.BaseStore = BaseStore;
 exports.InvalidNamespaceError = InvalidNamespaceError;
 exports.getTextAtPath = getTextAtPath;
 exports.tokenizePath = tokenizePath;
+exports.validateNamespace = validateNamespace;
 
 //# sourceMappingURL=base.cjs.map

package/dist/store/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":[],"sources":["../../src/store/base.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Embeddings } from \"@langchain/core/embeddings\";\n\n/**\n * Error thrown when an invalid namespace is provided.\n */\nexport class InvalidNamespaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"InvalidNamespaceError\";\n  }\n}\n\n/**\n * Validates the provided namespace.\n * @param namespace The namespace to validate.\n * @throws {InvalidNamespaceError} If the namespace is invalid.\n */\nfunction validateNamespace(namespace: string[]): void {\n  if (namespace.length === 0) {\n    throw new InvalidNamespaceError(\"Namespace cannot be empty.\");\n  }\n  for (const label of namespace) {\n    if (typeof label !== \"string\") {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels ` +\n          `must be strings, but got ${typeof label}.`\n      );\n    }\n    if (label.includes(\".\")) {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels cannot contain periods ('.').`\n      );\n    }\n    if (label === \"\") {\n      throw new InvalidNamespaceError(\n        `Namespace labels cannot be empty strings. Got ${label} in ${namespace}`\n      );\n    }\n  }\n  if (namespace[0] === \"langgraph\") {\n    throw new InvalidNamespaceError(\n      `Root label for namespace cannot be \"langgraph\". Got: ${namespace}`\n    );\n  }\n}\n\n/**\n * Represents a stored item with metadata.\n */\nexport interface Item {\n  /**\n   * The stored data as an object. Keys are filterable.\n   */\n  value: Record<string, any>;\n  /**\n   * Unique identifier within the namespace.\n   */\n  key: string;\n  /**\n   * Hierarchical path defining the collection in which this document resides.\n   * Represented as an array of strings, allowing for nested categorization.\n   * For example: [\"documents\", \"user123\"]\n   */\n  namespace: string[];\n  /**\n   * Timestamp of item creation.\n   */\n  createdAt: Date;\n  /**\n   * Timestamp of last update.\n   */\n  updatedAt: Date;\n}\n\n/**\n * Represents a search result item with relevance score.\n * Extends the base Item interface with an optional similarity score.\n */\nexport interface SearchItem extends Item {\n  /**\n   * Relevance/similarity score if from a ranked operation.\n   * Higher scores indicate better matches.\n   *\n   * This is typically a cosine similarity score between -1 and 1,\n   * where 1 indicates identical vectors and -1 indicates opposite vectors.\n   */\n  score?: number;\n}\n\n/**\n * Operation to retrieve an item by namespace and ID.\n */\nexport interface GetOperation {\n  /**\n   * Hierarchical path for the item.\n   *\n   * @example\n   * // Get a user profile\n   * namespace: [\"users\", \"profiles\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier within the namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * @example\n   * key: \"user123\"  // For a user profile\n   * key: \"doc456\"   // For a document\n   */\n  key: string;\n}\n\n/**\n * Operation to search for items within a namespace prefix.\n */\nexport interface SearchOperation {\n  /**\n   * Hierarchical path prefix to search within.\n   * Only items under this prefix will be searched.\n   *\n   * @example\n   * // Search all user documents\n   * namespacePrefix: [\"users\", \"documents\"]\n   *\n   * // Search everything\n   * namespacePrefix: []\n   */\n  namespacePrefix: string[];\n\n  /**\n   * Key-value pairs to filter results based on exact matches or comparison operators.\n   *\n   * Supports both exact matches and operator-based comparisons:\n   * - $eq: Equal to (same as direct value comparison)\n   * - $ne: Not equal to\n   * - $gt: Greater than\n   * - $gte: Greater than or equal to\n   * - $lt: Less than\n   * - $lte: Less than or equal to\n   *\n   * @example\n   * // Exact match\n   * filter: { status: \"active\" }\n   *\n   * // With operators\n   * filter: { score: { $gt: 4.99 } }\n   *\n   * // Multiple conditions\n   * filter: {\n   *   score: { $gte: 3.0 },\n   *   color: \"red\"\n   * }\n   */\n  filter?: Record<string, any>;\n\n  /**\n   * Maximum number of items to return.\n   * @default 10\n   */\n  limit?: number;\n\n  /**\n   * Number of items to skip before returning results.\n   * Useful for pagination.\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Natural language search query for semantic search.\n   * When provided, results will be ranked by relevance to this query\n   * using vector similarity search.\n   *\n   * @example\n   * // Find technical documentation about APIs\n   * query: \"technical documentation about REST APIs\"\n   *\n   * // Find recent ML papers\n   * query: \"machine learning papers from 2023\"\n   */\n  query?: string;\n}\n\n/**\n * Operation to store, update, or delete an item.\n */\nexport interface PutOperation {\n  /**\n   * Hierarchical path for the item.\n   * Acts as a folder-like structure to organize items.\n   * Each element represents one level in the hierarchy.\n   *\n   * @example\n   * // Root level documents\n   * namespace: [\"documents\"]\n   *\n   * // User-specific documents\n   * namespace: [\"documents\", \"user123\"]\n   *\n   * // Nested cache structure\n   * namespace: [\"cache\", \"docs\", \"v1\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier for the document within its namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * Example: If namespace is [\"documents\", \"user123\"] and key is \"report1\",\n   * the full path would effectively be \"documents/user123/report1\"\n   */\n  key: string;\n\n  /**\n   * Data to be stored, or null to delete the item.\n   * Must be a JSON-serializable object with string keys.\n   * Setting to null signals that the item should be deleted.\n   *\n   * @example\n   * {\n   *   field1: \"string value\",\n   *   field2: 123,\n   *   nested: { can: \"contain\", any: \"serializable data\" }\n   * }\n   */\n  value: Record<string, any> | null;\n\n  /**\n   * Controls how the item's fields are indexed for search operations.\n   *\n   * - undefined: Uses store's default indexing configuration\n   * - false: Disables indexing for this item\n   * - string[]: List of field paths to index\n   *\n   * Path syntax supports:\n   * - Nested fields: \"metadata.title\"\n   * - Array access: \"chapters[*].content\" (each indexed separately)\n   * - Specific indices: \"authors[0].name\"\n   *\n   * @example\n   * // Index specific fields\n   * index: [\"metadata.title\", \"chapters[*].content\"]\n   *\n   * // Disable indexing\n   * index: false\n   */\n  index?: false | string[];\n}\n\n/**\n * Operation to list and filter namespaces in the store.\n */\nexport interface ListNamespacesOperation {\n  matchConditions?: MatchCondition[];\n  maxDepth?: number;\n  limit: number;\n  offset: number;\n}\n\nexport type NameSpacePath = (string | \"*\")[];\n\nexport type NamespaceMatchType = \"prefix\" | \"suffix\";\n\nexport interface MatchCondition {\n  matchType: NamespaceMatchType;\n  path: NameSpacePath;\n}\n\nexport type Operation =\n  | GetOperation\n  | SearchOperation\n  | PutOperation\n  | ListNamespacesOperation;\n\nexport type OperationResults<Tuple extends readonly Operation[]> = {\n  [K in keyof Tuple]: Tuple[K] extends PutOperation\n    ? void\n    : Tuple[K] extends SearchOperation\n      ? SearchItem[]\n      : Tuple[K] extends GetOperation\n        ? Item | null\n        : Tuple[K] extends ListNamespacesOperation\n          ? string[][]\n          : never;\n};\n\n/**\n * Configuration for indexing documents for semantic search in the store.\n *\n * This configures how documents are embedded and indexed for vector similarity search.\n */\nexport interface IndexConfig {\n  /**\n   * Number of dimensions in the embedding vectors.\n   *\n   * Common embedding model dimensions:\n   * - OpenAI text-embedding-3-large: 256, 1024, or 3072\n   * - OpenAI text-embedding-3-small: 512 or 1536\n   * - OpenAI text-embedding-ada-002: 1536\n   * - Cohere embed-english-v3.0: 1024\n   * - Cohere embed-english-light-v3.0: 384\n   * - Cohere embed-multilingual-v3.0: 1024\n   * - Cohere embed-multilingual-light-v3.0: 384\n   */\n  dims: number;\n\n  /**\n   * The embeddings model to use for generating vectors.\n   * This should be a LangChain Embeddings implementation.\n   */\n  embeddings: Embeddings;\n\n  /**\n   * Fields to extract text from for embedding generation.\n   *\n   * Path syntax supports:\n   * - Simple field access: \"field\"\n   * - Nested fields: \"metadata.title\"\n   * - Array indexing:\n   *   - All elements: \"chapters[*].content\"\n   *   - Specific index: \"authors[0].name\"\n   *   - Last element: \"array[-1]\"\n   *\n   * @default [\"$\"] Embeds the entire document as one vector\n   */\n  fields?: string[];\n}\n\n/**\n * Utility function to get text at a specific JSON path\n */\nexport function getTextAtPath(obj: any, path: string): string[] {\n  const parts = path.split(\".\");\n  let current: any = obj;\n\n  for (const part of parts) {\n    if (part.includes(\"[\")) {\n      const [arrayName, indexStr] = part.split(\"[\");\n      const index = indexStr.replace(\"]\", \"\");\n\n      if (!current[arrayName]) return [];\n\n      if (index === \"*\") {\n        const results: string[] = [];\n        for (const item of current[arrayName]) {\n          if (typeof item === \"string\") results.push(item);\n        }\n        return results;\n      }\n\n      const idx = parseInt(index, 10);\n      if (Number.isNaN(idx)) return [];\n      current = current[arrayName][idx];\n    } else {\n      current = current[part];\n    }\n\n    if (current === undefined) return [];\n  }\n\n  return typeof current === \"string\" ? [current] : [];\n}\n\n/**\n * Tokenizes a JSON path into parts\n */\nexport function tokenizePath(path: string): string[] {\n  return path.split(\".\");\n}\n\n/**\n * Abstract base class for persistent key-value stores.\n *\n * Stores enable persistence and memory that can be shared across threads,\n * scoped to user IDs, assistant IDs, or other arbitrary namespaces.\n *\n * Features:\n * - Hierarchical namespaces for organization\n * - Key-value storage with metadata\n * - Vector similarity search (if configured)\n * - Filtering and pagination\n */\nexport abstract class BaseStore {\n  /**\n   * Execute multiple operations in a single batch.\n   * This is more efficient than executing operations individually.\n   *\n   * @param operations Array of operations to execute\n   * @returns Promise resolving to results matching the operations\n   */\n  abstract batch<Op extends Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>>;\n\n  /**\n   * Retrieve a single item by its namespace and key.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @returns Promise resolving to the item or null if not found\n   */\n  async get(namespace: string[], key: string): Promise<Item | null> {\n    return (await this.batch<[GetOperation]>([{ namespace, key }]))[0];\n  }\n\n  /**\n   * Search for items within a namespace prefix.\n   * Supports both metadata filtering and vector similarity search.\n   *\n   * @param namespacePrefix Hierarchical path prefix to search within\n   * @param options Search options for filtering and pagination\n   * @returns Promise resolving to list of matching items with relevance scores\n   *\n   * @example\n   * // Search with filters\n   * await store.search([\"documents\"], {\n   *   filter: { type: \"report\", status: \"active\" },\n   *   limit: 5,\n   *   offset: 10\n   * });\n   *\n   * // Vector similarity search\n   * await store.search([\"users\", \"content\"], {\n   *   query: \"technical documentation about APIs\",\n   *   limit: 20\n   * });\n   */\n  async search(\n    namespacePrefix: string[],\n    options: {\n      filter?: Record<string, any>;\n      limit?: number;\n      offset?: number;\n      query?: string;\n    } = {}\n  ): Promise<SearchItem[]> {\n    const { filter, limit = 10, offset = 0, query } = options;\n    return (\n      await this.batch<[SearchOperation]>([\n        {\n          namespacePrefix,\n          filter,\n          limit,\n          offset,\n          query,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Store or update an item.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @param value Object containing the item's data\n   * @param index Optional indexing configuration\n   *\n   * @example\n   * // Simple storage\n   * await store.put([\"docs\"], \"report\", { title: \"Annual Report\" });\n   *\n   * // With specific field indexing\n   * await store.put(\n   *   [\"docs\"],\n   *   \"report\",\n   *   {\n   *     title: \"Q4 Report\",\n   *     chapters: [{ content: \"...\" }, { content: \"...\" }]\n   *   },\n   *   [\"title\", \"chapters[*].content\"]\n   * );\n   */\n  async put(\n    namespace: string[],\n    key: string,\n    value: Record<string, any>,\n    index?: false | string[]\n  ): Promise<void> {\n    validateNamespace(namespace);\n    await this.batch<[PutOperation]>([{ namespace, key, value, index }]);\n  }\n\n  /**\n   * Delete an item from the store.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   */\n  async delete(namespace: string[], key: string): Promise<void> {\n    await this.batch<[PutOperation]>([{ namespace, key, value: null }]);\n  }\n\n  /**\n   * List and filter namespaces in the store.\n   * Used to explore data organization and navigate the namespace hierarchy.\n   *\n   * @param options Options for listing namespaces\n   * @returns Promise resolving to list of namespace paths\n   *\n   * @example\n   * // List all namespaces under \"documents\"\n   * await store.listNamespaces({\n   *   prefix: [\"documents\"],\n   *   maxDepth: 2\n   * });\n   *\n   * // List namespaces ending with \"v1\"\n   * await store.listNamespaces({\n   *   suffix: [\"v1\"],\n   *   limit: 50\n   * });\n   */\n  async listNamespaces(\n    options: {\n      prefix?: string[];\n      suffix?: string[];\n      maxDepth?: number;\n      limit?: number;\n      offset?: number;\n    } = {}\n  ): Promise<string[][]> {\n    const { prefix, suffix, maxDepth, limit = 100, offset = 0 } = options;\n\n    const matchConditions: MatchCondition[] = [];\n    if (prefix) {\n      matchConditions.push({ matchType: \"prefix\", path: prefix });\n    }\n    if (suffix) {\n      matchConditions.push({ matchType: \"suffix\", path: suffix });\n    }\n\n    return (\n      await this.batch<[ListNamespacesOperation]>([\n        {\n          matchConditions: matchConditions.length ? matchConditions : undefined,\n          maxDepth,\n          limit,\n          offset,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Start the store. Override if initialization is needed.\n   */\n  start(): void | Promise<void> {}\n\n  /**\n   * Stop the store. Override if cleanup is needed.\n   */\n  stop(): void | Promise<void> {}\n}\n"],"mappings":"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"}
+{"version":3,"file":"base.cjs","names":[],"sources":["../../src/store/base.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Embeddings } from \"@langchain/core/embeddings\";\n\n/**\n * Error thrown when an invalid namespace is provided.\n */\nexport class InvalidNamespaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"InvalidNamespaceError\";\n  }\n}\n\n/**\n * Validates the provided namespace.\n * @param namespace The namespace to validate.\n * @param options.allowEmpty When true, an empty namespace is permitted\n *   (`search([])` means \"search everything\"). Put still rejects empty.\n * @param options.allowReservedRoot When true, the `langgraph` root label is\n *   permitted. Put still rejects it; search may read a namespace written via\n *   `batch()` which bypasses put validation.\n * @throws {InvalidNamespaceError} If the namespace is invalid.\n */\nexport function validateNamespace(\n  namespace: string[],\n  options: { allowEmpty?: boolean; allowReservedRoot?: boolean } = {}\n): void {\n  if (namespace.length === 0) {\n    if (options.allowEmpty) {\n      return;\n    }\n    throw new InvalidNamespaceError(\"Namespace cannot be empty.\");\n  }\n  for (const label of namespace) {\n    if (typeof label !== \"string\") {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels ` +\n          `must be strings, but got ${typeof label}.`\n      );\n    }\n    if (label.includes(\".\")) {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels cannot contain periods ('.').`\n      );\n    }\n    if (label === \"\") {\n      throw new InvalidNamespaceError(\n        `Namespace labels cannot be empty strings. Got ${label} in ${namespace}`\n      );\n    }\n  }\n\n  if (namespace[0] === \"langgraph\" && !options.allowReservedRoot) {\n    throw new InvalidNamespaceError(\n      `Root label for namespace cannot be \"langgraph\". Got: ${namespace}`\n    );\n  }\n}\n\n/**\n * Represents a stored item with metadata.\n */\nexport interface Item {\n  /**\n   * The stored data as an object. Keys are filterable.\n   */\n  value: Record<string, any>;\n  /**\n   * Unique identifier within the namespace.\n   */\n  key: string;\n  /**\n   * Hierarchical path defining the collection in which this document resides.\n   * Represented as an array of strings, allowing for nested categorization.\n   * For example: [\"documents\", \"user123\"]\n   */\n  namespace: string[];\n  /**\n   * Timestamp of item creation.\n   */\n  createdAt: Date;\n  /**\n   * Timestamp of last update.\n   */\n  updatedAt: Date;\n}\n\n/**\n * Represents a search result item with relevance score.\n * Extends the base Item interface with an optional similarity score.\n */\nexport interface SearchItem extends Item {\n  /**\n   * Relevance/similarity score if from a ranked operation.\n   * Higher scores indicate better matches.\n   *\n   * This is typically a cosine similarity score between -1 and 1,\n   * where 1 indicates identical vectors and -1 indicates opposite vectors.\n   */\n  score?: number;\n}\n\n/**\n * Operation to retrieve an item by namespace and ID.\n */\nexport interface GetOperation {\n  /**\n   * Hierarchical path for the item.\n   *\n   * @example\n   * // Get a user profile\n   * namespace: [\"users\", \"profiles\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier within the namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * @example\n   * key: \"user123\"  // For a user profile\n   * key: \"doc456\"   // For a document\n   */\n  key: string;\n}\n\n/**\n * Operation to search for items within a namespace prefix.\n */\nexport interface SearchOperation {\n  /**\n   * Hierarchical path prefix to search within.\n   * Only items under this prefix will be searched.\n   *\n   * @example\n   * // Search all user documents\n   * namespacePrefix: [\"users\", \"documents\"]\n   *\n   * // Search everything\n   * namespacePrefix: []\n   */\n  namespacePrefix: string[];\n\n  /**\n   * Key-value pairs to filter results based on exact matches or comparison operators.\n   *\n   * Supports both exact matches and operator-based comparisons:\n   * - $eq: Equal to (same as direct value comparison)\n   * - $ne: Not equal to\n   * - $gt: Greater than\n   * - $gte: Greater than or equal to\n   * - $lt: Less than\n   * - $lte: Less than or equal to\n   *\n   * @example\n   * // Exact match\n   * filter: { status: \"active\" }\n   *\n   * // With operators\n   * filter: { score: { $gt: 4.99 } }\n   *\n   * // Multiple conditions\n   * filter: {\n   *   score: { $gte: 3.0 },\n   *   color: \"red\"\n   * }\n   */\n  filter?: Record<string, any>;\n\n  /**\n   * Maximum number of items to return.\n   * @default 10\n   */\n  limit?: number;\n\n  /**\n   * Number of items to skip before returning results.\n   * Useful for pagination.\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Natural language search query for semantic search.\n   * When provided, results will be ranked by relevance to this query\n   * using vector similarity search.\n   *\n   * @example\n   * // Find technical documentation about APIs\n   * query: \"technical documentation about REST APIs\"\n   *\n   * // Find recent ML papers\n   * query: \"machine learning papers from 2023\"\n   */\n  query?: string;\n}\n\n/**\n * Operation to store, update, or delete an item.\n */\nexport interface PutOperation {\n  /**\n   * Hierarchical path for the item.\n   * Acts as a folder-like structure to organize items.\n   * Each element represents one level in the hierarchy.\n   *\n   * @example\n   * // Root level documents\n   * namespace: [\"documents\"]\n   *\n   * // User-specific documents\n   * namespace: [\"documents\", \"user123\"]\n   *\n   * // Nested cache structure\n   * namespace: [\"cache\", \"docs\", \"v1\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier for the document within its namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * Example: If namespace is [\"documents\", \"user123\"] and key is \"report1\",\n   * the full path would effectively be \"documents/user123/report1\"\n   */\n  key: string;\n\n  /**\n   * Data to be stored, or null to delete the item.\n   * Must be a JSON-serializable object with string keys.\n   * Setting to null signals that the item should be deleted.\n   *\n   * @example\n   * {\n   *   field1: \"string value\",\n   *   field2: 123,\n   *   nested: { can: \"contain\", any: \"serializable data\" }\n   * }\n   */\n  value: Record<string, any> | null;\n\n  /**\n   * Controls how the item's fields are indexed for search operations.\n   *\n   * - undefined: Uses store's default indexing configuration\n   * - false: Disables indexing for this item\n   * - string[]: List of field paths to index\n   *\n   * Path syntax supports:\n   * - Nested fields: \"metadata.title\"\n   * - Array access: \"chapters[*].content\" (each indexed separately)\n   * - Specific indices: \"authors[0].name\"\n   *\n   * @example\n   * // Index specific fields\n   * index: [\"metadata.title\", \"chapters[*].content\"]\n   *\n   * // Disable indexing\n   * index: false\n   */\n  index?: false | string[];\n}\n\n/**\n * Operation to list and filter namespaces in the store.\n */\nexport interface ListNamespacesOperation {\n  matchConditions?: MatchCondition[];\n  maxDepth?: number;\n  limit: number;\n  offset: number;\n}\n\nexport type NameSpacePath = (string | \"*\")[];\n\nexport type NamespaceMatchType = \"prefix\" | \"suffix\";\n\nexport interface MatchCondition {\n  matchType: NamespaceMatchType;\n  path: NameSpacePath;\n}\n\nexport type Operation =\n  | GetOperation\n  | SearchOperation\n  | PutOperation\n  | ListNamespacesOperation;\n\nexport type OperationResults<Tuple extends readonly Operation[]> = {\n  [K in keyof Tuple]: Tuple[K] extends PutOperation\n    ? void\n    : Tuple[K] extends SearchOperation\n      ? SearchItem[]\n      : Tuple[K] extends GetOperation\n        ? Item | null\n        : Tuple[K] extends ListNamespacesOperation\n          ? string[][]\n          : never;\n};\n\n/**\n * Configuration for indexing documents for semantic search in the store.\n *\n * This configures how documents are embedded and indexed for vector similarity search.\n */\nexport interface IndexConfig {\n  /**\n   * Number of dimensions in the embedding vectors.\n   *\n   * Common embedding model dimensions:\n   * - OpenAI text-embedding-3-large: 256, 1024, or 3072\n   * - OpenAI text-embedding-3-small: 512 or 1536\n   * - OpenAI text-embedding-ada-002: 1536\n   * - Cohere embed-english-v3.0: 1024\n   * - Cohere embed-english-light-v3.0: 384\n   * - Cohere embed-multilingual-v3.0: 1024\n   * - Cohere embed-multilingual-light-v3.0: 384\n   */\n  dims: number;\n\n  /**\n   * The embeddings model to use for generating vectors.\n   * This should be a LangChain Embeddings implementation.\n   */\n  embeddings: Embeddings;\n\n  /**\n   * Fields to extract text from for embedding generation.\n   *\n   * Path syntax supports:\n   * - Simple field access: \"field\"\n   * - Nested fields: \"metadata.title\"\n   * - Array indexing:\n   *   - All elements: \"chapters[*].content\"\n   *   - Specific index: \"authors[0].name\"\n   *   - Last element: \"array[-1]\"\n   *\n   * @default [\"$\"] Embeds the entire document as one vector\n   */\n  fields?: string[];\n}\n\n/**\n * Utility function to get text at a specific JSON path\n */\nexport function getTextAtPath(obj: any, path: string): string[] {\n  const parts = path.split(\".\");\n  let current: any = obj;\n\n  for (const part of parts) {\n    if (part.includes(\"[\")) {\n      const [arrayName, indexStr] = part.split(\"[\");\n      const index = indexStr.replace(\"]\", \"\");\n\n      if (!current[arrayName]) return [];\n\n      if (index === \"*\") {\n        const results: string[] = [];\n        for (const item of current[arrayName]) {\n          if (typeof item === \"string\") results.push(item);\n        }\n        return results;\n      }\n\n      const idx = parseInt(index, 10);\n      if (Number.isNaN(idx)) return [];\n      current = current[arrayName][idx];\n    } else {\n      current = current[part];\n    }\n\n    if (current === undefined) return [];\n  }\n\n  return typeof current === \"string\" ? [current] : [];\n}\n\n/**\n * Tokenizes a JSON path into parts\n */\nexport function tokenizePath(path: string): string[] {\n  return path.split(\".\");\n}\n\n/**\n * Abstract base class for persistent key-value stores.\n *\n * Stores enable persistence and memory that can be shared across threads,\n * scoped to user IDs, assistant IDs, or other arbitrary namespaces.\n *\n * Features:\n * - Hierarchical namespaces for organization\n * - Key-value storage with metadata\n * - Vector similarity search (if configured)\n * - Filtering and pagination\n */\nexport abstract class BaseStore {\n  /**\n   * Execute multiple operations in a single batch.\n   * This is more efficient than executing operations individually.\n   *\n   * @param operations Array of operations to execute\n   * @returns Promise resolving to results matching the operations\n   */\n  abstract batch<Op extends Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>>;\n\n  /**\n   * Retrieve a single item by its namespace and key.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @returns Promise resolving to the item or null if not found\n   */\n  async get(namespace: string[], key: string): Promise<Item | null> {\n    return (await this.batch<[GetOperation]>([{ namespace, key }]))[0];\n  }\n\n  /**\n   * Search for items within a namespace prefix.\n   * Supports both metadata filtering and vector similarity search.\n   *\n   * @param namespacePrefix Hierarchical path prefix to search within\n   * @param options Search options for filtering and pagination\n   * @returns Promise resolving to list of matching items with relevance scores\n   *\n   * @example\n   * // Search with filters\n   * await store.search([\"documents\"], {\n   *   filter: { type: \"report\", status: \"active\" },\n   *   limit: 5,\n   *   offset: 10\n   * });\n   *\n   * // Vector similarity search\n   * await store.search([\"users\", \"content\"], {\n   *   query: \"technical documentation about APIs\",\n   *   limit: 20\n   * });\n   */\n  async search(\n    namespacePrefix: string[],\n    options: {\n      filter?: Record<string, any>;\n      limit?: number;\n      offset?: number;\n      query?: string;\n    } = {}\n  ): Promise<SearchItem[]> {\n    validateNamespace(namespacePrefix, {\n      allowEmpty: true,\n      allowReservedRoot: true,\n    });\n    const { filter, limit = 10, offset = 0, query } = options;\n    return (\n      await this.batch<[SearchOperation]>([\n        {\n          namespacePrefix,\n          filter,\n          limit,\n          offset,\n          query,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Store or update an item.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @param value Object containing the item's data\n   * @param index Optional indexing configuration\n   *\n   * @example\n   * // Simple storage\n   * await store.put([\"docs\"], \"report\", { title: \"Annual Report\" });\n   *\n   * // With specific field indexing\n   * await store.put(\n   *   [\"docs\"],\n   *   \"report\",\n   *   {\n   *     title: \"Q4 Report\",\n   *     chapters: [{ content: \"...\" }, { content: \"...\" }]\n   *   },\n   *   [\"title\", \"chapters[*].content\"]\n   * );\n   */\n  async put(\n    namespace: string[],\n    key: string,\n    value: Record<string, any>,\n    index?: false | string[]\n  ): Promise<void> {\n    validateNamespace(namespace);\n    await this.batch<[PutOperation]>([{ namespace, key, value, index }]);\n  }\n\n  /**\n   * Delete an item from the store.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   */\n  async delete(namespace: string[], key: string): Promise<void> {\n    await this.batch<[PutOperation]>([{ namespace, key, value: null }]);\n  }\n\n  /**\n   * List and filter namespaces in the store.\n   * Used to explore data organization and navigate the namespace hierarchy.\n   *\n   * @param options Options for listing namespaces\n   * @returns Promise resolving to list of namespace paths\n   *\n   * @example\n   * // List all namespaces under \"documents\"\n   * await store.listNamespaces({\n   *   prefix: [\"documents\"],\n   *   maxDepth: 2\n   * });\n   *\n   * // List namespaces ending with \"v1\"\n   * await store.listNamespaces({\n   *   suffix: [\"v1\"],\n   *   limit: 50\n   * });\n   */\n  async listNamespaces(\n    options: {\n      prefix?: string[];\n      suffix?: string[];\n      maxDepth?: number;\n      limit?: number;\n      offset?: number;\n    } = {}\n  ): Promise<string[][]> {\n    const { prefix, suffix, maxDepth, limit = 100, offset = 0 } = options;\n\n    const matchConditions: MatchCondition[] = [];\n    if (prefix) {\n      matchConditions.push({ matchType: \"prefix\", path: prefix });\n    }\n    if (suffix) {\n      matchConditions.push({ matchType: \"suffix\", path: suffix });\n    }\n\n    return (\n      await this.batch<[ListNamespacesOperation]>([\n        {\n          matchConditions: matchConditions.length ? matchConditions : undefined,\n          maxDepth,\n          limit,\n          offset,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Start the store. Override if initialization is needed.\n   */\n  start(): void | Promise<void> {}\n\n  /**\n   * Stop the store. Override if cleanup is needed.\n   */\n  stop(): void | Promise<void> {}\n}\n"],"mappings":"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"}

package/dist/store/base.d.cts

@@ -7,6 +7,20 @@ import { Embeddings } from "@langchain/core/embeddings";
 declare class InvalidNamespaceError extends Error {
   constructor(message: string);
 }
+/**
+ * Validates the provided namespace.
+ * @param namespace The namespace to validate.
+ * @param options.allowEmpty When true, an empty namespace is permitted
+ *   (`search([])` means "search everything"). Put still rejects empty.
+ * @param options.allowReservedRoot When true, the `langgraph` root label is
+ *   permitted. Put still rejects it; search may read a namespace written via
+ *   `batch()` which bypasses put validation.
+ * @throws {InvalidNamespaceError} If the namespace is invalid.
+ */
+declare function validateNamespace(namespace: string[], options?: {
+  allowEmpty?: boolean;
+  allowReservedRoot?: boolean;
+}): void;
 /**
  * Represents a stored item with metadata.
  */
@@ -387,5 +401,5 @@ declare abstract class BaseStore {
   stop(): void | Promise<void>;
 }
 //#endregion
-export { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath };
+export { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath, validateNamespace };
 //# sourceMappingURL=base.d.cts.map

package/dist/store/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/store/base.ts"],"mappings":";;;;;AAMA;cAAa,qBAAA,SAA8B,KAAA;EACzC,WAAA,CAAY,OAAA;AAAA;;;;UA2CG,IAAA;EA3CY;AA2C7B;;EAIE,KAAA,EAAO,MAAA;EAAA;;;EAIP,GAAA;EAce;;;;;EARf,SAAA;EAIW;;;EAAX,SAAA,EAAW,IAAA;EAII;AAOjB;;EAPE,SAAA,EAAW,IAAA;AAAA;;AAqBb;;;UAdiB,UAAA,SAAmB,IAAA;EAgC/B;AAML;;;;;;EA9BE,KAAA;AAAA;;;;UAMe,YAAA;EA+FA;;;;;;;EAvFf,SAAA;EAmJA;;;AAMF;;;;;EA/IE,GAAA;AAAA;;;;UAMe,eAAA;EAgJL;;;;;AAEZ;;;;;AAEA;EAxIE,eAAA;;;;;;;;;AA6IF;;;;;;;;;;;;;;;AAMA;EAzHE,MAAA,GAAS,MAAA;EAyHiB;;;;EAnH1B,KAAA;EAoHqC;;;;;EA7GrC,MAAA;EAiHY;;;;;;;;;;;;EAnGZ,KAAA;AAAA;;;;UAMe,YAAA;EA4FT;;;;;;;;;;AAaR;;;;;EAzFE,SAAA;EA4GY;;;;AAqBd;;;EAxHE,GAAA;EAwHkD;AAmCpD;;;;;AAgBA;;;;;;EA7JE,KAAA,EAAO,MAAA;EAuKJ;;;;;;;;;;;;;;;;;;;EAlJH,KAAA;AAAA;;;;UAMe,uBAAA;EACf,eAAA,GAAkB,cAAA;EAClB,QAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,KAGU,aAAA;AAAA,KAEA,kBAAA;AAAA,UAEK,cAAA;EACf,SAAA,EAAW,kBAAA;EACX,IAAA,EAAM,aAAA;AAAA;AAAA,KAGI,SAAA,GACR,YAAA,GACA,eAAA,GACA,YAAA,GACA,uBAAA;AAAA,KAEQ,gBAAA,wBAAwC,SAAA,oBACtC,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,YAAA,UAEjC,KAAA,CAAM,CAAA,UAAW,eAAA,GACf,UAAA,KACA,KAAA,CAAM,CAAA,UAAW,YAAA,GACf,IAAA,UACA,KAAA,CAAM,CAAA,UAAW,uBAAA;;;;;;UAUV,WAAA;EAsMmB;;;;;;;;;;;;EAzLlC,IAAA;EAwPe;;;;EAlPf,UAAA,EAAY,UAAA;;;;;;;;;;;;;;EAeZ,MAAA;AAAA;;;;iBAMc,aAAA,CAAc,GAAA,OAAU,IAAA;;;;iBAmCxB,YAAA,CAAa,IAAA;;;;;;;;;;;;;uBAgBP,SAAA;;;;;;;;WAQX,KAAA,YAAiB,SAAA,GAAA,CACxB,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;;;;;;;;EAStB,GAAA,CAAI,SAAA,YAAqB,GAAA,WAAc,OAAA,CAAQ,IAAA;;;;;;;;;;;;;;;;;;;;;;;EA0B/C,MAAA,CACJ,eAAA,YACA,OAAA;IACE,MAAA,GAAS,MAAA;IACT,KAAA;IACA,MAAA;IACA,KAAA;EAAA,IAED,OAAA,CAAQ,UAAA;;;;;;;;;;;;;;;;;;;;;;;;EAsCL,GAAA,CACJ,SAAA,YACA,GAAA,UACA,KAAA,EAAO,MAAA,eACP,KAAA,sBACC,OAAA;;;;;;;EAWG,MAAA,CAAO,SAAA,YAAqB,GAAA,WAAc,OAAA;;;;;;;;;;;;;;;;;;;;;EAwB1C,cAAA,CACJ,OAAA;IACE,MAAA;IACA,MAAA;IACA,QAAA;IACA,KAAA;IACA,MAAA;EAAA,IAED,OAAA;;;;EA0BH,KAAA,CAAA,UAAgB,OAAA;;;;EAKhB,IAAA,CAAA,UAAe,OAAA;AAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/store/base.ts"],"mappings":";;;;;AAMA;cAAa,qBAAA,SAA8B,KAAA;EACzC,WAAA,CAAY,OAAA;AAAA;;;;;;AAgBd;;;;;iBAAgB,iBAAA,CACd,SAAA,YACA,OAAA;EAAW,UAAA;EAAsB,iBAAA;AAAA;;AAqCnC;;UAAiB,IAAA;EAIR;;;EAAP,KAAA,EAAO,MAAA;EAkBQ;;;EAdf,GAAA;EAMA;;;;;EAAA,SAAA;EAQe;AAOjB;;EAXE,SAAA,EAAW,IAAA;EAWuB;;AAcpC;EArBE,SAAA,EAAW,IAAA;AAAA;;;AA6Cb;;UAtCiB,UAAA,SAAmB,IAAA;EA4EnB;;;;;;;EApEf,KAAA;AAAA;AAqGF;;;AAAA,UA/FiB,YAAA;EA+Gf;;;;;;;EAvGA,SAAA;EAyJsC;;;;;;;;EA/ItC,GAAA;AAAA;AAsJF;;;AAAA,UAhJiB,eAAA;EAgJQ;AAEzB;;;;;AAEA;;;;;EAxIE,eAAA;EA0IA;;;;AAGF;;;;;;;;;;;;;;;AAMA;;;;;EAzHE,MAAA,GAAS,MAAA;EA0HiB;;;;EApH1B,KAAA;EAuHM;;;;;EAhHN,MAAA;EAmHc;;;;;;;;;;;;EArGd,KAAA;AAAA;;;;UAMe,YAAA;EA8FP;;;;;;AAWV;;;;;;;;;EAzFE,SAAA;EAiIc;;;;;AAmChB;;EA3JE,GAAA;EA2J2B;;AAgB7B;;;;;;;;;;EA7JE,KAAA,EAAO,MAAA;EAkNI;;;;;;;;;;;;;;;;;;;EA7LX,KAAA;AAAA;;;;UAMe,uBAAA;EACf,eAAA,GAAkB,cAAA;EAClB,QAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,KAGU,aAAA;AAAA,KAEA,kBAAA;AAAA,UAEK,cAAA;EACf,SAAA,EAAW,kBAAA;EACX,IAAA,EAAM,aAAA;AAAA;AAAA,KAGI,SAAA,GACR,YAAA,GACA,eAAA,GACA,YAAA,GACA,uBAAA;AAAA,KAEQ,gBAAA,wBAAwC,SAAA,oBACtC,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,YAAA,UAEjC,KAAA,CAAM,CAAA,UAAW,eAAA,GACf,UAAA,KACA,KAAA,CAAM,CAAA,UAAW,YAAA,GACf,IAAA,UACA,KAAA,CAAM,CAAA,UAAW,uBAAA;;;;;;UAUV,WAAA;EAqOX;;;;;;;;;;;;EAxNJ,IAAA;;;;;EAMA,UAAA,EAAY,UAAA;;;;;;;;;;;;;;EAeZ,MAAA;AAAA;;;;iBAMc,aAAA,CAAc,GAAA,OAAU,IAAA;;;;iBAmCxB,YAAA,CAAa,IAAA;;;;;;;;;;;;;uBAgBP,SAAA;;;;;;;;WAQX,KAAA,YAAiB,SAAA,GAAA,CACxB,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;;;;;;;;EAStB,GAAA,CAAI,SAAA,YAAqB,GAAA,WAAc,OAAA,CAAQ,IAAA;;;;;;;;;;;;;;;;;;;;;;;EA0B/C,MAAA,CACJ,eAAA,YACA,OAAA;IACE,MAAA,GAAS,MAAA;IACT,KAAA;IACA,MAAA;IACA,KAAA;EAAA,IAED,OAAA,CAAQ,UAAA;;;;;;;;;;;;;;;;;;;;;;;;EA0CL,GAAA,CACJ,SAAA,YACA,GAAA,UACA,KAAA,EAAO,MAAA,eACP,KAAA,sBACC,OAAA;;;;;;;EAWG,MAAA,CAAO,SAAA,YAAqB,GAAA,WAAc,OAAA;;;;;;;;;;;;;;;;;;;;;EAwB1C,cAAA,CACJ,OAAA;IACE,MAAA;IACA,MAAA;IACA,QAAA;IACA,KAAA;IACA,MAAA;EAAA,IAED,OAAA;;;;EA0BH,KAAA,CAAA,UAAgB,OAAA;;;;EAKhB,IAAA,CAAA,UAAe,OAAA;AAAA"}

package/dist/store/base.d.ts

@@ -7,6 +7,20 @@ import { Embeddings } from "@langchain/core/embeddings";
 declare class InvalidNamespaceError extends Error {
   constructor(message: string);
 }
+/**
+ * Validates the provided namespace.
+ * @param namespace The namespace to validate.
+ * @param options.allowEmpty When true, an empty namespace is permitted
+ *   (`search([])` means "search everything"). Put still rejects empty.
+ * @param options.allowReservedRoot When true, the `langgraph` root label is
+ *   permitted. Put still rejects it; search may read a namespace written via
+ *   `batch()` which bypasses put validation.
+ * @throws {InvalidNamespaceError} If the namespace is invalid.
+ */
+declare function validateNamespace(namespace: string[], options?: {
+  allowEmpty?: boolean;
+  allowReservedRoot?: boolean;
+}): void;
 /**
  * Represents a stored item with metadata.
  */
@@ -387,5 +401,5 @@ declare abstract class BaseStore {
   stop(): void | Promise<void>;
 }
 //#endregion
-export { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath };
+export { BaseStore, GetOperation, IndexConfig, InvalidNamespaceError, Item, ListNamespacesOperation, MatchCondition, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchItem, SearchOperation, getTextAtPath, tokenizePath, validateNamespace };
 //# sourceMappingURL=base.d.ts.map

package/dist/store/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/store/base.ts"],"mappings":";;;;;AAMA;cAAa,qBAAA,SAA8B,KAAA;EACzC,WAAA,CAAY,OAAA;AAAA;;;;UA2CG,IAAA;EA3CY;AA2C7B;;EAIE,KAAA,EAAO,MAAA;EAAA;;;EAIP,GAAA;EAce;;;;;EARf,SAAA;EAIW;;;EAAX,SAAA,EAAW,IAAA;EAII;AAOjB;;EAPE,SAAA,EAAW,IAAA;AAAA;;AAqBb;;;UAdiB,UAAA,SAAmB,IAAA;EAgC/B;AAML;;;;;;EA9BE,KAAA;AAAA;;;;UAMe,YAAA;EA+FA;;;;;;;EAvFf,SAAA;EAmJA;;;AAMF;;;;;EA/IE,GAAA;AAAA;;;;UAMe,eAAA;EAgJL;;;;;AAEZ;;;;;AAEA;EAxIE,eAAA;;;;;;;;;AA6IF;;;;;;;;;;;;;;;AAMA;EAzHE,MAAA,GAAS,MAAA;EAyHiB;;;;EAnH1B,KAAA;EAoHqC;;;;;EA7GrC,MAAA;EAiHY;;;;;;;;;;;;EAnGZ,KAAA;AAAA;;;;UAMe,YAAA;EA4FT;;;;;;;;;;AAaR;;;;;EAzFE,SAAA;EA4GY;;;;AAqBd;;;EAxHE,GAAA;EAwHkD;AAmCpD;;;;;AAgBA;;;;;;EA7JE,KAAA,EAAO,MAAA;EAuKJ;;;;;;;;;;;;;;;;;;;EAlJH,KAAA;AAAA;;;;UAMe,uBAAA;EACf,eAAA,GAAkB,cAAA;EAClB,QAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,KAGU,aAAA;AAAA,KAEA,kBAAA;AAAA,UAEK,cAAA;EACf,SAAA,EAAW,kBAAA;EACX,IAAA,EAAM,aAAA;AAAA;AAAA,KAGI,SAAA,GACR,YAAA,GACA,eAAA,GACA,YAAA,GACA,uBAAA;AAAA,KAEQ,gBAAA,wBAAwC,SAAA,oBACtC,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,YAAA,UAEjC,KAAA,CAAM,CAAA,UAAW,eAAA,GACf,UAAA,KACA,KAAA,CAAM,CAAA,UAAW,YAAA,GACf,IAAA,UACA,KAAA,CAAM,CAAA,UAAW,uBAAA;;;;;;UAUV,WAAA;EAsMmB;;;;;;;;;;;;EAzLlC,IAAA;EAwPe;;;;EAlPf,UAAA,EAAY,UAAA;;;;;;;;;;;;;;EAeZ,MAAA;AAAA;;;;iBAMc,aAAA,CAAc,GAAA,OAAU,IAAA;;;;iBAmCxB,YAAA,CAAa,IAAA;;;;;;;;;;;;;uBAgBP,SAAA;;;;;;;;WAQX,KAAA,YAAiB,SAAA,GAAA,CACxB,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;;;;;;;;EAStB,GAAA,CAAI,SAAA,YAAqB,GAAA,WAAc,OAAA,CAAQ,IAAA;;;;;;;;;;;;;;;;;;;;;;;EA0B/C,MAAA,CACJ,eAAA,YACA,OAAA;IACE,MAAA,GAAS,MAAA;IACT,KAAA;IACA,MAAA;IACA,KAAA;EAAA,IAED,OAAA,CAAQ,UAAA;;;;;;;;;;;;;;;;;;;;;;;;EAsCL,GAAA,CACJ,SAAA,YACA,GAAA,UACA,KAAA,EAAO,MAAA,eACP,KAAA,sBACC,OAAA;;;;;;;EAWG,MAAA,CAAO,SAAA,YAAqB,GAAA,WAAc,OAAA;;;;;;;;;;;;;;;;;;;;;EAwB1C,cAAA,CACJ,OAAA;IACE,MAAA;IACA,MAAA;IACA,QAAA;IACA,KAAA;IACA,MAAA;EAAA,IAED,OAAA;;;;EA0BH,KAAA,CAAA,UAAgB,OAAA;;;;EAKhB,IAAA,CAAA,UAAe,OAAA;AAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/store/base.ts"],"mappings":";;;;;AAMA;cAAa,qBAAA,SAA8B,KAAA;EACzC,WAAA,CAAY,OAAA;AAAA;;;;;;AAgBd;;;;;iBAAgB,iBAAA,CACd,SAAA,YACA,OAAA;EAAW,UAAA;EAAsB,iBAAA;AAAA;;AAqCnC;;UAAiB,IAAA;EAIR;;;EAAP,KAAA,EAAO,MAAA;EAkBQ;;;EAdf,GAAA;EAMA;;;;;EAAA,SAAA;EAQe;AAOjB;;EAXE,SAAA,EAAW,IAAA;EAWuB;;AAcpC;EArBE,SAAA,EAAW,IAAA;AAAA;;;AA6Cb;;UAtCiB,UAAA,SAAmB,IAAA;EA4EnB;;;;;;;EApEf,KAAA;AAAA;AAqGF;;;AAAA,UA/FiB,YAAA;EA+Gf;;;;;;;EAvGA,SAAA;EAyJsC;;;;;;;;EA/ItC,GAAA;AAAA;AAsJF;;;AAAA,UAhJiB,eAAA;EAgJQ;AAEzB;;;;;AAEA;;;;;EAxIE,eAAA;EA0IA;;;;AAGF;;;;;;;;;;;;;;;AAMA;;;;;EAzHE,MAAA,GAAS,MAAA;EA0HiB;;;;EApH1B,KAAA;EAuHM;;;;;EAhHN,MAAA;EAmHc;;;;;;;;;;;;EArGd,KAAA;AAAA;;;;UAMe,YAAA;EA8FP;;;;;;AAWV;;;;;;;;;EAzFE,SAAA;EAiIc;;;;;AAmChB;;EA3JE,GAAA;EA2J2B;;AAgB7B;;;;;;;;;;EA7JE,KAAA,EAAO,MAAA;EAkNI;;;;;;;;;;;;;;;;;;;EA7LX,KAAA;AAAA;;;;UAMe,uBAAA;EACf,eAAA,GAAkB,cAAA;EAClB,QAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,KAGU,aAAA;AAAA,KAEA,kBAAA;AAAA,UAEK,cAAA;EACf,SAAA,EAAW,kBAAA;EACX,IAAA,EAAM,aAAA;AAAA;AAAA,KAGI,SAAA,GACR,YAAA,GACA,eAAA,GACA,YAAA,GACA,uBAAA;AAAA,KAEQ,gBAAA,wBAAwC,SAAA,oBACtC,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,YAAA,UAEjC,KAAA,CAAM,CAAA,UAAW,eAAA,GACf,UAAA,KACA,KAAA,CAAM,CAAA,UAAW,YAAA,GACf,IAAA,UACA,KAAA,CAAM,CAAA,UAAW,uBAAA;;;;;;UAUV,WAAA;EAqOX;;;;;;;;;;;;EAxNJ,IAAA;;;;;EAMA,UAAA,EAAY,UAAA;;;;;;;;;;;;;;EAeZ,MAAA;AAAA;;;;iBAMc,aAAA,CAAc,GAAA,OAAU,IAAA;;;;iBAmCxB,YAAA,CAAa,IAAA;;;;;;;;;;;;;uBAgBP,SAAA;;;;;;;;WAQX,KAAA,YAAiB,SAAA,GAAA,CACxB,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;;;;;;;;EAStB,GAAA,CAAI,SAAA,YAAqB,GAAA,WAAc,OAAA,CAAQ,IAAA;;;;;;;;;;;;;;;;;;;;;;;EA0B/C,MAAA,CACJ,eAAA,YACA,OAAA;IACE,MAAA,GAAS,MAAA;IACT,KAAA;IACA,MAAA;IACA,KAAA;EAAA,IAED,OAAA,CAAQ,UAAA;;;;;;;;;;;;;;;;;;;;;;;;EA0CL,GAAA,CACJ,SAAA,YACA,GAAA,UACA,KAAA,EAAO,MAAA,eACP,KAAA,sBACC,OAAA;;;;;;;EAWG,MAAA,CAAO,SAAA,YAAqB,GAAA,WAAc,OAAA;;;;;;;;;;;;;;;;;;;;;EAwB1C,cAAA,CACJ,OAAA;IACE,MAAA;IACA,MAAA;IACA,QAAA;IACA,KAAA;IACA,MAAA;EAAA,IAED,OAAA;;;;EA0BH,KAAA,CAAA,UAAgB,OAAA;;;;EAKhB,IAAA,CAAA,UAAe,OAAA;AAAA"}

package/dist/store/base.js

@@ -11,16 +11,24 @@ var InvalidNamespaceError = class extends Error {
 /**
 * Validates the provided namespace.
 * @param namespace The namespace to validate.
+* @param options.allowEmpty When true, an empty namespace is permitted
+*   (`search([])` means "search everything"). Put still rejects empty.
+* @param options.allowReservedRoot When true, the `langgraph` root label is
+*   permitted. Put still rejects it; search may read a namespace written via
+*   `batch()` which bypasses put validation.
 * @throws {InvalidNamespaceError} If the namespace is invalid.
 */
-function validateNamespace(namespace) {
-	if (namespace.length === 0) throw new InvalidNamespaceError("Namespace cannot be empty.");
+function validateNamespace(namespace, options = {}) {
+	if (namespace.length === 0) {
+		if (options.allowEmpty) return;
+		throw new InvalidNamespaceError("Namespace cannot be empty.");
+	}
 	for (const label of namespace) {
 		if (typeof label !== "string") throw new InvalidNamespaceError(`Invalid namespace label '${label}' found in ${namespace}. Namespace labels must be strings, but got ${typeof label}.`);
 		if (label.includes(".")) throw new InvalidNamespaceError(`Invalid namespace label '${label}' found in ${namespace}. Namespace labels cannot contain periods ('.').`);
 		if (label === "") throw new InvalidNamespaceError(`Namespace labels cannot be empty strings. Got ${label} in ${namespace}`);
 	}
-	if (namespace[0] === "langgraph") throw new InvalidNamespaceError(`Root label for namespace cannot be "langgraph". Got: ${namespace}`);
+	if (namespace[0] === "langgraph" && !options.allowReservedRoot) throw new InvalidNamespaceError(`Root label for namespace cannot be "langgraph". Got: ${namespace}`);
 }
 /**
 * Utility function to get text at a specific JSON path
@@ -101,6 +109,10 @@ var BaseStore = class {
 	* });
 	*/
 	async search(namespacePrefix, options = {}) {
+		validateNamespace(namespacePrefix, {
+			allowEmpty: true,
+			allowReservedRoot: true
+		});
 		const { filter, limit = 10, offset = 0, query } = options;
 		return (await this.batch([{
 			namespacePrefix,
@@ -203,6 +215,6 @@ var BaseStore = class {
 	stop() {}
 };
 //#endregion
-export { BaseStore, InvalidNamespaceError, getTextAtPath, tokenizePath };
+export { BaseStore, InvalidNamespaceError, getTextAtPath, tokenizePath, validateNamespace };
 
 //# sourceMappingURL=base.js.map

package/dist/store/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../src/store/base.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Embeddings } from \"@langchain/core/embeddings\";\n\n/**\n * Error thrown when an invalid namespace is provided.\n */\nexport class InvalidNamespaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"InvalidNamespaceError\";\n  }\n}\n\n/**\n * Validates the provided namespace.\n * @param namespace The namespace to validate.\n * @throws {InvalidNamespaceError} If the namespace is invalid.\n */\nfunction validateNamespace(namespace: string[]): void {\n  if (namespace.length === 0) {\n    throw new InvalidNamespaceError(\"Namespace cannot be empty.\");\n  }\n  for (const label of namespace) {\n    if (typeof label !== \"string\") {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels ` +\n          `must be strings, but got ${typeof label}.`\n      );\n    }\n    if (label.includes(\".\")) {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels cannot contain periods ('.').`\n      );\n    }\n    if (label === \"\") {\n      throw new InvalidNamespaceError(\n        `Namespace labels cannot be empty strings. Got ${label} in ${namespace}`\n      );\n    }\n  }\n  if (namespace[0] === \"langgraph\") {\n    throw new InvalidNamespaceError(\n      `Root label for namespace cannot be \"langgraph\". Got: ${namespace}`\n    );\n  }\n}\n\n/**\n * Represents a stored item with metadata.\n */\nexport interface Item {\n  /**\n   * The stored data as an object. Keys are filterable.\n   */\n  value: Record<string, any>;\n  /**\n   * Unique identifier within the namespace.\n   */\n  key: string;\n  /**\n   * Hierarchical path defining the collection in which this document resides.\n   * Represented as an array of strings, allowing for nested categorization.\n   * For example: [\"documents\", \"user123\"]\n   */\n  namespace: string[];\n  /**\n   * Timestamp of item creation.\n   */\n  createdAt: Date;\n  /**\n   * Timestamp of last update.\n   */\n  updatedAt: Date;\n}\n\n/**\n * Represents a search result item with relevance score.\n * Extends the base Item interface with an optional similarity score.\n */\nexport interface SearchItem extends Item {\n  /**\n   * Relevance/similarity score if from a ranked operation.\n   * Higher scores indicate better matches.\n   *\n   * This is typically a cosine similarity score between -1 and 1,\n   * where 1 indicates identical vectors and -1 indicates opposite vectors.\n   */\n  score?: number;\n}\n\n/**\n * Operation to retrieve an item by namespace and ID.\n */\nexport interface GetOperation {\n  /**\n   * Hierarchical path for the item.\n   *\n   * @example\n   * // Get a user profile\n   * namespace: [\"users\", \"profiles\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier within the namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * @example\n   * key: \"user123\"  // For a user profile\n   * key: \"doc456\"   // For a document\n   */\n  key: string;\n}\n\n/**\n * Operation to search for items within a namespace prefix.\n */\nexport interface SearchOperation {\n  /**\n   * Hierarchical path prefix to search within.\n   * Only items under this prefix will be searched.\n   *\n   * @example\n   * // Search all user documents\n   * namespacePrefix: [\"users\", \"documents\"]\n   *\n   * // Search everything\n   * namespacePrefix: []\n   */\n  namespacePrefix: string[];\n\n  /**\n   * Key-value pairs to filter results based on exact matches or comparison operators.\n   *\n   * Supports both exact matches and operator-based comparisons:\n   * - $eq: Equal to (same as direct value comparison)\n   * - $ne: Not equal to\n   * - $gt: Greater than\n   * - $gte: Greater than or equal to\n   * - $lt: Less than\n   * - $lte: Less than or equal to\n   *\n   * @example\n   * // Exact match\n   * filter: { status: \"active\" }\n   *\n   * // With operators\n   * filter: { score: { $gt: 4.99 } }\n   *\n   * // Multiple conditions\n   * filter: {\n   *   score: { $gte: 3.0 },\n   *   color: \"red\"\n   * }\n   */\n  filter?: Record<string, any>;\n\n  /**\n   * Maximum number of items to return.\n   * @default 10\n   */\n  limit?: number;\n\n  /**\n   * Number of items to skip before returning results.\n   * Useful for pagination.\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Natural language search query for semantic search.\n   * When provided, results will be ranked by relevance to this query\n   * using vector similarity search.\n   *\n   * @example\n   * // Find technical documentation about APIs\n   * query: \"technical documentation about REST APIs\"\n   *\n   * // Find recent ML papers\n   * query: \"machine learning papers from 2023\"\n   */\n  query?: string;\n}\n\n/**\n * Operation to store, update, or delete an item.\n */\nexport interface PutOperation {\n  /**\n   * Hierarchical path for the item.\n   * Acts as a folder-like structure to organize items.\n   * Each element represents one level in the hierarchy.\n   *\n   * @example\n   * // Root level documents\n   * namespace: [\"documents\"]\n   *\n   * // User-specific documents\n   * namespace: [\"documents\", \"user123\"]\n   *\n   * // Nested cache structure\n   * namespace: [\"cache\", \"docs\", \"v1\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier for the document within its namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * Example: If namespace is [\"documents\", \"user123\"] and key is \"report1\",\n   * the full path would effectively be \"documents/user123/report1\"\n   */\n  key: string;\n\n  /**\n   * Data to be stored, or null to delete the item.\n   * Must be a JSON-serializable object with string keys.\n   * Setting to null signals that the item should be deleted.\n   *\n   * @example\n   * {\n   *   field1: \"string value\",\n   *   field2: 123,\n   *   nested: { can: \"contain\", any: \"serializable data\" }\n   * }\n   */\n  value: Record<string, any> | null;\n\n  /**\n   * Controls how the item's fields are indexed for search operations.\n   *\n   * - undefined: Uses store's default indexing configuration\n   * - false: Disables indexing for this item\n   * - string[]: List of field paths to index\n   *\n   * Path syntax supports:\n   * - Nested fields: \"metadata.title\"\n   * - Array access: \"chapters[*].content\" (each indexed separately)\n   * - Specific indices: \"authors[0].name\"\n   *\n   * @example\n   * // Index specific fields\n   * index: [\"metadata.title\", \"chapters[*].content\"]\n   *\n   * // Disable indexing\n   * index: false\n   */\n  index?: false | string[];\n}\n\n/**\n * Operation to list and filter namespaces in the store.\n */\nexport interface ListNamespacesOperation {\n  matchConditions?: MatchCondition[];\n  maxDepth?: number;\n  limit: number;\n  offset: number;\n}\n\nexport type NameSpacePath = (string | \"*\")[];\n\nexport type NamespaceMatchType = \"prefix\" | \"suffix\";\n\nexport interface MatchCondition {\n  matchType: NamespaceMatchType;\n  path: NameSpacePath;\n}\n\nexport type Operation =\n  | GetOperation\n  | SearchOperation\n  | PutOperation\n  | ListNamespacesOperation;\n\nexport type OperationResults<Tuple extends readonly Operation[]> = {\n  [K in keyof Tuple]: Tuple[K] extends PutOperation\n    ? void\n    : Tuple[K] extends SearchOperation\n      ? SearchItem[]\n      : Tuple[K] extends GetOperation\n        ? Item | null\n        : Tuple[K] extends ListNamespacesOperation\n          ? string[][]\n          : never;\n};\n\n/**\n * Configuration for indexing documents for semantic search in the store.\n *\n * This configures how documents are embedded and indexed for vector similarity search.\n */\nexport interface IndexConfig {\n  /**\n   * Number of dimensions in the embedding vectors.\n   *\n   * Common embedding model dimensions:\n   * - OpenAI text-embedding-3-large: 256, 1024, or 3072\n   * - OpenAI text-embedding-3-small: 512 or 1536\n   * - OpenAI text-embedding-ada-002: 1536\n   * - Cohere embed-english-v3.0: 1024\n   * - Cohere embed-english-light-v3.0: 384\n   * - Cohere embed-multilingual-v3.0: 1024\n   * - Cohere embed-multilingual-light-v3.0: 384\n   */\n  dims: number;\n\n  /**\n   * The embeddings model to use for generating vectors.\n   * This should be a LangChain Embeddings implementation.\n   */\n  embeddings: Embeddings;\n\n  /**\n   * Fields to extract text from for embedding generation.\n   *\n   * Path syntax supports:\n   * - Simple field access: \"field\"\n   * - Nested fields: \"metadata.title\"\n   * - Array indexing:\n   *   - All elements: \"chapters[*].content\"\n   *   - Specific index: \"authors[0].name\"\n   *   - Last element: \"array[-1]\"\n   *\n   * @default [\"$\"] Embeds the entire document as one vector\n   */\n  fields?: string[];\n}\n\n/**\n * Utility function to get text at a specific JSON path\n */\nexport function getTextAtPath(obj: any, path: string): string[] {\n  const parts = path.split(\".\");\n  let current: any = obj;\n\n  for (const part of parts) {\n    if (part.includes(\"[\")) {\n      const [arrayName, indexStr] = part.split(\"[\");\n      const index = indexStr.replace(\"]\", \"\");\n\n      if (!current[arrayName]) return [];\n\n      if (index === \"*\") {\n        const results: string[] = [];\n        for (const item of current[arrayName]) {\n          if (typeof item === \"string\") results.push(item);\n        }\n        return results;\n      }\n\n      const idx = parseInt(index, 10);\n      if (Number.isNaN(idx)) return [];\n      current = current[arrayName][idx];\n    } else {\n      current = current[part];\n    }\n\n    if (current === undefined) return [];\n  }\n\n  return typeof current === \"string\" ? [current] : [];\n}\n\n/**\n * Tokenizes a JSON path into parts\n */\nexport function tokenizePath(path: string): string[] {\n  return path.split(\".\");\n}\n\n/**\n * Abstract base class for persistent key-value stores.\n *\n * Stores enable persistence and memory that can be shared across threads,\n * scoped to user IDs, assistant IDs, or other arbitrary namespaces.\n *\n * Features:\n * - Hierarchical namespaces for organization\n * - Key-value storage with metadata\n * - Vector similarity search (if configured)\n * - Filtering and pagination\n */\nexport abstract class BaseStore {\n  /**\n   * Execute multiple operations in a single batch.\n   * This is more efficient than executing operations individually.\n   *\n   * @param operations Array of operations to execute\n   * @returns Promise resolving to results matching the operations\n   */\n  abstract batch<Op extends Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>>;\n\n  /**\n   * Retrieve a single item by its namespace and key.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @returns Promise resolving to the item or null if not found\n   */\n  async get(namespace: string[], key: string): Promise<Item | null> {\n    return (await this.batch<[GetOperation]>([{ namespace, key }]))[0];\n  }\n\n  /**\n   * Search for items within a namespace prefix.\n   * Supports both metadata filtering and vector similarity search.\n   *\n   * @param namespacePrefix Hierarchical path prefix to search within\n   * @param options Search options for filtering and pagination\n   * @returns Promise resolving to list of matching items with relevance scores\n   *\n   * @example\n   * // Search with filters\n   * await store.search([\"documents\"], {\n   *   filter: { type: \"report\", status: \"active\" },\n   *   limit: 5,\n   *   offset: 10\n   * });\n   *\n   * // Vector similarity search\n   * await store.search([\"users\", \"content\"], {\n   *   query: \"technical documentation about APIs\",\n   *   limit: 20\n   * });\n   */\n  async search(\n    namespacePrefix: string[],\n    options: {\n      filter?: Record<string, any>;\n      limit?: number;\n      offset?: number;\n      query?: string;\n    } = {}\n  ): Promise<SearchItem[]> {\n    const { filter, limit = 10, offset = 0, query } = options;\n    return (\n      await this.batch<[SearchOperation]>([\n        {\n          namespacePrefix,\n          filter,\n          limit,\n          offset,\n          query,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Store or update an item.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @param value Object containing the item's data\n   * @param index Optional indexing configuration\n   *\n   * @example\n   * // Simple storage\n   * await store.put([\"docs\"], \"report\", { title: \"Annual Report\" });\n   *\n   * // With specific field indexing\n   * await store.put(\n   *   [\"docs\"],\n   *   \"report\",\n   *   {\n   *     title: \"Q4 Report\",\n   *     chapters: [{ content: \"...\" }, { content: \"...\" }]\n   *   },\n   *   [\"title\", \"chapters[*].content\"]\n   * );\n   */\n  async put(\n    namespace: string[],\n    key: string,\n    value: Record<string, any>,\n    index?: false | string[]\n  ): Promise<void> {\n    validateNamespace(namespace);\n    await this.batch<[PutOperation]>([{ namespace, key, value, index }]);\n  }\n\n  /**\n   * Delete an item from the store.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   */\n  async delete(namespace: string[], key: string): Promise<void> {\n    await this.batch<[PutOperation]>([{ namespace, key, value: null }]);\n  }\n\n  /**\n   * List and filter namespaces in the store.\n   * Used to explore data organization and navigate the namespace hierarchy.\n   *\n   * @param options Options for listing namespaces\n   * @returns Promise resolving to list of namespace paths\n   *\n   * @example\n   * // List all namespaces under \"documents\"\n   * await store.listNamespaces({\n   *   prefix: [\"documents\"],\n   *   maxDepth: 2\n   * });\n   *\n   * // List namespaces ending with \"v1\"\n   * await store.listNamespaces({\n   *   suffix: [\"v1\"],\n   *   limit: 50\n   * });\n   */\n  async listNamespaces(\n    options: {\n      prefix?: string[];\n      suffix?: string[];\n      maxDepth?: number;\n      limit?: number;\n      offset?: number;\n    } = {}\n  ): Promise<string[][]> {\n    const { prefix, suffix, maxDepth, limit = 100, offset = 0 } = options;\n\n    const matchConditions: MatchCondition[] = [];\n    if (prefix) {\n      matchConditions.push({ matchType: \"prefix\", path: prefix });\n    }\n    if (suffix) {\n      matchConditions.push({ matchType: \"suffix\", path: suffix });\n    }\n\n    return (\n      await this.batch<[ListNamespacesOperation]>([\n        {\n          matchConditions: matchConditions.length ? matchConditions : undefined,\n          maxDepth,\n          limit,\n          offset,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Start the store. Override if initialization is needed.\n   */\n  start(): void | Promise<void> {}\n\n  /**\n   * Stop the store. Override if cleanup is needed.\n   */\n  stop(): void | Promise<void> {}\n}\n"],"mappings":"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"}
+{"version":3,"file":"base.js","names":[],"sources":["../../src/store/base.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Embeddings } from \"@langchain/core/embeddings\";\n\n/**\n * Error thrown when an invalid namespace is provided.\n */\nexport class InvalidNamespaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"InvalidNamespaceError\";\n  }\n}\n\n/**\n * Validates the provided namespace.\n * @param namespace The namespace to validate.\n * @param options.allowEmpty When true, an empty namespace is permitted\n *   (`search([])` means \"search everything\"). Put still rejects empty.\n * @param options.allowReservedRoot When true, the `langgraph` root label is\n *   permitted. Put still rejects it; search may read a namespace written via\n *   `batch()` which bypasses put validation.\n * @throws {InvalidNamespaceError} If the namespace is invalid.\n */\nexport function validateNamespace(\n  namespace: string[],\n  options: { allowEmpty?: boolean; allowReservedRoot?: boolean } = {}\n): void {\n  if (namespace.length === 0) {\n    if (options.allowEmpty) {\n      return;\n    }\n    throw new InvalidNamespaceError(\"Namespace cannot be empty.\");\n  }\n  for (const label of namespace) {\n    if (typeof label !== \"string\") {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels ` +\n          `must be strings, but got ${typeof label}.`\n      );\n    }\n    if (label.includes(\".\")) {\n      throw new InvalidNamespaceError(\n        `Invalid namespace label '${label}' found in ${namespace}. Namespace labels cannot contain periods ('.').`\n      );\n    }\n    if (label === \"\") {\n      throw new InvalidNamespaceError(\n        `Namespace labels cannot be empty strings. Got ${label} in ${namespace}`\n      );\n    }\n  }\n\n  if (namespace[0] === \"langgraph\" && !options.allowReservedRoot) {\n    throw new InvalidNamespaceError(\n      `Root label for namespace cannot be \"langgraph\". Got: ${namespace}`\n    );\n  }\n}\n\n/**\n * Represents a stored item with metadata.\n */\nexport interface Item {\n  /**\n   * The stored data as an object. Keys are filterable.\n   */\n  value: Record<string, any>;\n  /**\n   * Unique identifier within the namespace.\n   */\n  key: string;\n  /**\n   * Hierarchical path defining the collection in which this document resides.\n   * Represented as an array of strings, allowing for nested categorization.\n   * For example: [\"documents\", \"user123\"]\n   */\n  namespace: string[];\n  /**\n   * Timestamp of item creation.\n   */\n  createdAt: Date;\n  /**\n   * Timestamp of last update.\n   */\n  updatedAt: Date;\n}\n\n/**\n * Represents a search result item with relevance score.\n * Extends the base Item interface with an optional similarity score.\n */\nexport interface SearchItem extends Item {\n  /**\n   * Relevance/similarity score if from a ranked operation.\n   * Higher scores indicate better matches.\n   *\n   * This is typically a cosine similarity score between -1 and 1,\n   * where 1 indicates identical vectors and -1 indicates opposite vectors.\n   */\n  score?: number;\n}\n\n/**\n * Operation to retrieve an item by namespace and ID.\n */\nexport interface GetOperation {\n  /**\n   * Hierarchical path for the item.\n   *\n   * @example\n   * // Get a user profile\n   * namespace: [\"users\", \"profiles\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier within the namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * @example\n   * key: \"user123\"  // For a user profile\n   * key: \"doc456\"   // For a document\n   */\n  key: string;\n}\n\n/**\n * Operation to search for items within a namespace prefix.\n */\nexport interface SearchOperation {\n  /**\n   * Hierarchical path prefix to search within.\n   * Only items under this prefix will be searched.\n   *\n   * @example\n   * // Search all user documents\n   * namespacePrefix: [\"users\", \"documents\"]\n   *\n   * // Search everything\n   * namespacePrefix: []\n   */\n  namespacePrefix: string[];\n\n  /**\n   * Key-value pairs to filter results based on exact matches or comparison operators.\n   *\n   * Supports both exact matches and operator-based comparisons:\n   * - $eq: Equal to (same as direct value comparison)\n   * - $ne: Not equal to\n   * - $gt: Greater than\n   * - $gte: Greater than or equal to\n   * - $lt: Less than\n   * - $lte: Less than or equal to\n   *\n   * @example\n   * // Exact match\n   * filter: { status: \"active\" }\n   *\n   * // With operators\n   * filter: { score: { $gt: 4.99 } }\n   *\n   * // Multiple conditions\n   * filter: {\n   *   score: { $gte: 3.0 },\n   *   color: \"red\"\n   * }\n   */\n  filter?: Record<string, any>;\n\n  /**\n   * Maximum number of items to return.\n   * @default 10\n   */\n  limit?: number;\n\n  /**\n   * Number of items to skip before returning results.\n   * Useful for pagination.\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Natural language search query for semantic search.\n   * When provided, results will be ranked by relevance to this query\n   * using vector similarity search.\n   *\n   * @example\n   * // Find technical documentation about APIs\n   * query: \"technical documentation about REST APIs\"\n   *\n   * // Find recent ML papers\n   * query: \"machine learning papers from 2023\"\n   */\n  query?: string;\n}\n\n/**\n * Operation to store, update, or delete an item.\n */\nexport interface PutOperation {\n  /**\n   * Hierarchical path for the item.\n   * Acts as a folder-like structure to organize items.\n   * Each element represents one level in the hierarchy.\n   *\n   * @example\n   * // Root level documents\n   * namespace: [\"documents\"]\n   *\n   * // User-specific documents\n   * namespace: [\"documents\", \"user123\"]\n   *\n   * // Nested cache structure\n   * namespace: [\"cache\", \"docs\", \"v1\"]\n   */\n  namespace: string[];\n\n  /**\n   * Unique identifier for the document within its namespace.\n   * Together with namespace forms the complete path to the item.\n   *\n   * Example: If namespace is [\"documents\", \"user123\"] and key is \"report1\",\n   * the full path would effectively be \"documents/user123/report1\"\n   */\n  key: string;\n\n  /**\n   * Data to be stored, or null to delete the item.\n   * Must be a JSON-serializable object with string keys.\n   * Setting to null signals that the item should be deleted.\n   *\n   * @example\n   * {\n   *   field1: \"string value\",\n   *   field2: 123,\n   *   nested: { can: \"contain\", any: \"serializable data\" }\n   * }\n   */\n  value: Record<string, any> | null;\n\n  /**\n   * Controls how the item's fields are indexed for search operations.\n   *\n   * - undefined: Uses store's default indexing configuration\n   * - false: Disables indexing for this item\n   * - string[]: List of field paths to index\n   *\n   * Path syntax supports:\n   * - Nested fields: \"metadata.title\"\n   * - Array access: \"chapters[*].content\" (each indexed separately)\n   * - Specific indices: \"authors[0].name\"\n   *\n   * @example\n   * // Index specific fields\n   * index: [\"metadata.title\", \"chapters[*].content\"]\n   *\n   * // Disable indexing\n   * index: false\n   */\n  index?: false | string[];\n}\n\n/**\n * Operation to list and filter namespaces in the store.\n */\nexport interface ListNamespacesOperation {\n  matchConditions?: MatchCondition[];\n  maxDepth?: number;\n  limit: number;\n  offset: number;\n}\n\nexport type NameSpacePath = (string | \"*\")[];\n\nexport type NamespaceMatchType = \"prefix\" | \"suffix\";\n\nexport interface MatchCondition {\n  matchType: NamespaceMatchType;\n  path: NameSpacePath;\n}\n\nexport type Operation =\n  | GetOperation\n  | SearchOperation\n  | PutOperation\n  | ListNamespacesOperation;\n\nexport type OperationResults<Tuple extends readonly Operation[]> = {\n  [K in keyof Tuple]: Tuple[K] extends PutOperation\n    ? void\n    : Tuple[K] extends SearchOperation\n      ? SearchItem[]\n      : Tuple[K] extends GetOperation\n        ? Item | null\n        : Tuple[K] extends ListNamespacesOperation\n          ? string[][]\n          : never;\n};\n\n/**\n * Configuration for indexing documents for semantic search in the store.\n *\n * This configures how documents are embedded and indexed for vector similarity search.\n */\nexport interface IndexConfig {\n  /**\n   * Number of dimensions in the embedding vectors.\n   *\n   * Common embedding model dimensions:\n   * - OpenAI text-embedding-3-large: 256, 1024, or 3072\n   * - OpenAI text-embedding-3-small: 512 or 1536\n   * - OpenAI text-embedding-ada-002: 1536\n   * - Cohere embed-english-v3.0: 1024\n   * - Cohere embed-english-light-v3.0: 384\n   * - Cohere embed-multilingual-v3.0: 1024\n   * - Cohere embed-multilingual-light-v3.0: 384\n   */\n  dims: number;\n\n  /**\n   * The embeddings model to use for generating vectors.\n   * This should be a LangChain Embeddings implementation.\n   */\n  embeddings: Embeddings;\n\n  /**\n   * Fields to extract text from for embedding generation.\n   *\n   * Path syntax supports:\n   * - Simple field access: \"field\"\n   * - Nested fields: \"metadata.title\"\n   * - Array indexing:\n   *   - All elements: \"chapters[*].content\"\n   *   - Specific index: \"authors[0].name\"\n   *   - Last element: \"array[-1]\"\n   *\n   * @default [\"$\"] Embeds the entire document as one vector\n   */\n  fields?: string[];\n}\n\n/**\n * Utility function to get text at a specific JSON path\n */\nexport function getTextAtPath(obj: any, path: string): string[] {\n  const parts = path.split(\".\");\n  let current: any = obj;\n\n  for (const part of parts) {\n    if (part.includes(\"[\")) {\n      const [arrayName, indexStr] = part.split(\"[\");\n      const index = indexStr.replace(\"]\", \"\");\n\n      if (!current[arrayName]) return [];\n\n      if (index === \"*\") {\n        const results: string[] = [];\n        for (const item of current[arrayName]) {\n          if (typeof item === \"string\") results.push(item);\n        }\n        return results;\n      }\n\n      const idx = parseInt(index, 10);\n      if (Number.isNaN(idx)) return [];\n      current = current[arrayName][idx];\n    } else {\n      current = current[part];\n    }\n\n    if (current === undefined) return [];\n  }\n\n  return typeof current === \"string\" ? [current] : [];\n}\n\n/**\n * Tokenizes a JSON path into parts\n */\nexport function tokenizePath(path: string): string[] {\n  return path.split(\".\");\n}\n\n/**\n * Abstract base class for persistent key-value stores.\n *\n * Stores enable persistence and memory that can be shared across threads,\n * scoped to user IDs, assistant IDs, or other arbitrary namespaces.\n *\n * Features:\n * - Hierarchical namespaces for organization\n * - Key-value storage with metadata\n * - Vector similarity search (if configured)\n * - Filtering and pagination\n */\nexport abstract class BaseStore {\n  /**\n   * Execute multiple operations in a single batch.\n   * This is more efficient than executing operations individually.\n   *\n   * @param operations Array of operations to execute\n   * @returns Promise resolving to results matching the operations\n   */\n  abstract batch<Op extends Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>>;\n\n  /**\n   * Retrieve a single item by its namespace and key.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @returns Promise resolving to the item or null if not found\n   */\n  async get(namespace: string[], key: string): Promise<Item | null> {\n    return (await this.batch<[GetOperation]>([{ namespace, key }]))[0];\n  }\n\n  /**\n   * Search for items within a namespace prefix.\n   * Supports both metadata filtering and vector similarity search.\n   *\n   * @param namespacePrefix Hierarchical path prefix to search within\n   * @param options Search options for filtering and pagination\n   * @returns Promise resolving to list of matching items with relevance scores\n   *\n   * @example\n   * // Search with filters\n   * await store.search([\"documents\"], {\n   *   filter: { type: \"report\", status: \"active\" },\n   *   limit: 5,\n   *   offset: 10\n   * });\n   *\n   * // Vector similarity search\n   * await store.search([\"users\", \"content\"], {\n   *   query: \"technical documentation about APIs\",\n   *   limit: 20\n   * });\n   */\n  async search(\n    namespacePrefix: string[],\n    options: {\n      filter?: Record<string, any>;\n      limit?: number;\n      offset?: number;\n      query?: string;\n    } = {}\n  ): Promise<SearchItem[]> {\n    validateNamespace(namespacePrefix, {\n      allowEmpty: true,\n      allowReservedRoot: true,\n    });\n    const { filter, limit = 10, offset = 0, query } = options;\n    return (\n      await this.batch<[SearchOperation]>([\n        {\n          namespacePrefix,\n          filter,\n          limit,\n          offset,\n          query,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Store or update an item.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   * @param value Object containing the item's data\n   * @param index Optional indexing configuration\n   *\n   * @example\n   * // Simple storage\n   * await store.put([\"docs\"], \"report\", { title: \"Annual Report\" });\n   *\n   * // With specific field indexing\n   * await store.put(\n   *   [\"docs\"],\n   *   \"report\",\n   *   {\n   *     title: \"Q4 Report\",\n   *     chapters: [{ content: \"...\" }, { content: \"...\" }]\n   *   },\n   *   [\"title\", \"chapters[*].content\"]\n   * );\n   */\n  async put(\n    namespace: string[],\n    key: string,\n    value: Record<string, any>,\n    index?: false | string[]\n  ): Promise<void> {\n    validateNamespace(namespace);\n    await this.batch<[PutOperation]>([{ namespace, key, value, index }]);\n  }\n\n  /**\n   * Delete an item from the store.\n   *\n   * @param namespace Hierarchical path for the item\n   * @param key Unique identifier within the namespace\n   */\n  async delete(namespace: string[], key: string): Promise<void> {\n    await this.batch<[PutOperation]>([{ namespace, key, value: null }]);\n  }\n\n  /**\n   * List and filter namespaces in the store.\n   * Used to explore data organization and navigate the namespace hierarchy.\n   *\n   * @param options Options for listing namespaces\n   * @returns Promise resolving to list of namespace paths\n   *\n   * @example\n   * // List all namespaces under \"documents\"\n   * await store.listNamespaces({\n   *   prefix: [\"documents\"],\n   *   maxDepth: 2\n   * });\n   *\n   * // List namespaces ending with \"v1\"\n   * await store.listNamespaces({\n   *   suffix: [\"v1\"],\n   *   limit: 50\n   * });\n   */\n  async listNamespaces(\n    options: {\n      prefix?: string[];\n      suffix?: string[];\n      maxDepth?: number;\n      limit?: number;\n      offset?: number;\n    } = {}\n  ): Promise<string[][]> {\n    const { prefix, suffix, maxDepth, limit = 100, offset = 0 } = options;\n\n    const matchConditions: MatchCondition[] = [];\n    if (prefix) {\n      matchConditions.push({ matchType: \"prefix\", path: prefix });\n    }\n    if (suffix) {\n      matchConditions.push({ matchType: \"suffix\", path: suffix });\n    }\n\n    return (\n      await this.batch<[ListNamespacesOperation]>([\n        {\n          matchConditions: matchConditions.length ? matchConditions : undefined,\n          maxDepth,\n          limit,\n          offset,\n        },\n      ])\n    )[0];\n  }\n\n  /**\n   * Start the store. Override if initialization is needed.\n   */\n  start(): void | Promise<void> {}\n\n  /**\n   * Stop the store. Override if cleanup is needed.\n   */\n  stop(): void | Promise<void> {}\n}\n"],"mappings":"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"}

package/dist/store/memory.cjs

@@ -1,6 +1,10 @@
 const require_base = require("./base.cjs");
 const require_utils = require("./utils.cjs");
 //#region src/store/memory.ts
+function validateMemoryNamespace(namespace) {
+	require_base.validateNamespace(namespace, { allowReservedRoot: true });
+	if (namespace.some((label) => label.includes(":"))) throw new require_base.InvalidNamespaceError("Namespace labels cannot contain colons (':'), the InMemoryStore path separator.");
+}
 /**
 * In-memory key-value store with optional vector search.
 *
@@ -51,6 +55,7 @@ var InMemoryStore = class extends require_base.BaseStore {
 		const searchOps = /* @__PURE__ */ new Map();
 		for (let i = 0; i < operations.length; i += 1) {
 			const op = operations[i];
+			if ("namespace" in op) validateMemoryNamespace(op.namespace);
 			if ("key" in op && "namespace" in op && !("value" in op)) results.push(this.getOperation(op));
 			else if ("namespacePrefix" in op) {
 				const candidates = this.filterItems(op);
@@ -137,8 +142,10 @@ var InMemoryStore = class extends require_base.BaseStore {
 		throw new Error(`Unsupported match type: ${matchType}`);
 	}
 	filterItems(op) {
+		if (op.namespacePrefix.length > 0) validateMemoryNamespace(op.namespacePrefix);
+		const prefix = op.namespacePrefix.join(":");
 		const candidates = [];
-		for (const [namespace, items] of this.data.entries()) if (namespace.startsWith(op.namespacePrefix.join(":"))) candidates.push(...items.values());
+		for (const [namespace, items] of this.data.entries()) if (prefix === "" || namespace === prefix || namespace.startsWith(`${prefix}:`)) candidates.push(...items.values());
 		let filteredCandidates = candidates;
 		if (op.filter) filteredCandidates = candidates.filter((item) => Object.entries(op.filter).every(([key, value]) => require_utils.compareValues(item.value[key], value)));
 		return filteredCandidates;

package/dist/store/memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory.cjs","names":["BaseStore","tokenizePath","compareValues","getTextAtPath"],"sources":["../../src/store/memory.ts"],"sourcesContent":["import {\n  BaseStore,\n  type OperationResults,\n  type Item,\n  type Operation,\n  MatchCondition,\n  ListNamespacesOperation,\n  PutOperation,\n  SearchOperation,\n  GetOperation,\n  type IndexConfig,\n  type SearchItem,\n} from \"./base.js\";\nimport { tokenizePath, compareValues, getTextAtPath } from \"./utils.js\";\n\n/**\n * In-memory key-value store with optional vector search.\n *\n * A lightweight store implementation using JavaScript Maps. Supports basic\n * key-value operations and vector search when configured with embeddings.\n *\n * @example\n * ```typescript\n * // Basic key-value storage\n * const store = new InMemoryStore();\n * await store.put([\"users\", \"123\"], \"prefs\", { theme: \"dark\" });\n * const item = await store.get([\"users\", \"123\"], \"prefs\");\n *\n * // Vector search with embeddings\n * import { OpenAIEmbeddings } from \"@langchain/openai\";\n * const store = new InMemoryStore({\n *   index: {\n *     dims: 1536,\n *     embeddings: new OpenAIEmbeddings({ modelName: \"text-embedding-3-small\" }),\n *   }\n * });\n *\n * // Store documents\n * await store.put([\"docs\"], \"doc1\", { text: \"Python tutorial\" });\n * await store.put([\"docs\"], \"doc2\", { text: \"TypeScript guide\" });\n *\n * // Search by similarity\n * const results = await store.search([\"docs\"], { query: \"python programming\" });\n * ```\n *\n * **Warning**: This store keeps all data in memory. Data is lost when the process exits.\n * For persistence, use a database-backed store.\n */\nexport class InMemoryStore extends BaseStore {\n  private data: Map<string, Map<string, Item>> = new Map();\n\n  // Namespace -> Key -> Path/field -> Vector\n  private vectors: Map<string, Map<string, Map<string, number[]>>> = new Map();\n\n  private _indexConfig?: IndexConfig & {\n    __tokenizedFields: Array<[string, string[]]>;\n  };\n\n  constructor(options?: { index?: IndexConfig }) {\n    super();\n    if (options?.index) {\n      this._indexConfig = {\n        ...options.index,\n        __tokenizedFields: (options.index.fields ?? [\"$\"]).map((p) => [\n          p,\n          p === \"$\" ? [p] : tokenizePath(p),\n        ]),\n      };\n    }\n  }\n\n  async batch<Op extends readonly Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>> {\n    const results = [];\n    const putOps = new Map<string, PutOperation>();\n    const searchOps = new Map<number, [SearchOperation, Item[]]>();\n\n    // First pass - handle gets and prepare search/put operations\n    for (let i = 0; i < operations.length; i += 1) {\n      const op = operations[i];\n      if (\"key\" in op && \"namespace\" in op && !(\"value\" in op)) {\n        // GetOperation\n        results.push(this.getOperation(op));\n      } else if (\"namespacePrefix\" in op) {\n        // SearchOperation\n        const candidates = this.filterItems(op);\n        searchOps.set(i, [op, candidates]);\n        results.push(null);\n      } else if (\"value\" in op) {\n        // PutOperation\n        const key = `${op.namespace.join(\":\")}:${op.key}`;\n        putOps.set(key, op);\n        results.push(null);\n      } else if (\"matchConditions\" in op) {\n        // ListNamespacesOperation\n        results.push(this.listNamespacesOperation(op));\n      }\n    }\n\n    // Handle search operations with embeddings\n    if (searchOps.size > 0) {\n      if (this._indexConfig?.embeddings) {\n        const queries = new Set<string>();\n        for (const [op] of searchOps.values()) {\n          if (op.query) queries.add(op.query);\n        }\n\n        // Get embeddings for all queries\n        const queryEmbeddings =\n          queries.size > 0\n            ? await Promise.all(\n                Array.from(queries).map((q) =>\n                  this._indexConfig!.embeddings.embedQuery(q)\n                )\n              )\n            : [];\n        const queryVectors = Object.fromEntries(\n          Array.from(queries).map((q, i) => [q, queryEmbeddings[i]])\n        );\n\n        // Process each search operation\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          if (op.query && queryVectors[op.query]) {\n            const queryVector = queryVectors[op.query];\n            const scoredResults = this.scoreResults(\n              candidates,\n              queryVector,\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n            results[i] = scoredResults;\n          } else {\n            results[i] = this.paginateResults(\n              candidates.map((item) => ({ ...item, score: undefined })),\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n          }\n        }\n      } else {\n        // No embeddings - just paginate the filtered results\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          results[i] = this.paginateResults(\n            candidates.map((item) => ({ ...item, score: undefined })),\n            op.offset ?? 0,\n            op.limit ?? 10\n          );\n        }\n      }\n    }\n\n    // Handle put operations with embeddings\n    if (putOps.size > 0 && this._indexConfig?.embeddings) {\n      const toEmbed = this.extractTexts(Array.from(putOps.values()));\n      if (Object.keys(toEmbed).length > 0) {\n        const embeddings = await this._indexConfig.embeddings.embedDocuments(\n          Object.keys(toEmbed)\n        );\n        this.insertVectors(toEmbed, embeddings);\n      }\n    }\n\n    // Apply all put operations\n    for (const op of putOps.values()) {\n      this.putOperation(op);\n    }\n\n    return results as OperationResults<Op>;\n  }\n\n  private getOperation(op: GetOperation): Item | null {\n    const namespaceKey = op.namespace.join(\":\");\n    const item = this.data.get(namespaceKey)?.get(op.key);\n    return item ?? null;\n  }\n\n  private putOperation(op: PutOperation): void {\n    const namespaceKey = op.namespace.join(\":\");\n    if (!this.data.has(namespaceKey)) {\n      this.data.set(namespaceKey, new Map());\n    }\n    const namespaceMap = this.data.get(namespaceKey)!;\n\n    if (op.value === null) {\n      namespaceMap.delete(op.key);\n    } else {\n      const now = new Date();\n      if (namespaceMap.has(op.key)) {\n        const item = namespaceMap.get(op.key)!;\n        item.value = op.value;\n        item.updatedAt = now;\n      } else {\n        namespaceMap.set(op.key, {\n          value: op.value,\n          key: op.key,\n          namespace: op.namespace,\n          createdAt: now,\n          updatedAt: now,\n        });\n      }\n    }\n  }\n\n  private listNamespacesOperation(op: ListNamespacesOperation): string[][] {\n    const allNamespaces = Array.from(this.data.keys()).map((ns) =>\n      ns.split(\":\")\n    );\n    let namespaces = allNamespaces;\n\n    if (op.matchConditions && op.matchConditions.length > 0) {\n      namespaces = namespaces.filter((ns) =>\n        op.matchConditions!.every((condition) => this.doesMatch(condition, ns))\n      );\n    }\n\n    if (op.maxDepth !== undefined) {\n      namespaces = Array.from(\n        new Set(namespaces.map((ns) => ns.slice(0, op.maxDepth).join(\":\")))\n      ).map((ns) => ns.split(\":\"));\n    }\n\n    namespaces.sort((a, b) => a.join(\":\").localeCompare(b.join(\":\")));\n\n    return namespaces.slice(\n      op.offset ?? 0,\n      (op.offset ?? 0) + (op.limit ?? namespaces.length)\n    );\n  }\n\n  private doesMatch(matchCondition: MatchCondition, key: string[]): boolean {\n    const { matchType, path } = matchCondition;\n\n    if (matchType === \"prefix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    } else if (matchType === \"suffix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[key.length - path.length + index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    }\n\n    throw new Error(`Unsupported match type: ${matchType}`);\n  }\n\n  private filterItems(op: SearchOperation): Item[] {\n    const candidates: Item[] = [];\n    for (const [namespace, items] of this.data.entries()) {\n      if (namespace.startsWith(op.namespacePrefix.join(\":\"))) {\n        candidates.push(...items.values());\n      }\n    }\n\n    let filteredCandidates = candidates;\n    if (op.filter) {\n      filteredCandidates = candidates.filter((item) =>\n        Object.entries(op.filter!).every(([key, value]) =>\n          compareValues(item.value[key], value)\n        )\n      );\n    }\n    return filteredCandidates;\n  }\n\n  private scoreResults(\n    candidates: Item[],\n    queryVector: number[],\n    offset: number = 0,\n    limit: number = 10\n  ): SearchItem[] {\n    const flatItems: Item[] = [];\n    const flatVectors: number[][] = [];\n    const scoreless: Item[] = [];\n\n    for (const item of candidates) {\n      const vectors = this.getVectors(item);\n      if (vectors.length) {\n        for (const vector of vectors) {\n          flatItems.push(item);\n          flatVectors.push(vector);\n        }\n      } else {\n        scoreless.push(item);\n      }\n    }\n\n    const scores = this.cosineSimilarity(queryVector, flatVectors);\n\n    const sortedResults = scores\n      .map((score, i) => [score, flatItems[i]] as [number, Item])\n      .sort((a, b) => b[0] - a[0]);\n\n    const seen = new Set<string>();\n    const kept: Array<[number | undefined, Item]> = [];\n\n    for (const [score, item] of sortedResults) {\n      const key = `${item.namespace.join(\":\")}:${item.key}`;\n      if (seen.has(key)) continue;\n\n      const ix = seen.size;\n      if (ix >= offset + limit) break;\n      if (ix < offset) {\n        seen.add(key);\n        continue;\n      }\n\n      seen.add(key);\n      kept.push([score, item]);\n    }\n\n    if (scoreless.length && kept.length < limit) {\n      for (const item of scoreless.slice(0, limit - kept.length)) {\n        const key = `${item.namespace.join(\":\")}:${item.key}`;\n        if (!seen.has(key)) {\n          seen.add(key);\n          kept.push([undefined, item]);\n        }\n      }\n    }\n    return kept.map(([score, item]) => ({\n      ...item,\n      score,\n    }));\n  }\n\n  private paginateResults(\n    results: SearchItem[],\n    offset: number,\n    limit: number\n  ): SearchItem[] {\n    return results.slice(offset, offset + limit);\n  }\n\n  private extractTexts(ops: PutOperation[]): {\n    [text: string]: [string[], string, string][];\n  } {\n    if (!ops.length || !this._indexConfig) {\n      return {};\n    }\n\n    const toEmbed: { [text: string]: [string[], string, string][] } = {};\n\n    for (const op of ops) {\n      if (op.value !== null && op.index !== false) {\n        const paths =\n          op.index === null || op.index === undefined\n            ? (this._indexConfig.__tokenizedFields ?? [])\n            : op.index.map(\n                (ix) => [ix, tokenizePath(ix)] as [string, string[]]\n              );\n        for (const [path, field] of paths) {\n          const texts = getTextAtPath(op.value, field);\n          if (texts.length) {\n            if (texts.length > 1) {\n              texts.forEach((text, i) => {\n                if (!toEmbed[text]) toEmbed[text] = [];\n                toEmbed[text].push([op.namespace, op.key, `${path}.${i}`]);\n              });\n            } else {\n              if (!toEmbed[texts[0]]) toEmbed[texts[0]] = [];\n              toEmbed[texts[0]].push([op.namespace, op.key, path]);\n            }\n          }\n        }\n      }\n    }\n\n    return toEmbed;\n  }\n\n  private insertVectors(\n    texts: { [text: string]: [string[], string, string][] },\n    embeddings: number[][]\n  ): void {\n    for (const [text, metadata] of Object.entries(texts)) {\n      const embedding = embeddings.shift();\n      if (!embedding) {\n        throw new Error(`No embedding found for text: ${text}`);\n      }\n\n      for (const [namespace, key, field] of metadata) {\n        const namespaceKey = namespace.join(\":\");\n        if (!this.vectors.has(namespaceKey)) {\n          this.vectors.set(namespaceKey, new Map());\n        }\n        const namespaceMap = this.vectors.get(namespaceKey)!;\n        if (!namespaceMap.has(key)) {\n          namespaceMap.set(key, new Map());\n        }\n        const itemMap = namespaceMap.get(key)!;\n        itemMap.set(field, embedding);\n      }\n    }\n  }\n\n  private getVectors(item: Item): number[][] {\n    const namespaceKey = item.namespace.join(\":\");\n    const itemKey = item.key;\n    if (!this.vectors.has(namespaceKey)) {\n      return [];\n    }\n    const namespaceMap = this.vectors.get(namespaceKey)!;\n    if (!namespaceMap.has(itemKey)) {\n      return [];\n    }\n    const itemMap = namespaceMap.get(itemKey)!;\n    const vectors = Array.from(itemMap.values());\n    if (!vectors.length) {\n      return [];\n    }\n    return vectors;\n  }\n\n  private cosineSimilarity(X: number[], Y: number[][]): number[] {\n    if (!Y.length) return [];\n\n    // Calculate dot products for all vectors at once\n    const dotProducts = Y.map((vector) =>\n      vector.reduce((acc, val, i) => acc + val * X[i], 0)\n    );\n\n    // Calculate magnitudes\n    const magnitude1 = Math.sqrt(X.reduce((acc, val) => acc + val * val, 0));\n    const magnitudes2 = Y.map((vector) =>\n      Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0))\n    );\n\n    // Calculate similarities\n    return dotProducts.map((dot, i) => {\n      const magnitude2 = magnitudes2[i];\n      return magnitude1 && magnitude2 ? dot / (magnitude1 * magnitude2) : 0;\n    });\n  }\n\n  public get indexConfig(): IndexConfig | undefined {\n    return this._indexConfig;\n  }\n}\n\n/** @deprecated Alias for InMemoryStore */\nexport class MemoryStore extends InMemoryStore {}\n"],"mappings":"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"}
+{"version":3,"file":"memory.cjs","names":["InvalidNamespaceError","BaseStore","tokenizePath","compareValues","getTextAtPath"],"sources":["../../src/store/memory.ts"],"sourcesContent":["import {\n  BaseStore,\n  type OperationResults,\n  type Item,\n  type Operation,\n  MatchCondition,\n  ListNamespacesOperation,\n  PutOperation,\n  SearchOperation,\n  GetOperation,\n  type IndexConfig,\n  type SearchItem,\n  validateNamespace,\n  InvalidNamespaceError,\n} from \"./base.js\";\nimport { tokenizePath, compareValues, getTextAtPath } from \"./utils.js\";\n\nfunction validateMemoryNamespace(namespace: string[]): void {\n  validateNamespace(namespace, { allowReservedRoot: true });\n\n  if (namespace.some((label) => label.includes(\":\"))) {\n    throw new InvalidNamespaceError(\n      \"Namespace labels cannot contain colons (':'), the InMemoryStore path separator.\"\n    );\n  }\n}\n\n/**\n * In-memory key-value store with optional vector search.\n *\n * A lightweight store implementation using JavaScript Maps. Supports basic\n * key-value operations and vector search when configured with embeddings.\n *\n * @example\n * ```typescript\n * // Basic key-value storage\n * const store = new InMemoryStore();\n * await store.put([\"users\", \"123\"], \"prefs\", { theme: \"dark\" });\n * const item = await store.get([\"users\", \"123\"], \"prefs\");\n *\n * // Vector search with embeddings\n * import { OpenAIEmbeddings } from \"@langchain/openai\";\n * const store = new InMemoryStore({\n *   index: {\n *     dims: 1536,\n *     embeddings: new OpenAIEmbeddings({ modelName: \"text-embedding-3-small\" }),\n *   }\n * });\n *\n * // Store documents\n * await store.put([\"docs\"], \"doc1\", { text: \"Python tutorial\" });\n * await store.put([\"docs\"], \"doc2\", { text: \"TypeScript guide\" });\n *\n * // Search by similarity\n * const results = await store.search([\"docs\"], { query: \"python programming\" });\n * ```\n *\n * **Warning**: This store keeps all data in memory. Data is lost when the process exits.\n * For persistence, use a database-backed store.\n */\nexport class InMemoryStore extends BaseStore {\n  private data: Map<string, Map<string, Item>> = new Map();\n\n  // Namespace -> Key -> Path/field -> Vector\n  private vectors: Map<string, Map<string, Map<string, number[]>>> = new Map();\n\n  private _indexConfig?: IndexConfig & {\n    __tokenizedFields: Array<[string, string[]]>;\n  };\n\n  constructor(options?: { index?: IndexConfig }) {\n    super();\n    if (options?.index) {\n      this._indexConfig = {\n        ...options.index,\n        __tokenizedFields: (options.index.fields ?? [\"$\"]).map((p) => [\n          p,\n          p === \"$\" ? [p] : tokenizePath(p),\n        ]),\n      };\n    }\n  }\n\n  async batch<Op extends readonly Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>> {\n    const results = [];\n    const putOps = new Map<string, PutOperation>();\n    const searchOps = new Map<number, [SearchOperation, Item[]]>();\n\n    // First pass - handle gets and prepare search/put operations\n    for (let i = 0; i < operations.length; i += 1) {\n      const op = operations[i];\n\n      if (\"namespace\" in op) {\n        validateMemoryNamespace(op.namespace);\n      }\n      if (\"key\" in op && \"namespace\" in op && !(\"value\" in op)) {\n        // GetOperation\n        results.push(this.getOperation(op));\n      } else if (\"namespacePrefix\" in op) {\n        // SearchOperation\n        const candidates = this.filterItems(op);\n        searchOps.set(i, [op, candidates]);\n        results.push(null);\n      } else if (\"value\" in op) {\n        // PutOperation\n        const key = `${op.namespace.join(\":\")}:${op.key}`;\n        putOps.set(key, op);\n        results.push(null);\n      } else if (\"matchConditions\" in op) {\n        // ListNamespacesOperation\n        results.push(this.listNamespacesOperation(op));\n      }\n    }\n\n    // Handle search operations with embeddings\n    if (searchOps.size > 0) {\n      if (this._indexConfig?.embeddings) {\n        const queries = new Set<string>();\n        for (const [op] of searchOps.values()) {\n          if (op.query) queries.add(op.query);\n        }\n\n        // Get embeddings for all queries\n        const queryEmbeddings =\n          queries.size > 0\n            ? await Promise.all(\n                Array.from(queries).map((q) =>\n                  this._indexConfig!.embeddings.embedQuery(q)\n                )\n              )\n            : [];\n        const queryVectors = Object.fromEntries(\n          Array.from(queries).map((q, i) => [q, queryEmbeddings[i]])\n        );\n\n        // Process each search operation\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          if (op.query && queryVectors[op.query]) {\n            const queryVector = queryVectors[op.query];\n            const scoredResults = this.scoreResults(\n              candidates,\n              queryVector,\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n            results[i] = scoredResults;\n          } else {\n            results[i] = this.paginateResults(\n              candidates.map((item) => ({ ...item, score: undefined })),\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n          }\n        }\n      } else {\n        // No embeddings - just paginate the filtered results\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          results[i] = this.paginateResults(\n            candidates.map((item) => ({ ...item, score: undefined })),\n            op.offset ?? 0,\n            op.limit ?? 10\n          );\n        }\n      }\n    }\n\n    // Handle put operations with embeddings\n    if (putOps.size > 0 && this._indexConfig?.embeddings) {\n      const toEmbed = this.extractTexts(Array.from(putOps.values()));\n      if (Object.keys(toEmbed).length > 0) {\n        const embeddings = await this._indexConfig.embeddings.embedDocuments(\n          Object.keys(toEmbed)\n        );\n        this.insertVectors(toEmbed, embeddings);\n      }\n    }\n\n    // Apply all put operations\n    for (const op of putOps.values()) {\n      this.putOperation(op);\n    }\n\n    return results as OperationResults<Op>;\n  }\n\n  private getOperation(op: GetOperation): Item | null {\n    const namespaceKey = op.namespace.join(\":\");\n    const item = this.data.get(namespaceKey)?.get(op.key);\n    return item ?? null;\n  }\n\n  private putOperation(op: PutOperation): void {\n    const namespaceKey = op.namespace.join(\":\");\n    if (!this.data.has(namespaceKey)) {\n      this.data.set(namespaceKey, new Map());\n    }\n    const namespaceMap = this.data.get(namespaceKey)!;\n\n    if (op.value === null) {\n      namespaceMap.delete(op.key);\n    } else {\n      const now = new Date();\n      if (namespaceMap.has(op.key)) {\n        const item = namespaceMap.get(op.key)!;\n        item.value = op.value;\n        item.updatedAt = now;\n      } else {\n        namespaceMap.set(op.key, {\n          value: op.value,\n          key: op.key,\n          namespace: op.namespace,\n          createdAt: now,\n          updatedAt: now,\n        });\n      }\n    }\n  }\n\n  private listNamespacesOperation(op: ListNamespacesOperation): string[][] {\n    const allNamespaces = Array.from(this.data.keys()).map((ns) =>\n      ns.split(\":\")\n    );\n    let namespaces = allNamespaces;\n\n    if (op.matchConditions && op.matchConditions.length > 0) {\n      namespaces = namespaces.filter((ns) =>\n        op.matchConditions!.every((condition) => this.doesMatch(condition, ns))\n      );\n    }\n\n    if (op.maxDepth !== undefined) {\n      namespaces = Array.from(\n        new Set(namespaces.map((ns) => ns.slice(0, op.maxDepth).join(\":\")))\n      ).map((ns) => ns.split(\":\"));\n    }\n\n    namespaces.sort((a, b) => a.join(\":\").localeCompare(b.join(\":\")));\n\n    return namespaces.slice(\n      op.offset ?? 0,\n      (op.offset ?? 0) + (op.limit ?? namespaces.length)\n    );\n  }\n\n  private doesMatch(matchCondition: MatchCondition, key: string[]): boolean {\n    const { matchType, path } = matchCondition;\n\n    if (matchType === \"prefix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    } else if (matchType === \"suffix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[key.length - path.length + index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    }\n\n    throw new Error(`Unsupported match type: ${matchType}`);\n  }\n\n  private filterItems(op: SearchOperation): Item[] {\n    if (op.namespacePrefix.length > 0) {\n      validateMemoryNamespace(op.namespacePrefix);\n    }\n\n    const prefix = op.namespacePrefix.join(\":\");\n    const candidates: Item[] = [];\n    for (const [namespace, items] of this.data.entries()) {\n      // Match exact namespaces and descendants at a segment boundary.\n      // An empty prefix searches all namespaces.\n      if (\n        prefix === \"\" ||\n        namespace === prefix ||\n        namespace.startsWith(`${prefix}:`)\n      ) {\n        candidates.push(...items.values());\n      }\n    }\n\n    let filteredCandidates = candidates;\n    if (op.filter) {\n      filteredCandidates = candidates.filter((item) =>\n        Object.entries(op.filter!).every(([key, value]) =>\n          compareValues(item.value[key], value)\n        )\n      );\n    }\n    return filteredCandidates;\n  }\n\n  private scoreResults(\n    candidates: Item[],\n    queryVector: number[],\n    offset: number = 0,\n    limit: number = 10\n  ): SearchItem[] {\n    const flatItems: Item[] = [];\n    const flatVectors: number[][] = [];\n    const scoreless: Item[] = [];\n\n    for (const item of candidates) {\n      const vectors = this.getVectors(item);\n      if (vectors.length) {\n        for (const vector of vectors) {\n          flatItems.push(item);\n          flatVectors.push(vector);\n        }\n      } else {\n        scoreless.push(item);\n      }\n    }\n\n    const scores = this.cosineSimilarity(queryVector, flatVectors);\n\n    const sortedResults = scores\n      .map((score, i) => [score, flatItems[i]] as [number, Item])\n      .sort((a, b) => b[0] - a[0]);\n\n    const seen = new Set<string>();\n    const kept: Array<[number | undefined, Item]> = [];\n\n    for (const [score, item] of sortedResults) {\n      const key = `${item.namespace.join(\":\")}:${item.key}`;\n      if (seen.has(key)) continue;\n\n      const ix = seen.size;\n      if (ix >= offset + limit) break;\n      if (ix < offset) {\n        seen.add(key);\n        continue;\n      }\n\n      seen.add(key);\n      kept.push([score, item]);\n    }\n\n    if (scoreless.length && kept.length < limit) {\n      for (const item of scoreless.slice(0, limit - kept.length)) {\n        const key = `${item.namespace.join(\":\")}:${item.key}`;\n        if (!seen.has(key)) {\n          seen.add(key);\n          kept.push([undefined, item]);\n        }\n      }\n    }\n    return kept.map(([score, item]) => ({\n      ...item,\n      score,\n    }));\n  }\n\n  private paginateResults(\n    results: SearchItem[],\n    offset: number,\n    limit: number\n  ): SearchItem[] {\n    return results.slice(offset, offset + limit);\n  }\n\n  private extractTexts(ops: PutOperation[]): {\n    [text: string]: [string[], string, string][];\n  } {\n    if (!ops.length || !this._indexConfig) {\n      return {};\n    }\n\n    const toEmbed: { [text: string]: [string[], string, string][] } = {};\n\n    for (const op of ops) {\n      if (op.value !== null && op.index !== false) {\n        const paths =\n          op.index === null || op.index === undefined\n            ? (this._indexConfig.__tokenizedFields ?? [])\n            : op.index.map(\n                (ix) => [ix, tokenizePath(ix)] as [string, string[]]\n              );\n        for (const [path, field] of paths) {\n          const texts = getTextAtPath(op.value, field);\n          if (texts.length) {\n            if (texts.length > 1) {\n              texts.forEach((text, i) => {\n                if (!toEmbed[text]) toEmbed[text] = [];\n                toEmbed[text].push([op.namespace, op.key, `${path}.${i}`]);\n              });\n            } else {\n              if (!toEmbed[texts[0]]) toEmbed[texts[0]] = [];\n              toEmbed[texts[0]].push([op.namespace, op.key, path]);\n            }\n          }\n        }\n      }\n    }\n\n    return toEmbed;\n  }\n\n  private insertVectors(\n    texts: { [text: string]: [string[], string, string][] },\n    embeddings: number[][]\n  ): void {\n    for (const [text, metadata] of Object.entries(texts)) {\n      const embedding = embeddings.shift();\n      if (!embedding) {\n        throw new Error(`No embedding found for text: ${text}`);\n      }\n\n      for (const [namespace, key, field] of metadata) {\n        const namespaceKey = namespace.join(\":\");\n        if (!this.vectors.has(namespaceKey)) {\n          this.vectors.set(namespaceKey, new Map());\n        }\n        const namespaceMap = this.vectors.get(namespaceKey)!;\n        if (!namespaceMap.has(key)) {\n          namespaceMap.set(key, new Map());\n        }\n        const itemMap = namespaceMap.get(key)!;\n        itemMap.set(field, embedding);\n      }\n    }\n  }\n\n  private getVectors(item: Item): number[][] {\n    const namespaceKey = item.namespace.join(\":\");\n    const itemKey = item.key;\n    if (!this.vectors.has(namespaceKey)) {\n      return [];\n    }\n    const namespaceMap = this.vectors.get(namespaceKey)!;\n    if (!namespaceMap.has(itemKey)) {\n      return [];\n    }\n    const itemMap = namespaceMap.get(itemKey)!;\n    const vectors = Array.from(itemMap.values());\n    if (!vectors.length) {\n      return [];\n    }\n    return vectors;\n  }\n\n  private cosineSimilarity(X: number[], Y: number[][]): number[] {\n    if (!Y.length) return [];\n\n    // Calculate dot products for all vectors at once\n    const dotProducts = Y.map((vector) =>\n      vector.reduce((acc, val, i) => acc + val * X[i], 0)\n    );\n\n    // Calculate magnitudes\n    const magnitude1 = Math.sqrt(X.reduce((acc, val) => acc + val * val, 0));\n    const magnitudes2 = Y.map((vector) =>\n      Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0))\n    );\n\n    // Calculate similarities\n    return dotProducts.map((dot, i) => {\n      const magnitude2 = magnitudes2[i];\n      return magnitude1 && magnitude2 ? dot / (magnitude1 * magnitude2) : 0;\n    });\n  }\n\n  public get indexConfig(): IndexConfig | undefined {\n    return this._indexConfig;\n  }\n}\n\n/** @deprecated Alias for InMemoryStore */\nexport class MemoryStore extends InMemoryStore {}\n"],"mappings":"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"}

package/dist/store/memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.cts","names":[],"sources":["../../src/store/memory.ts"],"mappings":";;;;;AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,aAAA,SAAsB,SAAA;EAAA,QACzB,IAAA;EAAA,QAGA,OAAA;EAAA,QAEA,YAAA;EAIR,WAAA,CAAY,OAAA;IAAY,KAAA,GAAQ,WAAA;EAAA;EAa1B,KAAA,qBAA0B,SAAA,GAAA,CAC9B,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;EAAA,QAkGpB,YAAA;EAAA,QAMA,YAAA;EAAA,QA2BA,uBAAA;EAAA,QA0BA,SAAA;EAAA,QAoBA,WAAA;EAAA,QAmBA,YAAA;EAAA,QA6DA,eAAA;EAAA,QAQA,YAAA;EAAA,QAqCA,aAAA;EAAA,QAyBA,UAAA;EAAA,QAkBA,gBAAA;EAAA,IAqBG,WAAA,CAAA,GAAe,WAAA;AAAA;;cAMf,WAAA,SAAoB,aAAA"}
+{"version":3,"file":"memory.d.cts","names":[],"sources":["../../src/store/memory.ts"],"mappings":";;;;;AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,aAAA,SAAsB,SAAA;EAAA,QACzB,IAAA;EAAA,QAGA,OAAA;EAAA,QAEA,YAAA;EAIR,WAAA,CAAY,OAAA;IAAY,KAAA,GAAQ,WAAA;EAAA;EAa1B,KAAA,qBAA0B,SAAA,GAAA,CAC9B,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;EAAA,QAsGpB,YAAA;EAAA,QAMA,YAAA;EAAA,QA2BA,uBAAA;EAAA,QA0BA,SAAA;EAAA,QAoBA,WAAA;EAAA,QA8BA,YAAA;EAAA,QA6DA,eAAA;EAAA,QAQA,YAAA;EAAA,QAqCA,aAAA;EAAA,QAyBA,UAAA;EAAA,QAkBA,gBAAA;EAAA,IAqBG,WAAA,CAAA,GAAe,WAAA;AAAA;;cAMf,WAAA,SAAoB,aAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","names":[],"sources":["../../src/store/memory.ts"],"mappings":";;;;;AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,aAAA,SAAsB,SAAA;EAAA,QACzB,IAAA;EAAA,QAGA,OAAA;EAAA,QAEA,YAAA;EAIR,WAAA,CAAY,OAAA;IAAY,KAAA,GAAQ,WAAA;EAAA;EAa1B,KAAA,qBAA0B,SAAA,GAAA,CAC9B,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;EAAA,QAkGpB,YAAA;EAAA,QAMA,YAAA;EAAA,QA2BA,uBAAA;EAAA,QA0BA,SAAA;EAAA,QAoBA,WAAA;EAAA,QAmBA,YAAA;EAAA,QA6DA,eAAA;EAAA,QAQA,YAAA;EAAA,QAqCA,aAAA;EAAA,QAyBA,UAAA;EAAA,QAkBA,gBAAA;EAAA,IAqBG,WAAA,CAAA,GAAe,WAAA;AAAA;;cAMf,WAAA,SAAoB,aAAA"}
+{"version":3,"file":"memory.d.ts","names":[],"sources":["../../src/store/memory.ts"],"mappings":";;;;;AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,aAAA,SAAsB,SAAA;EAAA,QACzB,IAAA;EAAA,QAGA,OAAA;EAAA,QAEA,YAAA;EAIR,WAAA,CAAY,OAAA;IAAY,KAAA,GAAQ,WAAA;EAAA;EAa1B,KAAA,qBAA0B,SAAA,GAAA,CAC9B,UAAA,EAAY,EAAA,GACX,OAAA,CAAQ,gBAAA,CAAiB,EAAA;EAAA,QAsGpB,YAAA;EAAA,QAMA,YAAA;EAAA,QA2BA,uBAAA;EAAA,QA0BA,SAAA;EAAA,QAoBA,WAAA;EAAA,QA8BA,YAAA;EAAA,QA6DA,eAAA;EAAA,QAQA,YAAA;EAAA,QAqCA,aAAA;EAAA,QAyBA,UAAA;EAAA,QAkBA,gBAAA;EAAA,IAqBG,WAAA,CAAA,GAAe,WAAA;AAAA;;cAMf,WAAA,SAAoB,aAAA"}

package/dist/store/memory.js

@@ -1,6 +1,10 @@
-import { BaseStore } from "./base.js";
+import { BaseStore, InvalidNamespaceError, validateNamespace } from "./base.js";
 import { compareValues, getTextAtPath, tokenizePath } from "./utils.js";
 //#region src/store/memory.ts
+function validateMemoryNamespace(namespace) {
+	validateNamespace(namespace, { allowReservedRoot: true });
+	if (namespace.some((label) => label.includes(":"))) throw new InvalidNamespaceError("Namespace labels cannot contain colons (':'), the InMemoryStore path separator.");
+}
 /**
 * In-memory key-value store with optional vector search.
 *
@@ -51,6 +55,7 @@ var InMemoryStore = class extends BaseStore {
 		const searchOps = /* @__PURE__ */ new Map();
 		for (let i = 0; i < operations.length; i += 1) {
 			const op = operations[i];
+			if ("namespace" in op) validateMemoryNamespace(op.namespace);
 			if ("key" in op && "namespace" in op && !("value" in op)) results.push(this.getOperation(op));
 			else if ("namespacePrefix" in op) {
 				const candidates = this.filterItems(op);
@@ -137,8 +142,10 @@ var InMemoryStore = class extends BaseStore {
 		throw new Error(`Unsupported match type: ${matchType}`);
 	}
 	filterItems(op) {
+		if (op.namespacePrefix.length > 0) validateMemoryNamespace(op.namespacePrefix);
+		const prefix = op.namespacePrefix.join(":");
 		const candidates = [];
-		for (const [namespace, items] of this.data.entries()) if (namespace.startsWith(op.namespacePrefix.join(":"))) candidates.push(...items.values());
+		for (const [namespace, items] of this.data.entries()) if (prefix === "" || namespace === prefix || namespace.startsWith(`${prefix}:`)) candidates.push(...items.values());
 		let filteredCandidates = candidates;
 		if (op.filter) filteredCandidates = candidates.filter((item) => Object.entries(op.filter).every(([key, value]) => compareValues(item.value[key], value)));
 		return filteredCandidates;

package/dist/store/memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory.js","names":[],"sources":["../../src/store/memory.ts"],"sourcesContent":["import {\n  BaseStore,\n  type OperationResults,\n  type Item,\n  type Operation,\n  MatchCondition,\n  ListNamespacesOperation,\n  PutOperation,\n  SearchOperation,\n  GetOperation,\n  type IndexConfig,\n  type SearchItem,\n} from \"./base.js\";\nimport { tokenizePath, compareValues, getTextAtPath } from \"./utils.js\";\n\n/**\n * In-memory key-value store with optional vector search.\n *\n * A lightweight store implementation using JavaScript Maps. Supports basic\n * key-value operations and vector search when configured with embeddings.\n *\n * @example\n * ```typescript\n * // Basic key-value storage\n * const store = new InMemoryStore();\n * await store.put([\"users\", \"123\"], \"prefs\", { theme: \"dark\" });\n * const item = await store.get([\"users\", \"123\"], \"prefs\");\n *\n * // Vector search with embeddings\n * import { OpenAIEmbeddings } from \"@langchain/openai\";\n * const store = new InMemoryStore({\n *   index: {\n *     dims: 1536,\n *     embeddings: new OpenAIEmbeddings({ modelName: \"text-embedding-3-small\" }),\n *   }\n * });\n *\n * // Store documents\n * await store.put([\"docs\"], \"doc1\", { text: \"Python tutorial\" });\n * await store.put([\"docs\"], \"doc2\", { text: \"TypeScript guide\" });\n *\n * // Search by similarity\n * const results = await store.search([\"docs\"], { query: \"python programming\" });\n * ```\n *\n * **Warning**: This store keeps all data in memory. Data is lost when the process exits.\n * For persistence, use a database-backed store.\n */\nexport class InMemoryStore extends BaseStore {\n  private data: Map<string, Map<string, Item>> = new Map();\n\n  // Namespace -> Key -> Path/field -> Vector\n  private vectors: Map<string, Map<string, Map<string, number[]>>> = new Map();\n\n  private _indexConfig?: IndexConfig & {\n    __tokenizedFields: Array<[string, string[]]>;\n  };\n\n  constructor(options?: { index?: IndexConfig }) {\n    super();\n    if (options?.index) {\n      this._indexConfig = {\n        ...options.index,\n        __tokenizedFields: (options.index.fields ?? [\"$\"]).map((p) => [\n          p,\n          p === \"$\" ? [p] : tokenizePath(p),\n        ]),\n      };\n    }\n  }\n\n  async batch<Op extends readonly Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>> {\n    const results = [];\n    const putOps = new Map<string, PutOperation>();\n    const searchOps = new Map<number, [SearchOperation, Item[]]>();\n\n    // First pass - handle gets and prepare search/put operations\n    for (let i = 0; i < operations.length; i += 1) {\n      const op = operations[i];\n      if (\"key\" in op && \"namespace\" in op && !(\"value\" in op)) {\n        // GetOperation\n        results.push(this.getOperation(op));\n      } else if (\"namespacePrefix\" in op) {\n        // SearchOperation\n        const candidates = this.filterItems(op);\n        searchOps.set(i, [op, candidates]);\n        results.push(null);\n      } else if (\"value\" in op) {\n        // PutOperation\n        const key = `${op.namespace.join(\":\")}:${op.key}`;\n        putOps.set(key, op);\n        results.push(null);\n      } else if (\"matchConditions\" in op) {\n        // ListNamespacesOperation\n        results.push(this.listNamespacesOperation(op));\n      }\n    }\n\n    // Handle search operations with embeddings\n    if (searchOps.size > 0) {\n      if (this._indexConfig?.embeddings) {\n        const queries = new Set<string>();\n        for (const [op] of searchOps.values()) {\n          if (op.query) queries.add(op.query);\n        }\n\n        // Get embeddings for all queries\n        const queryEmbeddings =\n          queries.size > 0\n            ? await Promise.all(\n                Array.from(queries).map((q) =>\n                  this._indexConfig!.embeddings.embedQuery(q)\n                )\n              )\n            : [];\n        const queryVectors = Object.fromEntries(\n          Array.from(queries).map((q, i) => [q, queryEmbeddings[i]])\n        );\n\n        // Process each search operation\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          if (op.query && queryVectors[op.query]) {\n            const queryVector = queryVectors[op.query];\n            const scoredResults = this.scoreResults(\n              candidates,\n              queryVector,\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n            results[i] = scoredResults;\n          } else {\n            results[i] = this.paginateResults(\n              candidates.map((item) => ({ ...item, score: undefined })),\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n          }\n        }\n      } else {\n        // No embeddings - just paginate the filtered results\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          results[i] = this.paginateResults(\n            candidates.map((item) => ({ ...item, score: undefined })),\n            op.offset ?? 0,\n            op.limit ?? 10\n          );\n        }\n      }\n    }\n\n    // Handle put operations with embeddings\n    if (putOps.size > 0 && this._indexConfig?.embeddings) {\n      const toEmbed = this.extractTexts(Array.from(putOps.values()));\n      if (Object.keys(toEmbed).length > 0) {\n        const embeddings = await this._indexConfig.embeddings.embedDocuments(\n          Object.keys(toEmbed)\n        );\n        this.insertVectors(toEmbed, embeddings);\n      }\n    }\n\n    // Apply all put operations\n    for (const op of putOps.values()) {\n      this.putOperation(op);\n    }\n\n    return results as OperationResults<Op>;\n  }\n\n  private getOperation(op: GetOperation): Item | null {\n    const namespaceKey = op.namespace.join(\":\");\n    const item = this.data.get(namespaceKey)?.get(op.key);\n    return item ?? null;\n  }\n\n  private putOperation(op: PutOperation): void {\n    const namespaceKey = op.namespace.join(\":\");\n    if (!this.data.has(namespaceKey)) {\n      this.data.set(namespaceKey, new Map());\n    }\n    const namespaceMap = this.data.get(namespaceKey)!;\n\n    if (op.value === null) {\n      namespaceMap.delete(op.key);\n    } else {\n      const now = new Date();\n      if (namespaceMap.has(op.key)) {\n        const item = namespaceMap.get(op.key)!;\n        item.value = op.value;\n        item.updatedAt = now;\n      } else {\n        namespaceMap.set(op.key, {\n          value: op.value,\n          key: op.key,\n          namespace: op.namespace,\n          createdAt: now,\n          updatedAt: now,\n        });\n      }\n    }\n  }\n\n  private listNamespacesOperation(op: ListNamespacesOperation): string[][] {\n    const allNamespaces = Array.from(this.data.keys()).map((ns) =>\n      ns.split(\":\")\n    );\n    let namespaces = allNamespaces;\n\n    if (op.matchConditions && op.matchConditions.length > 0) {\n      namespaces = namespaces.filter((ns) =>\n        op.matchConditions!.every((condition) => this.doesMatch(condition, ns))\n      );\n    }\n\n    if (op.maxDepth !== undefined) {\n      namespaces = Array.from(\n        new Set(namespaces.map((ns) => ns.slice(0, op.maxDepth).join(\":\")))\n      ).map((ns) => ns.split(\":\"));\n    }\n\n    namespaces.sort((a, b) => a.join(\":\").localeCompare(b.join(\":\")));\n\n    return namespaces.slice(\n      op.offset ?? 0,\n      (op.offset ?? 0) + (op.limit ?? namespaces.length)\n    );\n  }\n\n  private doesMatch(matchCondition: MatchCondition, key: string[]): boolean {\n    const { matchType, path } = matchCondition;\n\n    if (matchType === \"prefix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    } else if (matchType === \"suffix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[key.length - path.length + index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    }\n\n    throw new Error(`Unsupported match type: ${matchType}`);\n  }\n\n  private filterItems(op: SearchOperation): Item[] {\n    const candidates: Item[] = [];\n    for (const [namespace, items] of this.data.entries()) {\n      if (namespace.startsWith(op.namespacePrefix.join(\":\"))) {\n        candidates.push(...items.values());\n      }\n    }\n\n    let filteredCandidates = candidates;\n    if (op.filter) {\n      filteredCandidates = candidates.filter((item) =>\n        Object.entries(op.filter!).every(([key, value]) =>\n          compareValues(item.value[key], value)\n        )\n      );\n    }\n    return filteredCandidates;\n  }\n\n  private scoreResults(\n    candidates: Item[],\n    queryVector: number[],\n    offset: number = 0,\n    limit: number = 10\n  ): SearchItem[] {\n    const flatItems: Item[] = [];\n    const flatVectors: number[][] = [];\n    const scoreless: Item[] = [];\n\n    for (const item of candidates) {\n      const vectors = this.getVectors(item);\n      if (vectors.length) {\n        for (const vector of vectors) {\n          flatItems.push(item);\n          flatVectors.push(vector);\n        }\n      } else {\n        scoreless.push(item);\n      }\n    }\n\n    const scores = this.cosineSimilarity(queryVector, flatVectors);\n\n    const sortedResults = scores\n      .map((score, i) => [score, flatItems[i]] as [number, Item])\n      .sort((a, b) => b[0] - a[0]);\n\n    const seen = new Set<string>();\n    const kept: Array<[number | undefined, Item]> = [];\n\n    for (const [score, item] of sortedResults) {\n      const key = `${item.namespace.join(\":\")}:${item.key}`;\n      if (seen.has(key)) continue;\n\n      const ix = seen.size;\n      if (ix >= offset + limit) break;\n      if (ix < offset) {\n        seen.add(key);\n        continue;\n      }\n\n      seen.add(key);\n      kept.push([score, item]);\n    }\n\n    if (scoreless.length && kept.length < limit) {\n      for (const item of scoreless.slice(0, limit - kept.length)) {\n        const key = `${item.namespace.join(\":\")}:${item.key}`;\n        if (!seen.has(key)) {\n          seen.add(key);\n          kept.push([undefined, item]);\n        }\n      }\n    }\n    return kept.map(([score, item]) => ({\n      ...item,\n      score,\n    }));\n  }\n\n  private paginateResults(\n    results: SearchItem[],\n    offset: number,\n    limit: number\n  ): SearchItem[] {\n    return results.slice(offset, offset + limit);\n  }\n\n  private extractTexts(ops: PutOperation[]): {\n    [text: string]: [string[], string, string][];\n  } {\n    if (!ops.length || !this._indexConfig) {\n      return {};\n    }\n\n    const toEmbed: { [text: string]: [string[], string, string][] } = {};\n\n    for (const op of ops) {\n      if (op.value !== null && op.index !== false) {\n        const paths =\n          op.index === null || op.index === undefined\n            ? (this._indexConfig.__tokenizedFields ?? [])\n            : op.index.map(\n                (ix) => [ix, tokenizePath(ix)] as [string, string[]]\n              );\n        for (const [path, field] of paths) {\n          const texts = getTextAtPath(op.value, field);\n          if (texts.length) {\n            if (texts.length > 1) {\n              texts.forEach((text, i) => {\n                if (!toEmbed[text]) toEmbed[text] = [];\n                toEmbed[text].push([op.namespace, op.key, `${path}.${i}`]);\n              });\n            } else {\n              if (!toEmbed[texts[0]]) toEmbed[texts[0]] = [];\n              toEmbed[texts[0]].push([op.namespace, op.key, path]);\n            }\n          }\n        }\n      }\n    }\n\n    return toEmbed;\n  }\n\n  private insertVectors(\n    texts: { [text: string]: [string[], string, string][] },\n    embeddings: number[][]\n  ): void {\n    for (const [text, metadata] of Object.entries(texts)) {\n      const embedding = embeddings.shift();\n      if (!embedding) {\n        throw new Error(`No embedding found for text: ${text}`);\n      }\n\n      for (const [namespace, key, field] of metadata) {\n        const namespaceKey = namespace.join(\":\");\n        if (!this.vectors.has(namespaceKey)) {\n          this.vectors.set(namespaceKey, new Map());\n        }\n        const namespaceMap = this.vectors.get(namespaceKey)!;\n        if (!namespaceMap.has(key)) {\n          namespaceMap.set(key, new Map());\n        }\n        const itemMap = namespaceMap.get(key)!;\n        itemMap.set(field, embedding);\n      }\n    }\n  }\n\n  private getVectors(item: Item): number[][] {\n    const namespaceKey = item.namespace.join(\":\");\n    const itemKey = item.key;\n    if (!this.vectors.has(namespaceKey)) {\n      return [];\n    }\n    const namespaceMap = this.vectors.get(namespaceKey)!;\n    if (!namespaceMap.has(itemKey)) {\n      return [];\n    }\n    const itemMap = namespaceMap.get(itemKey)!;\n    const vectors = Array.from(itemMap.values());\n    if (!vectors.length) {\n      return [];\n    }\n    return vectors;\n  }\n\n  private cosineSimilarity(X: number[], Y: number[][]): number[] {\n    if (!Y.length) return [];\n\n    // Calculate dot products for all vectors at once\n    const dotProducts = Y.map((vector) =>\n      vector.reduce((acc, val, i) => acc + val * X[i], 0)\n    );\n\n    // Calculate magnitudes\n    const magnitude1 = Math.sqrt(X.reduce((acc, val) => acc + val * val, 0));\n    const magnitudes2 = Y.map((vector) =>\n      Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0))\n    );\n\n    // Calculate similarities\n    return dotProducts.map((dot, i) => {\n      const magnitude2 = magnitudes2[i];\n      return magnitude1 && magnitude2 ? dot / (magnitude1 * magnitude2) : 0;\n    });\n  }\n\n  public get indexConfig(): IndexConfig | undefined {\n    return this._indexConfig;\n  }\n}\n\n/** @deprecated Alias for InMemoryStore */\nexport class MemoryStore extends InMemoryStore {}\n"],"mappings":"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"}
+{"version":3,"file":"memory.js","names":[],"sources":["../../src/store/memory.ts"],"sourcesContent":["import {\n  BaseStore,\n  type OperationResults,\n  type Item,\n  type Operation,\n  MatchCondition,\n  ListNamespacesOperation,\n  PutOperation,\n  SearchOperation,\n  GetOperation,\n  type IndexConfig,\n  type SearchItem,\n  validateNamespace,\n  InvalidNamespaceError,\n} from \"./base.js\";\nimport { tokenizePath, compareValues, getTextAtPath } from \"./utils.js\";\n\nfunction validateMemoryNamespace(namespace: string[]): void {\n  validateNamespace(namespace, { allowReservedRoot: true });\n\n  if (namespace.some((label) => label.includes(\":\"))) {\n    throw new InvalidNamespaceError(\n      \"Namespace labels cannot contain colons (':'), the InMemoryStore path separator.\"\n    );\n  }\n}\n\n/**\n * In-memory key-value store with optional vector search.\n *\n * A lightweight store implementation using JavaScript Maps. Supports basic\n * key-value operations and vector search when configured with embeddings.\n *\n * @example\n * ```typescript\n * // Basic key-value storage\n * const store = new InMemoryStore();\n * await store.put([\"users\", \"123\"], \"prefs\", { theme: \"dark\" });\n * const item = await store.get([\"users\", \"123\"], \"prefs\");\n *\n * // Vector search with embeddings\n * import { OpenAIEmbeddings } from \"@langchain/openai\";\n * const store = new InMemoryStore({\n *   index: {\n *     dims: 1536,\n *     embeddings: new OpenAIEmbeddings({ modelName: \"text-embedding-3-small\" }),\n *   }\n * });\n *\n * // Store documents\n * await store.put([\"docs\"], \"doc1\", { text: \"Python tutorial\" });\n * await store.put([\"docs\"], \"doc2\", { text: \"TypeScript guide\" });\n *\n * // Search by similarity\n * const results = await store.search([\"docs\"], { query: \"python programming\" });\n * ```\n *\n * **Warning**: This store keeps all data in memory. Data is lost when the process exits.\n * For persistence, use a database-backed store.\n */\nexport class InMemoryStore extends BaseStore {\n  private data: Map<string, Map<string, Item>> = new Map();\n\n  // Namespace -> Key -> Path/field -> Vector\n  private vectors: Map<string, Map<string, Map<string, number[]>>> = new Map();\n\n  private _indexConfig?: IndexConfig & {\n    __tokenizedFields: Array<[string, string[]]>;\n  };\n\n  constructor(options?: { index?: IndexConfig }) {\n    super();\n    if (options?.index) {\n      this._indexConfig = {\n        ...options.index,\n        __tokenizedFields: (options.index.fields ?? [\"$\"]).map((p) => [\n          p,\n          p === \"$\" ? [p] : tokenizePath(p),\n        ]),\n      };\n    }\n  }\n\n  async batch<Op extends readonly Operation[]>(\n    operations: Op\n  ): Promise<OperationResults<Op>> {\n    const results = [];\n    const putOps = new Map<string, PutOperation>();\n    const searchOps = new Map<number, [SearchOperation, Item[]]>();\n\n    // First pass - handle gets and prepare search/put operations\n    for (let i = 0; i < operations.length; i += 1) {\n      const op = operations[i];\n\n      if (\"namespace\" in op) {\n        validateMemoryNamespace(op.namespace);\n      }\n      if (\"key\" in op && \"namespace\" in op && !(\"value\" in op)) {\n        // GetOperation\n        results.push(this.getOperation(op));\n      } else if (\"namespacePrefix\" in op) {\n        // SearchOperation\n        const candidates = this.filterItems(op);\n        searchOps.set(i, [op, candidates]);\n        results.push(null);\n      } else if (\"value\" in op) {\n        // PutOperation\n        const key = `${op.namespace.join(\":\")}:${op.key}`;\n        putOps.set(key, op);\n        results.push(null);\n      } else if (\"matchConditions\" in op) {\n        // ListNamespacesOperation\n        results.push(this.listNamespacesOperation(op));\n      }\n    }\n\n    // Handle search operations with embeddings\n    if (searchOps.size > 0) {\n      if (this._indexConfig?.embeddings) {\n        const queries = new Set<string>();\n        for (const [op] of searchOps.values()) {\n          if (op.query) queries.add(op.query);\n        }\n\n        // Get embeddings for all queries\n        const queryEmbeddings =\n          queries.size > 0\n            ? await Promise.all(\n                Array.from(queries).map((q) =>\n                  this._indexConfig!.embeddings.embedQuery(q)\n                )\n              )\n            : [];\n        const queryVectors = Object.fromEntries(\n          Array.from(queries).map((q, i) => [q, queryEmbeddings[i]])\n        );\n\n        // Process each search operation\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          if (op.query && queryVectors[op.query]) {\n            const queryVector = queryVectors[op.query];\n            const scoredResults = this.scoreResults(\n              candidates,\n              queryVector,\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n            results[i] = scoredResults;\n          } else {\n            results[i] = this.paginateResults(\n              candidates.map((item) => ({ ...item, score: undefined })),\n              op.offset ?? 0,\n              op.limit ?? 10\n            );\n          }\n        }\n      } else {\n        // No embeddings - just paginate the filtered results\n        for (const [i, [op, candidates]] of searchOps.entries()) {\n          results[i] = this.paginateResults(\n            candidates.map((item) => ({ ...item, score: undefined })),\n            op.offset ?? 0,\n            op.limit ?? 10\n          );\n        }\n      }\n    }\n\n    // Handle put operations with embeddings\n    if (putOps.size > 0 && this._indexConfig?.embeddings) {\n      const toEmbed = this.extractTexts(Array.from(putOps.values()));\n      if (Object.keys(toEmbed).length > 0) {\n        const embeddings = await this._indexConfig.embeddings.embedDocuments(\n          Object.keys(toEmbed)\n        );\n        this.insertVectors(toEmbed, embeddings);\n      }\n    }\n\n    // Apply all put operations\n    for (const op of putOps.values()) {\n      this.putOperation(op);\n    }\n\n    return results as OperationResults<Op>;\n  }\n\n  private getOperation(op: GetOperation): Item | null {\n    const namespaceKey = op.namespace.join(\":\");\n    const item = this.data.get(namespaceKey)?.get(op.key);\n    return item ?? null;\n  }\n\n  private putOperation(op: PutOperation): void {\n    const namespaceKey = op.namespace.join(\":\");\n    if (!this.data.has(namespaceKey)) {\n      this.data.set(namespaceKey, new Map());\n    }\n    const namespaceMap = this.data.get(namespaceKey)!;\n\n    if (op.value === null) {\n      namespaceMap.delete(op.key);\n    } else {\n      const now = new Date();\n      if (namespaceMap.has(op.key)) {\n        const item = namespaceMap.get(op.key)!;\n        item.value = op.value;\n        item.updatedAt = now;\n      } else {\n        namespaceMap.set(op.key, {\n          value: op.value,\n          key: op.key,\n          namespace: op.namespace,\n          createdAt: now,\n          updatedAt: now,\n        });\n      }\n    }\n  }\n\n  private listNamespacesOperation(op: ListNamespacesOperation): string[][] {\n    const allNamespaces = Array.from(this.data.keys()).map((ns) =>\n      ns.split(\":\")\n    );\n    let namespaces = allNamespaces;\n\n    if (op.matchConditions && op.matchConditions.length > 0) {\n      namespaces = namespaces.filter((ns) =>\n        op.matchConditions!.every((condition) => this.doesMatch(condition, ns))\n      );\n    }\n\n    if (op.maxDepth !== undefined) {\n      namespaces = Array.from(\n        new Set(namespaces.map((ns) => ns.slice(0, op.maxDepth).join(\":\")))\n      ).map((ns) => ns.split(\":\"));\n    }\n\n    namespaces.sort((a, b) => a.join(\":\").localeCompare(b.join(\":\")));\n\n    return namespaces.slice(\n      op.offset ?? 0,\n      (op.offset ?? 0) + (op.limit ?? namespaces.length)\n    );\n  }\n\n  private doesMatch(matchCondition: MatchCondition, key: string[]): boolean {\n    const { matchType, path } = matchCondition;\n\n    if (matchType === \"prefix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    } else if (matchType === \"suffix\") {\n      if (path.length > key.length) return false;\n      return path.every((pElem, index) => {\n        const kElem = key[key.length - path.length + index];\n        return pElem === \"*\" || kElem === pElem;\n      });\n    }\n\n    throw new Error(`Unsupported match type: ${matchType}`);\n  }\n\n  private filterItems(op: SearchOperation): Item[] {\n    if (op.namespacePrefix.length > 0) {\n      validateMemoryNamespace(op.namespacePrefix);\n    }\n\n    const prefix = op.namespacePrefix.join(\":\");\n    const candidates: Item[] = [];\n    for (const [namespace, items] of this.data.entries()) {\n      // Match exact namespaces and descendants at a segment boundary.\n      // An empty prefix searches all namespaces.\n      if (\n        prefix === \"\" ||\n        namespace === prefix ||\n        namespace.startsWith(`${prefix}:`)\n      ) {\n        candidates.push(...items.values());\n      }\n    }\n\n    let filteredCandidates = candidates;\n    if (op.filter) {\n      filteredCandidates = candidates.filter((item) =>\n        Object.entries(op.filter!).every(([key, value]) =>\n          compareValues(item.value[key], value)\n        )\n      );\n    }\n    return filteredCandidates;\n  }\n\n  private scoreResults(\n    candidates: Item[],\n    queryVector: number[],\n    offset: number = 0,\n    limit: number = 10\n  ): SearchItem[] {\n    const flatItems: Item[] = [];\n    const flatVectors: number[][] = [];\n    const scoreless: Item[] = [];\n\n    for (const item of candidates) {\n      const vectors = this.getVectors(item);\n      if (vectors.length) {\n        for (const vector of vectors) {\n          flatItems.push(item);\n          flatVectors.push(vector);\n        }\n      } else {\n        scoreless.push(item);\n      }\n    }\n\n    const scores = this.cosineSimilarity(queryVector, flatVectors);\n\n    const sortedResults = scores\n      .map((score, i) => [score, flatItems[i]] as [number, Item])\n      .sort((a, b) => b[0] - a[0]);\n\n    const seen = new Set<string>();\n    const kept: Array<[number | undefined, Item]> = [];\n\n    for (const [score, item] of sortedResults) {\n      const key = `${item.namespace.join(\":\")}:${item.key}`;\n      if (seen.has(key)) continue;\n\n      const ix = seen.size;\n      if (ix >= offset + limit) break;\n      if (ix < offset) {\n        seen.add(key);\n        continue;\n      }\n\n      seen.add(key);\n      kept.push([score, item]);\n    }\n\n    if (scoreless.length && kept.length < limit) {\n      for (const item of scoreless.slice(0, limit - kept.length)) {\n        const key = `${item.namespace.join(\":\")}:${item.key}`;\n        if (!seen.has(key)) {\n          seen.add(key);\n          kept.push([undefined, item]);\n        }\n      }\n    }\n    return kept.map(([score, item]) => ({\n      ...item,\n      score,\n    }));\n  }\n\n  private paginateResults(\n    results: SearchItem[],\n    offset: number,\n    limit: number\n  ): SearchItem[] {\n    return results.slice(offset, offset + limit);\n  }\n\n  private extractTexts(ops: PutOperation[]): {\n    [text: string]: [string[], string, string][];\n  } {\n    if (!ops.length || !this._indexConfig) {\n      return {};\n    }\n\n    const toEmbed: { [text: string]: [string[], string, string][] } = {};\n\n    for (const op of ops) {\n      if (op.value !== null && op.index !== false) {\n        const paths =\n          op.index === null || op.index === undefined\n            ? (this._indexConfig.__tokenizedFields ?? [])\n            : op.index.map(\n                (ix) => [ix, tokenizePath(ix)] as [string, string[]]\n              );\n        for (const [path, field] of paths) {\n          const texts = getTextAtPath(op.value, field);\n          if (texts.length) {\n            if (texts.length > 1) {\n              texts.forEach((text, i) => {\n                if (!toEmbed[text]) toEmbed[text] = [];\n                toEmbed[text].push([op.namespace, op.key, `${path}.${i}`]);\n              });\n            } else {\n              if (!toEmbed[texts[0]]) toEmbed[texts[0]] = [];\n              toEmbed[texts[0]].push([op.namespace, op.key, path]);\n            }\n          }\n        }\n      }\n    }\n\n    return toEmbed;\n  }\n\n  private insertVectors(\n    texts: { [text: string]: [string[], string, string][] },\n    embeddings: number[][]\n  ): void {\n    for (const [text, metadata] of Object.entries(texts)) {\n      const embedding = embeddings.shift();\n      if (!embedding) {\n        throw new Error(`No embedding found for text: ${text}`);\n      }\n\n      for (const [namespace, key, field] of metadata) {\n        const namespaceKey = namespace.join(\":\");\n        if (!this.vectors.has(namespaceKey)) {\n          this.vectors.set(namespaceKey, new Map());\n        }\n        const namespaceMap = this.vectors.get(namespaceKey)!;\n        if (!namespaceMap.has(key)) {\n          namespaceMap.set(key, new Map());\n        }\n        const itemMap = namespaceMap.get(key)!;\n        itemMap.set(field, embedding);\n      }\n    }\n  }\n\n  private getVectors(item: Item): number[][] {\n    const namespaceKey = item.namespace.join(\":\");\n    const itemKey = item.key;\n    if (!this.vectors.has(namespaceKey)) {\n      return [];\n    }\n    const namespaceMap = this.vectors.get(namespaceKey)!;\n    if (!namespaceMap.has(itemKey)) {\n      return [];\n    }\n    const itemMap = namespaceMap.get(itemKey)!;\n    const vectors = Array.from(itemMap.values());\n    if (!vectors.length) {\n      return [];\n    }\n    return vectors;\n  }\n\n  private cosineSimilarity(X: number[], Y: number[][]): number[] {\n    if (!Y.length) return [];\n\n    // Calculate dot products for all vectors at once\n    const dotProducts = Y.map((vector) =>\n      vector.reduce((acc, val, i) => acc + val * X[i], 0)\n    );\n\n    // Calculate magnitudes\n    const magnitude1 = Math.sqrt(X.reduce((acc, val) => acc + val * val, 0));\n    const magnitudes2 = Y.map((vector) =>\n      Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0))\n    );\n\n    // Calculate similarities\n    return dotProducts.map((dot, i) => {\n      const magnitude2 = magnitudes2[i];\n      return magnitude1 && magnitude2 ? dot / (magnitude1 * magnitude2) : 0;\n    });\n  }\n\n  public get indexConfig(): IndexConfig | undefined {\n    return this._indexConfig;\n  }\n}\n\n/** @deprecated Alias for InMemoryStore */\nexport class MemoryStore extends InMemoryStore {}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-checkpoint",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Library with base interfaces for LangGraph checkpoint savers.",
   "type": "module",
   "engines": {
@@ -26,7 +26,7 @@
     "rollup": "^4.62.3",
     "tsx": "^4.19.3",
     "typescript": "^4.9.5 || ^5.4.5",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.11"
   },
   "publishConfig": {
     "access": "public",