memvault 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iamsaad640
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# memvault
+
+[![npm version](https://img.shields.io/npm/v/memvault?color=blue)](https://www.npmjs.com/package/memvault)
+[![TypeScript](https://img.shields.io/badge/TypeScript-6.0-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Prisma](https://img.shields.io/badge/Prisma-7-2D3748?logo=prisma&logoColor=white)](https://www.prisma.io/)
+[![Tests](https://img.shields.io/badge/tests-58%20passing-brightgreen)](https://github.com/iamsaad640/memvault)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Vercel AI SDK](https://img.shields.io/badge/Vercel%20AI%20SDK-6-black?logo=vercel)](https://ai-sdk.dev)
+[![OpenAI](https://img.shields.io/badge/OpenAI-supported-412991?logo=openai&logoColor=white)](https://platform.openai.com)
+[![Anthropic](https://img.shields.io/badge/Anthropic-supported-d4a574?logo=anthropic&logoColor=white)](https://docs.anthropic.com)
+
+> Persistent, tenant-isolated memory tools for AI agents. Prisma-powered. Drop-in tools for Vercel AI SDK, OpenAI, and Anthropic.
+
+**No cloud. No Neo4j. No $249/mo paywall. Just your PostgreSQL.**
+
+## Install
+
+```bash
+npm install memvault
+```
+
+## Setup
+
+### 1. Add the model to your Prisma schema
+
+```prisma
+model MemvaultMemory {
+  id        String   @id @default(cuid())
+  tenantId  String
+  type      String   @default("general")
+  content   String
+  metadata  Json?
+  tags      String[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  expiresAt DateTime?
+
+  @@index([tenantId])
+  @@index([tenantId, type])
+  @@map("memvault_memories")
+}
+```
+
+### 2. Run migration
+
+```bash
+npx prisma migrate dev --name add-memvault
+```
+
+### 3. Create vault instance
+
+```typescript
+import { MemVault } from "memvault"
+
+const vault = new MemVault({ db: prisma.memvaultMemory })
+```
+
+## Usage with AI SDKs
+
+### Vercel AI SDK
+
+```typescript
+import { createMemVaultTools } from "memvault/ai-sdk"
+import { generateText } from "ai"
+import { anthropic } from "@ai-sdk/anthropic"
+
+const tools = createMemVaultTools({ vault, tenantId: user.id })
+
+const result = await generateText({
+  model: anthropic("claude-sonnet-4-6"),
+  tools,
+  prompt: "Help the user with their project"
+})
+```
+
+### OpenAI SDK
+
+```typescript
+import { createMemVaultTools } from "memvault/openai"
+
+const { tools, handleToolCall } = createMemVaultTools({ vault, tenantId: user.id })
+
+const response = await openai.responses.create({
+  model: "gpt-4o",
+  tools,
+  input: "Help the user..."
+})
+
+// Handle tool calls from the response
+for (const output of response.output) {
+  if (output.type === "function_call") {
+    const result = await handleToolCall(output.name, JSON.parse(output.arguments))
+  }
+}
+```
+
+### Anthropic SDK
+
+```typescript
+import { createMemVaultTools } from "memvault/anthropic"
+
+const { tools, handleToolCall } = createMemVaultTools({ vault, tenantId: user.id })
+
+const message = await anthropic.messages.create({
+  model: "claude-sonnet-4-6",
+  max_tokens: 1024,
+  tools,
+  messages: [{ role: "user", content: "Help me..." }]
+})
+
+// Handle tool calls from the response
+for (const block of message.content) {
+  if (block.type === "tool_use") {
+    const result = await handleToolCall(block.name, block.input)
+  }
+}
+```
+
+### Standalone (no LLM)
+
+```typescript
+const tenant = vault.tenant("user-123")
+
+await tenant.remember({
+  content: "Prefers dark mode",
+  type: "preference",
+  tags: ["ui", "theme"]
+})
+
+const memories = await tenant.recall({ type: "preference" })
+await tenant.update(memoryId, { content: "Switched to light mode" })
+await tenant.forget(memoryId)
+```
+
+## Tools Provided
+
+Each SDK integration provides 4 tools:
+
+| Tool | Description |
+|------|-------------|
+| `memvault_remember` | Save information to persistent memory |
+| `memvault_recall` | Retrieve relevant memories with filters |
+| `memvault_update` | Update existing memories |
+| `memvault_forget` | Delete a specific memory |
+
+The LLM decides when to use each tool based on the built-in descriptions.
+
+## Tenant Isolation
+
+Every operation is scoped to a `tenantId`. No tenant can read, update, or delete another tenant's memories.
+
+```typescript
+const alice = vault.tenant("alice")
+const bob = vault.tenant("bob")
+
+await alice.remember({ content: "Alice's secret" })
+await bob.recall() // Returns empty — Bob can't see Alice's memories
+```
+
+## Memory Types
+
+Organize memories by type:
+
+- `preference` — User preferences and settings
+- `fact` — Facts about the user
+- `feedback` — User feedback on behavior
+- `project` — Project context and details
+- `reference` — Links and external references
+- `general` — Default catch-all
+- Any custom string
+
+## TTL (Time-to-Live)
+
+Set temporary memories that auto-expire:
+
+```typescript
+await tenant.remember({
+  content: "Currently debugging auth flow",
+  type: "context",
+  ttl: 3600 // expires in 1 hour
+})
+```
+
+## API
+
+### `MemVault`
+
+- `new MemVault({ db })` — Create instance with Prisma delegate
+- `vault.tenant(tenantId)` — Get tenant-scoped vault
+
+### `TenantVault`
+
+- `tenant.remember(input)` — Save a memory
+- `tenant.recall(filter?)` — Query memories
+- `tenant.get(id)` — Get specific memory
+- `tenant.update(id, input)` — Update a memory
+- `tenant.forget(id)` — Delete a memory
+- `tenant.forgetAll()` — Delete all tenant memories
+- `tenant.count(filter?)` — Count memories
+
+## License
+
+MIT

package/dist/chunk-JJHMEQOW.js

@@ -0,0 +1,136 @@
+// src/tenant.ts
+var TenantVault = class {
+  constructor(db, tenantId) {
+    this.db = db;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Save a memory for this tenant.
+   */
+  async remember(input) {
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = input.ttl != null ? new Date(now.getTime() + input.ttl * 1e3) : null;
+    return this.db.create({
+      data: {
+        tenantId: this.tenantId,
+        content: input.content,
+        type: input.type ?? "general",
+        metadata: input.metadata ?? null,
+        tags: input.tags ?? [],
+        expiresAt
+      }
+    });
+  }
+  /**
+   * Retrieve memories for this tenant, with optional filters.
+   * Expired memories are excluded by default.
+   */
+  async recall(filter) {
+    const where = this.buildWhere(filter);
+    return this.db.findMany({
+      where,
+      orderBy: { createdAt: "desc" },
+      take: filter?.limit
+    });
+  }
+  /**
+   * Get a specific memory by ID. Returns null if not found or belongs to another tenant.
+   */
+  async get(id) {
+    const memory = await this.db.findUnique({ where: { id } });
+    if (!memory || memory.tenantId !== this.tenantId) return null;
+    return memory;
+  }
+  /**
+   * Update an existing memory. Only updates fields that are provided.
+   * Throws if the memory doesn't exist or belongs to another tenant.
+   */
+  async update(id, input) {
+    const existing = await this.get(id);
+    if (!existing) {
+      throw new Error(`Memory "${id}" not found for tenant "${this.tenantId}"`);
+    }
+    const data = {};
+    if (input.content !== void 0) data.content = input.content;
+    if (input.type !== void 0) data.type = input.type;
+    if (input.metadata !== void 0) data.metadata = input.metadata;
+    if (input.tags !== void 0) data.tags = input.tags;
+    if (input.ttl !== void 0) {
+      data.expiresAt = input.ttl === null ? null : new Date(Date.now() + input.ttl * 1e3);
+    }
+    return this.db.update({ where: { id }, data });
+  }
+  /**
+   * Delete a specific memory. Silently succeeds if memory doesn't exist.
+   */
+  async forget(id) {
+    const existing = await this.get(id);
+    if (!existing) return;
+    await this.db.delete({ where: { id } });
+  }
+  /**
+   * Delete all memories for this tenant. Returns the count of deleted records.
+   */
+  async forgetAll() {
+    const result = await this.db.deleteMany({
+      where: { tenantId: this.tenantId }
+    });
+    return result.count;
+  }
+  /**
+   * Count memories for this tenant with optional filters.
+   */
+  async count(filter) {
+    const where = this.buildWhere(filter);
+    return this.db.count({ where });
+  }
+  /**
+   * Build a Prisma where clause scoped to this tenant.
+   */
+  buildWhere(filter) {
+    const where = {
+      tenantId: this.tenantId
+    };
+    if (filter?.type) {
+      where.type = filter.type;
+    }
+    if (filter?.tags && filter.tags.length > 0) {
+      where.tags = { hasSome: filter.tags };
+    }
+    if (filter?.search) {
+      where.content = { contains: filter.search, mode: "insensitive" };
+    }
+    if (!filter?.includeExpired) {
+      where.OR = [{ expiresAt: null }, { expiresAt: { gt: /* @__PURE__ */ new Date() } }];
+    }
+    return where;
+  }
+};
+
+// src/memvault.ts
+var MemVault = class {
+  config;
+  constructor(config) {
+    if (!config.db) {
+      throw new Error(
+        "MemVault requires a Prisma delegate. Pass { db: prisma.memvaultMemory }"
+      );
+    }
+    this.config = config;
+  }
+  /**
+   * Get a tenant-scoped vault. All operations are isolated to this tenant.
+   */
+  tenant(tenantId) {
+    if (!tenantId || typeof tenantId !== "string") {
+      throw new Error("tenantId must be a non-empty string");
+    }
+    return new TenantVault(this.config.db, tenantId);
+  }
+};
+
+export {
+  TenantVault,
+  MemVault
+};
+//# sourceMappingURL=chunk-JJHMEQOW.js.map

package/dist/chunk-JJHMEQOW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tenant.ts","../src/memvault.ts"],"sourcesContent":["import type {\n  Memory,\n  MemoryInput,\n  MemoryUpdate,\n  MemoryFilter,\n  MemvaultPrismaDelegate,\n  TenantVaultInstance,\n} from \"./types.js\";\n\n/**\n * All operations are scoped to a single tenant.\n * No query can ever leak across tenant boundaries.\n */\nexport class TenantVault implements TenantVaultInstance {\n  constructor(\n    private readonly db: MemvaultPrismaDelegate,\n    public readonly tenantId: string,\n  ) {}\n\n  /**\n   * Save a memory for this tenant.\n   */\n  async remember(input: MemoryInput): Promise<Memory> {\n    const now = new Date();\n    const expiresAt =\n      input.ttl != null ? new Date(now.getTime() + input.ttl * 1000) : null;\n\n    return this.db.create({\n      data: {\n        tenantId: this.tenantId,\n        content: input.content,\n        type: input.type ?? \"general\",\n        metadata: input.metadata ?? null,\n        tags: input.tags ?? [],\n        expiresAt,\n      },\n    });\n  }\n\n  /**\n   * Retrieve memories for this tenant, with optional filters.\n   * Expired memories are excluded by default.\n   */\n  async recall(filter?: MemoryFilter): Promise<Memory[]> {\n    const where = this.buildWhere(filter);\n\n    return this.db.findMany({\n      where,\n      orderBy: { createdAt: \"desc\" },\n      take: filter?.limit,\n    });\n  }\n\n  /**\n   * Get a specific memory by ID. Returns null if not found or belongs to another tenant.\n   */\n  async get(id: string): Promise<Memory | null> {\n    const memory = await this.db.findUnique({ where: { id } });\n    if (!memory || memory.tenantId !== this.tenantId) return null;\n    return memory;\n  }\n\n  /**\n   * Update an existing memory. Only updates fields that are provided.\n   * Throws if the memory doesn't exist or belongs to another tenant.\n   */\n  async update(id: string, input: MemoryUpdate): Promise<Memory> {\n    const existing = await this.get(id);\n    if (!existing) {\n      throw new Error(`Memory \"${id}\" not found for tenant \"${this.tenantId}\"`);\n    }\n\n    const data: Record<string, unknown> = {};\n    if (input.content !== undefined) data.content = input.content;\n    if (input.type !== undefined) data.type = input.type;\n    if (input.metadata !== undefined) data.metadata = input.metadata;\n    if (input.tags !== undefined) data.tags = input.tags;\n    if (input.ttl !== undefined) {\n      data.expiresAt =\n        input.ttl === null\n          ? null\n          : new Date(Date.now() + input.ttl * 1000);\n    }\n\n    return this.db.update({ where: { id }, data });\n  }\n\n  /**\n   * Delete a specific memory. Silently succeeds if memory doesn't exist.\n   */\n  async forget(id: string): Promise<void> {\n    const existing = await this.get(id);\n    if (!existing) return;\n    await this.db.delete({ where: { id } });\n  }\n\n  /**\n   * Delete all memories for this tenant. Returns the count of deleted records.\n   */\n  async forgetAll(): Promise<number> {\n    const result = await this.db.deleteMany({\n      where: { tenantId: this.tenantId },\n    });\n    return result.count;\n  }\n\n  /**\n   * Count memories for this tenant with optional filters.\n   */\n  async count(filter?: MemoryFilter): Promise<number> {\n    const where = this.buildWhere(filter);\n    return this.db.count({ where });\n  }\n\n  /**\n   * Build a Prisma where clause scoped to this tenant.\n   */\n  private buildWhere(filter?: MemoryFilter): Record<string, unknown> {\n    const where: Record<string, unknown> = {\n      tenantId: this.tenantId,\n    };\n\n    if (filter?.type) {\n      where.type = filter.type;\n    }\n\n    if (filter?.tags && filter.tags.length > 0) {\n      where.tags = { hasSome: filter.tags };\n    }\n\n    if (filter?.search) {\n      where.content = { contains: filter.search, mode: \"insensitive\" };\n    }\n\n    if (!filter?.includeExpired) {\n      where.OR = [{ expiresAt: null }, { expiresAt: { gt: new Date() } }];\n    }\n\n    return where;\n  }\n}\n","import type { MemVaultConfig, MemVaultInstance } from \"./types.js\";\nimport { TenantVault } from \"./tenant.js\";\n\n/**\n * MemVault — persistent, tenant-isolated memory for AI agents.\n *\n * Usage:\n * ```ts\n * const vault = new MemVault({ db: prisma.memvaultMemory })\n * const tenant = vault.tenant(\"user-123\")\n * await tenant.remember({ content: \"Prefers dark mode\", type: \"preference\" })\n * ```\n */\nexport class MemVault implements MemVaultInstance {\n  private readonly config: MemVaultConfig;\n\n  constructor(config: MemVaultConfig) {\n    if (!config.db) {\n      throw new Error(\n        \"MemVault requires a Prisma delegate. Pass { db: prisma.memvaultMemory }\",\n      );\n    }\n    this.config = config;\n  }\n\n  /**\n   * Get a tenant-scoped vault. All operations are isolated to this tenant.\n   */\n  tenant(tenantId: string): TenantVault {\n    if (!tenantId || typeof tenantId !== \"string\") {\n      throw new Error(\"tenantId must be a non-empty string\");\n    }\n    return new TenantVault(this.config.db, tenantId);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { T as TenantVaultInstance, M as MemvaultPrismaDelegate, a as MemoryInput, b as Memory, c as MemoryFilter, d as MemoryUpdate, e as MemVaultInstance, f as MemVaultConfig } from './types-BbBXYjeB.js';
+export { g as ToolsConfig } from './types-BbBXYjeB.js';
+
+/**
+ * All operations are scoped to a single tenant.
+ * No query can ever leak across tenant boundaries.
+ */
+declare class TenantVault implements TenantVaultInstance {
+    private readonly db;
+    readonly tenantId: string;
+    constructor(db: MemvaultPrismaDelegate, tenantId: string);
+    /**
+     * Save a memory for this tenant.
+     */
+    remember(input: MemoryInput): Promise<Memory>;
+    /**
+     * Retrieve memories for this tenant, with optional filters.
+     * Expired memories are excluded by default.
+     */
+    recall(filter?: MemoryFilter): Promise<Memory[]>;
+    /**
+     * Get a specific memory by ID. Returns null if not found or belongs to another tenant.
+     */
+    get(id: string): Promise<Memory | null>;
+    /**
+     * Update an existing memory. Only updates fields that are provided.
+     * Throws if the memory doesn't exist or belongs to another tenant.
+     */
+    update(id: string, input: MemoryUpdate): Promise<Memory>;
+    /**
+     * Delete a specific memory. Silently succeeds if memory doesn't exist.
+     */
+    forget(id: string): Promise<void>;
+    /**
+     * Delete all memories for this tenant. Returns the count of deleted records.
+     */
+    forgetAll(): Promise<number>;
+    /**
+     * Count memories for this tenant with optional filters.
+     */
+    count(filter?: MemoryFilter): Promise<number>;
+    /**
+     * Build a Prisma where clause scoped to this tenant.
+     */
+    private buildWhere;
+}
+
+/**
+ * MemVault — persistent, tenant-isolated memory for AI agents.
+ *
+ * Usage:
+ * ```ts
+ * const vault = new MemVault({ db: prisma.memvaultMemory })
+ * const tenant = vault.tenant("user-123")
+ * await tenant.remember({ content: "Prefers dark mode", type: "preference" })
+ * ```
+ */
+declare class MemVault implements MemVaultInstance {
+    private readonly config;
+    constructor(config: MemVaultConfig);
+    /**
+     * Get a tenant-scoped vault. All operations are isolated to this tenant.
+     */
+    tenant(tenantId: string): TenantVault;
+}
+
+export { MemVault, MemVaultConfig, MemVaultInstance, Memory, MemoryFilter, MemoryInput, MemoryUpdate, MemvaultPrismaDelegate, TenantVault, TenantVaultInstance };

package/dist/index.js

@@ -0,0 +1,9 @@
+import {
+  MemVault,
+  TenantVault
+} from "./chunk-JJHMEQOW.js";
+export {
+  MemVault,
+  TenantVault
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/integrations/ai-sdk.d.ts

@@ -0,0 +1,64 @@
+import * as ai from 'ai';
+import { g as ToolsConfig } from '../types-BbBXYjeB.js';
+
+/**
+ * Create drop-in memory tools for the Vercel AI SDK.
+ *
+ * Usage:
+ * ```ts
+ * import { createMemVaultTools } from "memvault/ai-sdk"
+ *
+ * const tools = createMemVaultTools({ vault, tenantId: user.id })
+ *
+ * const result = await generateText({
+ *   model: anthropic("claude-sonnet-4-6"),
+ *   tools,
+ *   prompt: "Help the user..."
+ * })
+ * ```
+ */
+declare function createMemVaultTools(config: ToolsConfig): {
+    memvault_remember: ai.Tool<{
+        content: string;
+        type?: string | undefined;
+        tags?: string[] | undefined;
+        ttl?: number | undefined;
+    }, {
+        success: boolean;
+        id: string;
+        message: string;
+    }>;
+    memvault_recall: ai.Tool<{
+        type?: string | undefined;
+        tags?: string[] | undefined;
+        search?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        count: number;
+        memories: {
+            id: string;
+            type: string;
+            content: string;
+            tags: string[];
+            createdAt: string;
+        }[];
+    }>;
+    memvault_forget: ai.Tool<{
+        id: string;
+    }, {
+        success: boolean;
+        message: string;
+    }>;
+    memvault_update: ai.Tool<{
+        id: string;
+        content?: string | undefined;
+        type?: string | undefined;
+        tags?: string[] | undefined;
+    }, {
+        success: boolean;
+        id: string;
+        message: string;
+    }>;
+};
+
+export { createMemVaultTools };

package/dist/integrations/ai-sdk.js

@@ -0,0 +1,95 @@
+import "../chunk-JJHMEQOW.js";
+
+// src/integrations/ai-sdk.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createMemVaultTools(config) {
+  const tenant = config.vault.tenant(config.tenantId);
+  return {
+    memvault_remember: tool({
+      description: "Save important information to persistent memory for this user. Use this when the user shares preferences, facts about themselves, project context, feedback, or anything worth remembering across sessions. Memories persist permanently unless given a TTL.",
+      inputSchema: z.object({
+        content: z.string().describe("The information to remember. Be specific and concise."),
+        type: z.string().optional().describe(
+          'Category: "preference", "fact", "feedback", "project", "reference", or any custom type. Defaults to "general".'
+        ),
+        tags: z.array(z.string()).optional().describe("Tags for categorization and filtering, e.g. ['ui', 'theme']"),
+        ttl: z.number().optional().describe(
+          "Time-to-live in seconds. Omit for permanent memory. Use for temporary/session info."
+        )
+      }),
+      execute: async (input) => {
+        const memory = await tenant.remember({
+          content: input.content,
+          type: input.type,
+          tags: input.tags,
+          ttl: input.ttl
+        });
+        return {
+          success: true,
+          id: memory.id,
+          message: `Remembered: "${memory.content}" (type: ${memory.type})`
+        };
+      }
+    }),
+    memvault_recall: tool({
+      description: "Retrieve memories for this user. Use this BEFORE responding when you need context about the user's preferences, past conversations, project details, or any previously saved information. Always recall relevant memories to personalize your responses.",
+      inputSchema: z.object({
+        type: z.string().optional().describe("Filter by memory type, e.g. 'preference', 'project'"),
+        tags: z.array(z.string()).optional().describe("Filter by tags \u2014 returns memories matching ANY of these tags"),
+        search: z.string().optional().describe("Search memory content (case-insensitive substring match)"),
+        limit: z.number().optional().describe("Max number of memories to return. Defaults to all.")
+      }),
+      execute: async (input) => {
+        const memories = await tenant.recall({
+          type: input.type,
+          tags: input.tags,
+          search: input.search,
+          limit: input.limit
+        });
+        return {
+          count: memories.length,
+          memories: memories.map((m) => ({
+            id: m.id,
+            type: m.type,
+            content: m.content,
+            tags: m.tags,
+            createdAt: m.createdAt.toISOString()
+          }))
+        };
+      }
+    }),
+    memvault_forget: tool({
+      description: "Delete a specific memory by ID. Use when the user asks to forget something or when information is outdated and should be removed.",
+      inputSchema: z.object({
+        id: z.string().describe("The memory ID to delete")
+      }),
+      execute: async (input) => {
+        await tenant.forget(input.id);
+        return { success: true, message: `Memory ${input.id} deleted.` };
+      }
+    }),
+    memvault_update: tool({
+      description: "Update an existing memory. Use when information has changed and the old memory should be corrected rather than deleted and re-created.",
+      inputSchema: z.object({
+        id: z.string().describe("The memory ID to update"),
+        content: z.string().optional().describe("New content to replace the existing memory content"),
+        type: z.string().optional().describe("New type for the memory"),
+        tags: z.array(z.string()).optional().describe("New tags (replaces existing tags)")
+      }),
+      execute: async (input) => {
+        const { id, ...updates } = input;
+        const memory = await tenant.update(id, updates);
+        return {
+          success: true,
+          id: memory.id,
+          message: `Updated memory: "${memory.content}"`
+        };
+      }
+    })
+  };
+}
+export {
+  createMemVaultTools
+};
+//# sourceMappingURL=ai-sdk.js.map

package/dist/integrations/ai-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/integrations/ai-sdk.ts"],"sourcesContent":["import { tool } from \"ai\";\nimport { z } from \"zod\";\nimport { MemVault } from \"../memvault.js\";\nimport type { ToolsConfig } from \"../types.js\";\n\n/**\n * Create drop-in memory tools for the Vercel AI SDK.\n *\n * Usage:\n * ```ts\n * import { createMemVaultTools } from \"memvault/ai-sdk\"\n *\n * const tools = createMemVaultTools({ vault, tenantId: user.id })\n *\n * const result = await generateText({\n *   model: anthropic(\"claude-sonnet-4-6\"),\n *   tools,\n *   prompt: \"Help the user...\"\n * })\n * ```\n */\nexport function createMemVaultTools(config: ToolsConfig) {\n  const tenant = config.vault.tenant(config.tenantId);\n\n  return {\n    memvault_remember: tool({\n      description:\n        \"Save important information to persistent memory for this user. \" +\n        \"Use this when the user shares preferences, facts about themselves, \" +\n        \"project context, feedback, or anything worth remembering across sessions. \" +\n        \"Memories persist permanently unless given a TTL.\",\n      inputSchema: z.object({\n        content: z\n          .string()\n          .describe(\"The information to remember. Be specific and concise.\"),\n        type: z\n          .string()\n          .optional()\n          .describe(\n            'Category: \"preference\", \"fact\", \"feedback\", \"project\", \"reference\", or any custom type. Defaults to \"general\".',\n          ),\n        tags: z\n          .array(z.string())\n          .optional()\n          .describe(\"Tags for categorization and filtering, e.g. ['ui', 'theme']\"),\n        ttl: z\n          .number()\n          .optional()\n          .describe(\n            \"Time-to-live in seconds. Omit for permanent memory. Use for temporary/session info.\",\n          ),\n      }),\n      execute: async (input) => {\n        const memory = await tenant.remember({\n          content: input.content,\n          type: input.type,\n          tags: input.tags,\n          ttl: input.ttl,\n        });\n        return {\n          success: true,\n          id: memory.id,\n          message: `Remembered: \"${memory.content}\" (type: ${memory.type})`,\n        };\n      },\n    }),\n\n    memvault_recall: tool({\n      description:\n        \"Retrieve memories for this user. Use this BEFORE responding when you need \" +\n        \"context about the user's preferences, past conversations, project details, \" +\n        \"or any previously saved information. Always recall relevant memories to \" +\n        \"personalize your responses.\",\n      inputSchema: z.object({\n        type: z\n          .string()\n          .optional()\n          .describe(\"Filter by memory type, e.g. 'preference', 'project'\"),\n        tags: z\n          .array(z.string())\n          .optional()\n          .describe(\"Filter by tags — returns memories matching ANY of these tags\"),\n        search: z\n          .string()\n          .optional()\n          .describe(\"Search memory content (case-insensitive substring match)\"),\n        limit: z\n          .number()\n          .optional()\n          .describe(\"Max number of memories to return. Defaults to all.\"),\n      }),\n      execute: async (input) => {\n        const memories = await tenant.recall({\n          type: input.type,\n          tags: input.tags,\n          search: input.search,\n          limit: input.limit,\n        });\n        return {\n          count: memories.length,\n          memories: memories.map((m) => ({\n            id: m.id,\n            type: m.type,\n            content: m.content,\n            tags: m.tags,\n            createdAt: m.createdAt.toISOString(),\n          })),\n        };\n      },\n    }),\n\n    memvault_forget: tool({\n      description:\n        \"Delete a specific memory by ID. Use when the user asks to forget something \" +\n        \"or when information is outdated and should be removed.\",\n      inputSchema: z.object({\n        id: z.string().describe(\"The memory ID to delete\"),\n      }),\n      execute: async (input) => {\n        await tenant.forget(input.id);\n        return { success: true, message: `Memory ${input.id} deleted.` };\n      },\n    }),\n\n    memvault_update: tool({\n      description:\n        \"Update an existing memory. Use when information has changed and the old \" +\n        \"memory should be corrected rather than deleted and re-created.\",\n      inputSchema: z.object({\n        id: z.string().describe(\"The memory ID to update\"),\n        content: z\n          .string()\n          .optional()\n          .describe(\"New content to replace the existing memory content\"),\n        type: z.string().optional().describe(\"New type for the memory\"),\n        tags: z\n          .array(z.string())\n          .optional()\n          .describe(\"New tags (replaces existing tags)\"),\n      }),\n      execute: async (input) => {\n        const { id, ...updates } = input;\n        const memory = await tenant.update(id, updates);\n        return {\n          success: true,\n          id: memory.id,\n          message: `Updated memory: \"${memory.content}\"`,\n        };\n      },\n    }),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/integrations/anthropic.d.ts

@@ -0,0 +1,33 @@
+import { g as ToolsConfig } from '../types-BbBXYjeB.js';
+
+/**
+ * Tool definitions for the Anthropic SDK.
+ *
+ * Usage:
+ * ```ts
+ * import { createMemVaultTools } from "memvault/anthropic"
+ *
+ * const { tools, handleToolCall } = createMemVaultTools({ vault, tenantId: user.id })
+ *
+ * const message = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-6",
+ *   tools,
+ *   messages: [{ role: "user", content: "Help me..." }]
+ * })
+ * ```
+ */
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+declare function createMemVaultTools(config: ToolsConfig): {
+    tools: AnthropicTool[];
+    handleToolCall: (name: string, input: Record<string, unknown>) => Promise<string>;
+};
+
+export { createMemVaultTools };

package/dist/integrations/anthropic.js

@@ -0,0 +1,146 @@
+// src/integrations/anthropic.ts
+function createMemVaultTools(config) {
+  const tenant = config.vault.tenant(config.tenantId);
+  const tools = [
+    {
+      name: "memvault_remember",
+      description: "Save important information to persistent memory for this user. Use this when the user shares preferences, facts about themselves, project context, feedback, or anything worth remembering across sessions.",
+      input_schema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "The information to remember. Be specific and concise."
+          },
+          type: {
+            type: "string",
+            description: 'Category: "preference", "fact", "feedback", "project", "reference", or any custom type. Defaults to "general".'
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for categorization and filtering."
+          },
+          ttl: {
+            type: "number",
+            description: "Time-to-live in seconds. Omit for permanent memory."
+          }
+        },
+        required: ["content"]
+      }
+    },
+    {
+      name: "memvault_recall",
+      description: "Retrieve memories for this user. Use this BEFORE responding when you need context about the user's preferences, past conversations, or project details.",
+      input_schema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            description: "Filter by memory type."
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by tags."
+          },
+          search: {
+            type: "string",
+            description: "Search memory content (case-insensitive)."
+          },
+          limit: {
+            type: "number",
+            description: "Max number of memories to return."
+          }
+        }
+      }
+    },
+    {
+      name: "memvault_forget",
+      description: "Delete a specific memory by ID. Use when the user asks to forget something.",
+      input_schema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "The memory ID to delete." }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "memvault_update",
+      description: "Update an existing memory. Use when information has changed.",
+      input_schema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "The memory ID to update." },
+          content: { type: "string", description: "New content." },
+          type: { type: "string", description: "New type." },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "New tags."
+          }
+        },
+        required: ["id"]
+      }
+    }
+  ];
+  async function handleToolCall(name, input) {
+    switch (name) {
+      case "memvault_remember": {
+        const memory = await tenant.remember({
+          content: input.content,
+          type: input.type,
+          tags: input.tags,
+          ttl: input.ttl
+        });
+        return JSON.stringify({
+          success: true,
+          id: memory.id,
+          message: `Remembered: "${memory.content}"`
+        });
+      }
+      case "memvault_recall": {
+        const memories = await tenant.recall({
+          type: input.type,
+          tags: input.tags,
+          search: input.search,
+          limit: input.limit
+        });
+        return JSON.stringify({
+          count: memories.length,
+          memories: memories.map((m) => ({
+            id: m.id,
+            type: m.type,
+            content: m.content,
+            tags: m.tags,
+            createdAt: m.createdAt.toISOString()
+          }))
+        });
+      }
+      case "memvault_forget": {
+        await tenant.forget(input.id);
+        return JSON.stringify({
+          success: true,
+          message: `Memory ${input.id} deleted.`
+        });
+      }
+      case "memvault_update": {
+        const { id, ...updates } = input;
+        const memory = await tenant.update(id, updates);
+        return JSON.stringify({
+          success: true,
+          id: memory.id,
+          message: `Updated memory: "${memory.content}"`
+        });
+      }
+      default:
+        return JSON.stringify({ error: `Unknown tool: ${name}` });
+    }
+  }
+  return { tools, handleToolCall };
+}
+export {
+  createMemVaultTools
+};
+//# sourceMappingURL=anthropic.js.map

package/dist/integrations/anthropic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/integrations/anthropic.ts"],"sourcesContent":["import type { ToolsConfig, TenantVaultInstance } from \"../types.js\";\n\n/**\n * Tool definitions for the Anthropic SDK.\n *\n * Usage:\n * ```ts\n * import { createMemVaultTools } from \"memvault/anthropic\"\n *\n * const { tools, handleToolCall } = createMemVaultTools({ vault, tenantId: user.id })\n *\n * const message = await anthropic.messages.create({\n *   model: \"claude-sonnet-4-6\",\n *   tools,\n *   messages: [{ role: \"user\", content: \"Help me...\" }]\n * })\n * ```\n */\n\ninterface AnthropicTool {\n  name: string;\n  description: string;\n  input_schema: {\n    type: \"object\";\n    properties: Record<string, unknown>;\n    required?: string[];\n  };\n}\n\nexport function createMemVaultTools(config: ToolsConfig) {\n  const tenant = config.vault.tenant(config.tenantId);\n\n  const tools: AnthropicTool[] = [\n    {\n      name: \"memvault_remember\",\n      description:\n        \"Save important information to persistent memory for this user. \" +\n        \"Use this when the user shares preferences, facts about themselves, \" +\n        \"project context, feedback, or anything worth remembering across sessions.\",\n      input_schema: {\n        type: \"object\",\n        properties: {\n          content: {\n            type: \"string\",\n            description:\n              \"The information to remember. Be specific and concise.\",\n          },\n          type: {\n            type: \"string\",\n            description:\n              'Category: \"preference\", \"fact\", \"feedback\", \"project\", \"reference\", or any custom type. Defaults to \"general\".',\n          },\n          tags: {\n            type: \"array\",\n            items: { type: \"string\" },\n            description: \"Tags for categorization and filtering.\",\n          },\n          ttl: {\n            type: \"number\",\n            description:\n              \"Time-to-live in seconds. Omit for permanent memory.\",\n          },\n        },\n        required: [\"content\"],\n      },\n    },\n    {\n      name: \"memvault_recall\",\n      description:\n        \"Retrieve memories for this user. Use this BEFORE responding when you need \" +\n        \"context about the user's preferences, past conversations, or project details.\",\n      input_schema: {\n        type: \"object\",\n        properties: {\n          type: {\n            type: \"string\",\n            description: \"Filter by memory type.\",\n          },\n          tags: {\n            type: \"array\",\n            items: { type: \"string\" },\n            description: \"Filter by tags.\",\n          },\n          search: {\n            type: \"string\",\n            description: \"Search memory content (case-insensitive).\",\n          },\n          limit: {\n            type: \"number\",\n            description: \"Max number of memories to return.\",\n          },\n        },\n      },\n    },\n    {\n      name: \"memvault_forget\",\n      description:\n        \"Delete a specific memory by ID. Use when the user asks to forget something.\",\n      input_schema: {\n        type: \"object\",\n        properties: {\n          id: { type: \"string\", description: \"The memory ID to delete.\" },\n        },\n        required: [\"id\"],\n      },\n    },\n    {\n      name: \"memvault_update\",\n      description:\n        \"Update an existing memory. Use when information has changed.\",\n      input_schema: {\n        type: \"object\",\n        properties: {\n          id: { type: \"string\", description: \"The memory ID to update.\" },\n          content: { type: \"string\", description: \"New content.\" },\n          type: { type: \"string\", description: \"New type.\" },\n          tags: {\n            type: \"array\",\n            items: { type: \"string\" },\n            description: \"New tags.\",\n          },\n        },\n        required: [\"id\"],\n      },\n    },\n  ];\n\n  /**\n   * Execute a tool call from the Anthropic API response.\n   * Pass the tool name and input object from the tool_use content block.\n   */\n  async function handleToolCall(\n    name: string,\n    input: Record<string, unknown>,\n  ): Promise<string> {\n    switch (name) {\n      case \"memvault_remember\": {\n        const memory = await tenant.remember({\n          content: input.content as string,\n          type: input.type as string | undefined,\n          tags: input.tags as string[] | undefined,\n          ttl: input.ttl as number | undefined,\n        });\n        return JSON.stringify({\n          success: true,\n          id: memory.id,\n          message: `Remembered: \"${memory.content}\"`,\n        });\n      }\n      case \"memvault_recall\": {\n        const memories = await tenant.recall({\n          type: input.type as string | undefined,\n          tags: input.tags as string[] | undefined,\n          search: input.search as string | undefined,\n          limit: input.limit as number | undefined,\n        });\n        return JSON.stringify({\n          count: memories.length,\n          memories: memories.map((m) => ({\n            id: m.id,\n            type: m.type,\n            content: m.content,\n            tags: m.tags,\n            createdAt: m.createdAt.toISOString(),\n          })),\n        });\n      }\n      case \"memvault_forget\": {\n        await tenant.forget(input.id as string);\n        return JSON.stringify({\n          success: true,\n          message: `Memory ${input.id} deleted.`,\n        });\n      }\n      case \"memvault_update\": {\n        const { id, ...updates } = input;\n        const memory = await tenant.update(id as string, updates);\n        return JSON.stringify({\n          success: true,\n          id: memory.id,\n          message: `Updated memory: \"${memory.content}\"`,\n        });\n      }\n      default:\n        return JSON.stringify({ error: `Unknown tool: ${name}` });\n    }\n  }\n\n  return { tools, handleToolCall };\n}\n"],"mappings":"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","names":[]}

package/dist/integrations/openai.d.ts

@@ -0,0 +1,32 @@
+import { g as ToolsConfig } from '../types-BbBXYjeB.js';
+
+/**
+ * Tool definitions for the OpenAI SDK (Responses API & Chat Completions).
+ *
+ * Usage:
+ * ```ts
+ * import { createMemVaultTools, handleToolCall } from "memvault/openai"
+ *
+ * const { tools, handleToolCall } = createMemVaultTools({ vault, tenantId: user.id })
+ *
+ * const response = await openai.responses.create({
+ *   model: "gpt-4o",
+ *   tools,
+ *   input: "Help the user..."
+ * })
+ * ```
+ */
+interface OpenAIFunctionTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+declare function createMemVaultTools(config: ToolsConfig): {
+    tools: OpenAIFunctionTool[];
+    handleToolCall: (name: string, args: Record<string, unknown>) => Promise<string>;
+};
+
+export { createMemVaultTools };

package/dist/integrations/openai.js

@@ -0,0 +1,159 @@
+// src/integrations/openai.ts
+function createMemVaultTools(config) {
+  const tenant = config.vault.tenant(config.tenantId);
+  const tools = [
+    {
+      type: "function",
+      function: {
+        name: "memvault_remember",
+        description: "Save important information to persistent memory for this user. Use this when the user shares preferences, facts about themselves, project context, feedback, or anything worth remembering across sessions.",
+        parameters: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "The information to remember. Be specific and concise."
+            },
+            type: {
+              type: "string",
+              description: 'Category: "preference", "fact", "feedback", "project", "reference", or any custom type. Defaults to "general".'
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Tags for categorization and filtering."
+            },
+            ttl: {
+              type: "number",
+              description: "Time-to-live in seconds. Omit for permanent memory."
+            }
+          },
+          required: ["content"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "memvault_recall",
+        description: "Retrieve memories for this user. Use this BEFORE responding when you need context about the user's preferences, past conversations, or project details.",
+        parameters: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              description: "Filter by memory type."
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Filter by tags."
+            },
+            search: {
+              type: "string",
+              description: "Search memory content (case-insensitive)."
+            },
+            limit: {
+              type: "number",
+              description: "Max number of memories to return."
+            }
+          },
+          required: []
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "memvault_forget",
+        description: "Delete a specific memory by ID. Use when the user asks to forget something.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "The memory ID to delete." }
+          },
+          required: ["id"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "memvault_update",
+        description: "Update an existing memory. Use when information has changed.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "The memory ID to update." },
+            content: { type: "string", description: "New content." },
+            type: { type: "string", description: "New type." },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "New tags."
+            }
+          },
+          required: ["id"]
+        }
+      }
+    }
+  ];
+  async function handleToolCall(name, args) {
+    switch (name) {
+      case "memvault_remember": {
+        const memory = await tenant.remember({
+          content: args.content,
+          type: args.type,
+          tags: args.tags,
+          ttl: args.ttl
+        });
+        return JSON.stringify({
+          success: true,
+          id: memory.id,
+          message: `Remembered: "${memory.content}"`
+        });
+      }
+      case "memvault_recall": {
+        const memories = await tenant.recall({
+          type: args.type,
+          tags: args.tags,
+          search: args.search,
+          limit: args.limit
+        });
+        return JSON.stringify({
+          count: memories.length,
+          memories: memories.map((m) => ({
+            id: m.id,
+            type: m.type,
+            content: m.content,
+            tags: m.tags,
+            createdAt: m.createdAt.toISOString()
+          }))
+        });
+      }
+      case "memvault_forget": {
+        await tenant.forget(args.id);
+        return JSON.stringify({
+          success: true,
+          message: `Memory ${args.id} deleted.`
+        });
+      }
+      case "memvault_update": {
+        const { id, ...updates } = args;
+        const memory = await tenant.update(id, updates);
+        return JSON.stringify({
+          success: true,
+          id: memory.id,
+          message: `Updated memory: "${memory.content}"`
+        });
+      }
+      default:
+        return JSON.stringify({ error: `Unknown tool: ${name}` });
+    }
+  }
+  return { tools, handleToolCall };
+}
+export {
+  createMemVaultTools
+};
+//# sourceMappingURL=openai.js.map

package/dist/integrations/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/integrations/openai.ts"],"sourcesContent":["import type { ToolsConfig, TenantVaultInstance } from \"../types.js\";\n\n/**\n * Tool definitions for the OpenAI SDK (Responses API & Chat Completions).\n *\n * Usage:\n * ```ts\n * import { createMemVaultTools, handleToolCall } from \"memvault/openai\"\n *\n * const { tools, handleToolCall } = createMemVaultTools({ vault, tenantId: user.id })\n *\n * const response = await openai.responses.create({\n *   model: \"gpt-4o\",\n *   tools,\n *   input: \"Help the user...\"\n * })\n * ```\n */\n\ninterface OpenAIFunctionTool {\n  type: \"function\";\n  function: {\n    name: string;\n    description: string;\n    parameters: Record<string, unknown>;\n  };\n}\n\nexport function createMemVaultTools(config: ToolsConfig) {\n  const tenant = config.vault.tenant(config.tenantId);\n\n  const tools: OpenAIFunctionTool[] = [\n    {\n      type: \"function\",\n      function: {\n        name: \"memvault_remember\",\n        description:\n          \"Save important information to persistent memory for this user. \" +\n          \"Use this when the user shares preferences, facts about themselves, \" +\n          \"project context, feedback, or anything worth remembering across sessions.\",\n        parameters: {\n          type: \"object\",\n          properties: {\n            content: {\n              type: \"string\",\n              description:\n                \"The information to remember. Be specific and concise.\",\n            },\n            type: {\n              type: \"string\",\n              description:\n                'Category: \"preference\", \"fact\", \"feedback\", \"project\", \"reference\", or any custom type. Defaults to \"general\".',\n            },\n            tags: {\n              type: \"array\",\n              items: { type: \"string\" },\n              description: \"Tags for categorization and filtering.\",\n            },\n            ttl: {\n              type: \"number\",\n              description:\n                \"Time-to-live in seconds. Omit for permanent memory.\",\n            },\n          },\n          required: [\"content\"],\n        },\n      },\n    },\n    {\n      type: \"function\",\n      function: {\n        name: \"memvault_recall\",\n        description:\n          \"Retrieve memories for this user. Use this BEFORE responding when you need \" +\n          \"context about the user's preferences, past conversations, or project details.\",\n        parameters: {\n          type: \"object\",\n          properties: {\n            type: {\n              type: \"string\",\n              description: \"Filter by memory type.\",\n            },\n            tags: {\n              type: \"array\",\n              items: { type: \"string\" },\n              description: \"Filter by tags.\",\n            },\n            search: {\n              type: \"string\",\n              description: \"Search memory content (case-insensitive).\",\n            },\n            limit: {\n              type: \"number\",\n              description: \"Max number of memories to return.\",\n            },\n          },\n          required: [],\n        },\n      },\n    },\n    {\n      type: \"function\",\n      function: {\n        name: \"memvault_forget\",\n        description:\n          \"Delete a specific memory by ID. Use when the user asks to forget something.\",\n        parameters: {\n          type: \"object\",\n          properties: {\n            id: { type: \"string\", description: \"The memory ID to delete.\" },\n          },\n          required: [\"id\"],\n        },\n      },\n    },\n    {\n      type: \"function\",\n      function: {\n        name: \"memvault_update\",\n        description:\n          \"Update an existing memory. Use when information has changed.\",\n        parameters: {\n          type: \"object\",\n          properties: {\n            id: { type: \"string\", description: \"The memory ID to update.\" },\n            content: { type: \"string\", description: \"New content.\" },\n            type: { type: \"string\", description: \"New type.\" },\n            tags: {\n              type: \"array\",\n              items: { type: \"string\" },\n              description: \"New tags.\",\n            },\n          },\n          required: [\"id\"],\n        },\n      },\n    },\n  ];\n\n  /**\n   * Execute a tool call returned by the OpenAI API.\n   * Pass the function name and parsed arguments.\n   */\n  async function handleToolCall(\n    name: string,\n    args: Record<string, unknown>,\n  ): Promise<string> {\n    switch (name) {\n      case \"memvault_remember\": {\n        const memory = await tenant.remember({\n          content: args.content as string,\n          type: args.type as string | undefined,\n          tags: args.tags as string[] | undefined,\n          ttl: args.ttl as number | undefined,\n        });\n        return JSON.stringify({\n          success: true,\n          id: memory.id,\n          message: `Remembered: \"${memory.content}\"`,\n        });\n      }\n      case \"memvault_recall\": {\n        const memories = await tenant.recall({\n          type: args.type as string | undefined,\n          tags: args.tags as string[] | undefined,\n          search: args.search as string | undefined,\n          limit: args.limit as number | undefined,\n        });\n        return JSON.stringify({\n          count: memories.length,\n          memories: memories.map((m) => ({\n            id: m.id,\n            type: m.type,\n            content: m.content,\n            tags: m.tags,\n            createdAt: m.createdAt.toISOString(),\n          })),\n        });\n      }\n      case \"memvault_forget\": {\n        await tenant.forget(args.id as string);\n        return JSON.stringify({\n          success: true,\n          message: `Memory ${args.id} deleted.`,\n        });\n      }\n      case \"memvault_update\": {\n        const { id, ...updates } = args;\n        const memory = await tenant.update(id as string, updates);\n        return JSON.stringify({\n          success: true,\n          id: memory.id,\n          message: `Updated memory: \"${memory.content}\"`,\n        });\n      }\n      default:\n        return JSON.stringify({ error: `Unknown tool: ${name}` });\n    }\n  }\n\n  return { tools, handleToolCall };\n}\n"],"mappings":"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","names":[]}

package/dist/types-BbBXYjeB.d.ts

@@ -0,0 +1,116 @@
+/**
+ * A stored memory record.
+ */
+interface Memory {
+    id: string;
+    tenantId: string;
+    type: string;
+    content: string;
+    metadata: Record<string, unknown> | null;
+    tags: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date | null;
+}
+/**
+ * Input for creating a new memory.
+ */
+interface MemoryInput {
+    content: string;
+    type?: string;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    /** Time-to-live in seconds. Sets expiresAt relative to now. */
+    ttl?: number;
+}
+/**
+ * Input for updating an existing memory.
+ */
+interface MemoryUpdate {
+    content?: string;
+    type?: string;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    /** Time-to-live in seconds. Resets expiresAt relative to now. null clears expiry. */
+    ttl?: number | null;
+}
+/**
+ * Filters for querying memories.
+ */
+interface MemoryFilter {
+    type?: string;
+    tags?: string[];
+    search?: string;
+    limit?: number;
+    /** Include expired memories. Defaults to false. */
+    includeExpired?: boolean;
+}
+/**
+ * The Prisma delegate interface that MemVault requires.
+ * This matches the shape of `prisma.memvaultMemory` after adding the schema.
+ */
+interface MemvaultPrismaDelegate {
+    create(args: {
+        data: Record<string, unknown>;
+    }): Promise<Memory>;
+    findMany(args?: {
+        where?: Record<string, unknown>;
+        orderBy?: Record<string, unknown> | Record<string, unknown>[];
+        take?: number;
+    }): Promise<Memory[]>;
+    findUnique(args: {
+        where: Record<string, unknown>;
+    }): Promise<Memory | null>;
+    update(args: {
+        where: Record<string, unknown>;
+        data: Record<string, unknown>;
+    }): Promise<Memory>;
+    delete(args: {
+        where: Record<string, unknown>;
+    }): Promise<Memory>;
+    deleteMany(args?: {
+        where?: Record<string, unknown>;
+    }): Promise<{
+        count: number;
+    }>;
+    count(args?: {
+        where?: Record<string, unknown>;
+    }): Promise<number>;
+}
+/**
+ * Configuration for MemVault.
+ */
+interface MemVaultConfig {
+    /** The Prisma delegate for the MemvaultMemory model (e.g. prisma.memvaultMemory) */
+    db: MemvaultPrismaDelegate;
+}
+/**
+ * Configuration for creating SDK tools.
+ */
+interface ToolsConfig {
+    /** The MemVault instance */
+    vault: MemVaultInstance;
+    /** Tenant ID to scope all memory operations */
+    tenantId: string;
+}
+/**
+ * The public MemVault instance interface.
+ */
+interface MemVaultInstance {
+    tenant(tenantId: string): TenantVaultInstance;
+}
+/**
+ * The public TenantVault interface — all operations scoped to one tenant.
+ */
+interface TenantVaultInstance {
+    readonly tenantId: string;
+    remember(input: MemoryInput): Promise<Memory>;
+    recall(filter?: MemoryFilter): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    update(id: string, input: MemoryUpdate): Promise<Memory>;
+    forget(id: string): Promise<void>;
+    forgetAll(): Promise<number>;
+    count(filter?: MemoryFilter): Promise<number>;
+}
+
+export type { MemvaultPrismaDelegate as M, TenantVaultInstance as T, MemoryInput as a, Memory as b, MemoryFilter as c, MemoryUpdate as d, MemVaultInstance as e, MemVaultConfig as f, ToolsConfig as g };

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "memvault",
+  "version": "0.0.1",
+  "description": "Persistent, tenant-isolated memory tools for AI agents. Drop-in tools for Vercel AI SDK, OpenAI, and Anthropic. Prisma-powered.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./ai-sdk": {
+      "import": "./dist/integrations/ai-sdk.js",
+      "types": "./dist/integrations/ai-sdk.d.ts"
+    },
+    "./openai": {
+      "import": "./dist/integrations/openai.js",
+      "types": "./dist/integrations/openai.d.ts"
+    },
+    "./anthropic": {
+      "import": "./dist/integrations/anthropic.js",
+      "types": "./dist/integrations/anthropic.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "prisma",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "memory",
+    "llm",
+    "agent",
+    "persistent",
+    "tenant",
+    "prisma",
+    "openai",
+    "anthropic",
+    "vercel-ai-sdk",
+    "multi-tenant",
+    "tools",
+    "function-calling"
+  ],
+  "author": "iamsaad640",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iamsaad640/memvault.git"
+  },
+  "peerDependencies": {
+    "@prisma/client": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": false
+    },
+    "ai": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    },
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@prisma/client": "7.6.0",
+    "prisma": "7.6.0",
+    "ai": "6.0.142",
+    "zod": "4.3.6",
+    "openai": "6.33.0",
+    "@anthropic-ai/sdk": "0.82.0",
+    "tsup": "8.5.1",
+    "typescript": "6.0.2",
+    "vitest": "4.1.2"
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,30 @@
+// MemVault — Add this model to your existing Prisma schema.
+// After adding, run: npx prisma migrate dev --name add-memvault
+//
+// This model stores persistent memories with tenant-level isolation.
+// Every query is scoped by tenantId — no tenant can access another's data.
+
+generator client {
+  provider = "prisma-client"
+  output   = "../generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model MemvaultMemory {
+  id        String   @id @default(cuid())
+  tenantId  String
+  type      String   @default("general")
+  content   String
+  metadata  Json?
+  tags      String[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  expiresAt DateTime?
+
+  @@index([tenantId])
+  @@index([tenantId, type])
+  @@map("memvault_memories")
+}