@reverbia/sdk 1.0.0-next.20251212012743 → 1.0.0-next.20251215143604

package/dist/react/index.mjs

@@ -1226,7 +1226,8 @@ function useChat(options) {
       model,
       onData,
       runTools = true,
-      headers
+      headers,
+      memoryContext
     }) => {
       const messagesValidation = validateMessages(messages);
       if (!messagesValidation.valid) {
@@ -1239,7 +1240,20 @@ function useChat(options) {
       abortControllerRef.current = abortController;
       setIsLoading(true);
       let toolExecutionResult;
-      let messagesWithToolContext = messages;
+      let messagesWithContext = messages;
+      if (memoryContext) {
+        const memorySystemMessage = {
+          role: "system",
+          content: [
+            {
+              type: "text",
+              text: memoryContext
+            }
+          ]
+        };
+        messagesWithContext = [memorySystemMessage, ...messages];
+      }
+      let messagesWithToolContext = messagesWithContext;
       const shouldRunTools = runTools && tools && tools.length > 0;
       if (shouldRunTools) {
         const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
@@ -1622,10 +1636,920 @@ function useEncryption(signMessage) {
   };
 }
 
-// src/react/useMemory.ts
-import { useCallback as useCallback2, useRef as useRef2 } from "react";
+// src/react/useChatStorage.ts
+import { useCallback as useCallback2, useState as useState2, useMemo } from "react";
+
+// src/lib/chatStorage/types.ts
+function convertUsageToStored(usage) {
+  if (!usage) return void 0;
+  return {
+    promptTokens: usage.prompt_tokens,
+    completionTokens: usage.completion_tokens,
+    totalTokens: usage.total_tokens,
+    costMicroUsd: usage.cost_micro_usd
+  };
+}
+function generateConversationId() {
+  return `conv_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+// src/lib/chatStorage/operations.ts
+import { Q } from "@nozbe/watermelondb";
+function messageToStored(message) {
+  return {
+    uniqueId: message.id,
+    messageId: message.messageId,
+    conversationId: message.conversationId,
+    role: message.role,
+    content: message.content,
+    model: message.model,
+    files: message.files,
+    createdAt: message.createdAt,
+    updatedAt: message.updatedAt,
+    vector: message.vector,
+    embeddingModel: message.embeddingModel,
+    usage: message.usage,
+    sources: message.sources,
+    responseDuration: message.responseDuration
+  };
+}
+function conversationToStored(conversation) {
+  return {
+    uniqueId: conversation.id,
+    conversationId: conversation.conversationId,
+    title: conversation.title,
+    createdAt: conversation.createdAt,
+    updatedAt: conversation.updatedAt,
+    isDeleted: conversation.isDeleted
+  };
+}
+async function createConversationOp(ctx, opts, defaultTitle = "New Conversation") {
+  const convId = opts?.conversationId || generateConversationId();
+  const title = opts?.title || defaultTitle;
+  const created = await ctx.database.write(async () => {
+    return await ctx.conversationsCollection.create((conv) => {
+      conv._setRaw("conversation_id", convId);
+      conv._setRaw("title", title);
+      conv._setRaw("is_deleted", false);
+    });
+  });
+  return conversationToStored(created);
+}
+async function getConversationOp(ctx, id) {
+  const results = await ctx.conversationsCollection.query(Q.where("conversation_id", id), Q.where("is_deleted", false)).fetch();
+  return results.length > 0 ? conversationToStored(results[0]) : null;
+}
+async function getConversationsOp(ctx) {
+  const results = await ctx.conversationsCollection.query(Q.where("is_deleted", false), Q.sortBy("created_at", Q.desc)).fetch();
+  return results.map(conversationToStored);
+}
+async function updateConversationTitleOp(ctx, id, title) {
+  const results = await ctx.conversationsCollection.query(Q.where("conversation_id", id), Q.where("is_deleted", false)).fetch();
+  if (results.length > 0) {
+    await ctx.database.write(async () => {
+      await results[0].update((conv) => {
+        conv._setRaw("title", title);
+      });
+    });
+    return true;
+  }
+  return false;
+}
+async function deleteConversationOp(ctx, id) {
+  const results = await ctx.conversationsCollection.query(Q.where("conversation_id", id), Q.where("is_deleted", false)).fetch();
+  if (results.length > 0) {
+    await ctx.database.write(async () => {
+      await results[0].update((conv) => {
+        conv._setRaw("is_deleted", true);
+      });
+    });
+    return true;
+  }
+  return false;
+}
+async function getMessagesOp(ctx, convId) {
+  const results = await ctx.messagesCollection.query(Q.where("conversation_id", convId), Q.sortBy("message_id", Q.asc)).fetch();
+  return results.map(messageToStored);
+}
+async function getMessageCountOp(ctx, convId) {
+  return await ctx.messagesCollection.query(Q.where("conversation_id", convId)).fetchCount();
+}
+async function clearMessagesOp(ctx, convId) {
+  const messages = await ctx.messagesCollection.query(Q.where("conversation_id", convId)).fetch();
+  await ctx.database.write(async () => {
+    for (const message of messages) {
+      await message.destroyPermanently();
+    }
+  });
+}
+async function createMessageOp(ctx, opts) {
+  const existingCount = await getMessageCountOp(ctx, opts.conversationId);
+  const messageId = existingCount + 1;
+  const created = await ctx.database.write(async () => {
+    return await ctx.messagesCollection.create((msg) => {
+      msg._setRaw("message_id", messageId);
+      msg._setRaw("conversation_id", opts.conversationId);
+      msg._setRaw("role", opts.role);
+      msg._setRaw("content", opts.content);
+      if (opts.model) msg._setRaw("model", opts.model);
+      if (opts.files) msg._setRaw("files", JSON.stringify(opts.files));
+      if (opts.usage) msg._setRaw("usage", JSON.stringify(opts.usage));
+      if (opts.sources) msg._setRaw("sources", JSON.stringify(opts.sources));
+      if (opts.responseDuration !== void 0)
+        msg._setRaw("response_duration", opts.responseDuration);
+      if (opts.vector) msg._setRaw("vector", JSON.stringify(opts.vector));
+      if (opts.embeddingModel) msg._setRaw("embedding_model", opts.embeddingModel);
+    });
+  });
+  return messageToStored(created);
+}
+async function updateMessageEmbeddingOp(ctx, uniqueId, vector, embeddingModel) {
+  let message;
+  try {
+    message = await ctx.messagesCollection.find(uniqueId);
+  } catch {
+    return null;
+  }
+  await ctx.database.write(async () => {
+    await message.update((msg) => {
+      msg._setRaw("vector", JSON.stringify(vector));
+      msg._setRaw("embedding_model", embeddingModel);
+    });
+  });
+  return messageToStored(message);
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+async function searchMessagesOp(ctx, queryVector, options) {
+  const { limit = 10, minSimilarity = 0.5, conversationId } = options || {};
+  const activeConversations = await ctx.conversationsCollection.query(Q.where("is_deleted", false)).fetch();
+  const activeConversationIds = new Set(
+    activeConversations.map((c) => c.conversationId)
+  );
+  const queryConditions = conversationId ? [Q.where("conversation_id", conversationId)] : [];
+  const messages = await ctx.messagesCollection.query(...queryConditions).fetch();
+  const resultsWithSimilarity = [];
+  for (const message of messages) {
+    if (!activeConversationIds.has(message.conversationId)) continue;
+    const messageVector = message.vector;
+    if (!messageVector || messageVector.length === 0) continue;
+    const similarity = cosineSimilarity(queryVector, messageVector);
+    if (similarity >= minSimilarity) {
+      resultsWithSimilarity.push({
+        ...messageToStored(message),
+        similarity
+      });
+    }
+  }
+  return resultsWithSimilarity.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+}
+
+// src/react/useChatStorage.ts
+function storedToLlmapiMessage(stored) {
+  const content = [
+    { type: "text", text: stored.content }
+  ];
+  if (stored.files?.length) {
+    for (const file of stored.files) {
+      if (file.url) {
+        content.push({
+          type: "image_url",
+          image_url: { url: file.url }
+        });
+      }
+    }
+  }
+  return {
+    role: stored.role,
+    content
+  };
+}
+function useChatStorage(options) {
+  const {
+    database,
+    conversationId: initialConversationId,
+    autoCreateConversation = true,
+    defaultConversationTitle = "New Conversation",
+    getToken,
+    baseUrl,
+    onData,
+    onFinish,
+    onError,
+    chatProvider,
+    localModel,
+    tools,
+    toolSelectorModel,
+    onToolExecution
+  } = options;
+  const [currentConversationId, setCurrentConversationId] = useState2(initialConversationId || null);
+  const messagesCollection = useMemo(
+    () => database.get("history"),
+    [database]
+  );
+  const conversationsCollection = useMemo(
+    () => database.get("conversations"),
+    [database]
+  );
+  const storageCtx = useMemo(
+    () => ({
+      database,
+      messagesCollection,
+      conversationsCollection
+    }),
+    [database, messagesCollection, conversationsCollection]
+  );
+  const {
+    isLoading,
+    isSelectingTool,
+    sendMessage: baseSendMessage,
+    stop
+  } = useChat({
+    getToken,
+    baseUrl,
+    onData,
+    onFinish,
+    onError,
+    chatProvider,
+    localModel,
+    tools,
+    toolSelectorModel,
+    onToolExecution
+  });
+  const createConversation = useCallback2(
+    async (opts) => {
+      const created = await createConversationOp(
+        storageCtx,
+        opts,
+        defaultConversationTitle
+      );
+      setCurrentConversationId(created.conversationId);
+      return created;
+    },
+    [storageCtx, defaultConversationTitle]
+  );
+  const getConversation = useCallback2(
+    async (id) => {
+      return getConversationOp(storageCtx, id);
+    },
+    [storageCtx]
+  );
+  const getConversations = useCallback2(async () => {
+    return getConversationsOp(storageCtx);
+  }, [storageCtx]);
+  const updateConversationTitle = useCallback2(
+    async (id, title) => {
+      return updateConversationTitleOp(storageCtx, id, title);
+    },
+    [storageCtx]
+  );
+  const deleteConversation = useCallback2(
+    async (id) => {
+      const deleted = await deleteConversationOp(storageCtx, id);
+      if (deleted && currentConversationId === id) {
+        setCurrentConversationId(null);
+      }
+      return deleted;
+    },
+    [storageCtx, currentConversationId]
+  );
+  const getMessages = useCallback2(
+    async (convId) => {
+      return getMessagesOp(storageCtx, convId);
+    },
+    [storageCtx]
+  );
+  const getMessageCount = useCallback2(
+    async (convId) => {
+      return getMessageCountOp(storageCtx, convId);
+    },
+    [storageCtx]
+  );
+  const clearMessages = useCallback2(
+    async (convId) => {
+      return clearMessagesOp(storageCtx, convId);
+    },
+    [storageCtx]
+  );
+  const ensureConversation = useCallback2(async () => {
+    if (currentConversationId) {
+      const existing = await getConversation(currentConversationId);
+      if (existing) {
+        return currentConversationId;
+      }
+      if (autoCreateConversation) {
+        const newConv = await createConversation({
+          conversationId: currentConversationId
+        });
+        return newConv.conversationId;
+      }
+    }
+    if (autoCreateConversation) {
+      const newConv = await createConversation();
+      return newConv.conversationId;
+    }
+    throw new Error(
+      "No conversation ID provided and autoCreateConversation is disabled"
+    );
+  }, [
+    currentConversationId,
+    getConversation,
+    autoCreateConversation,
+    createConversation
+  ]);
+  const sendMessage = useCallback2(
+    async (args) => {
+      const {
+        content,
+        model,
+        messages: providedMessages,
+        includeHistory = true,
+        maxHistoryMessages = 50,
+        files,
+        onData: perRequestOnData,
+        runTools,
+        headers,
+        memoryContext
+      } = args;
+      let convId;
+      try {
+        convId = await ensureConversation();
+      } catch (err) {
+        return {
+          data: null,
+          error: err instanceof Error ? err.message : "Failed to ensure conversation"
+        };
+      }
+      let messagesToSend = [];
+      if (includeHistory && !providedMessages) {
+        const storedMessages = await getMessages(convId);
+        const limitedMessages = storedMessages.slice(-maxHistoryMessages);
+        messagesToSend = limitedMessages.map(storedToLlmapiMessage);
+      } else if (providedMessages) {
+        messagesToSend = providedMessages;
+      }
+      const userMessageContent = [
+        { type: "text", text: content }
+      ];
+      if (files && files.length > 0) {
+        for (const file of files) {
+          if (file.url && file.type.startsWith("image/")) {
+            userMessageContent.push({
+              type: "image_url",
+              image_url: { url: file.url }
+            });
+          }
+        }
+      }
+      const userMessage = {
+        role: "user",
+        content: userMessageContent
+      };
+      messagesToSend.push(userMessage);
+      const sanitizedFiles = files?.map((file) => ({
+        id: file.id,
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        // Only keep URL if it's not a data URI (e.g., external URLs)
+        url: file.url && !file.url.startsWith("data:") ? file.url : void 0
+      }));
+      let storedUserMessage;
+      try {
+        storedUserMessage = await createMessageOp(storageCtx, {
+          conversationId: convId,
+          role: "user",
+          content,
+          files: sanitizedFiles
+        });
+      } catch (err) {
+        return {
+          data: null,
+          error: err instanceof Error ? err.message : "Failed to store user message"
+        };
+      }
+      const startTime = Date.now();
+      const result = await baseSendMessage({
+        messages: messagesToSend,
+        model,
+        onData: perRequestOnData,
+        runTools,
+        headers,
+        memoryContext
+      });
+      const responseDuration = (Date.now() - startTime) / 1e3;
+      if (result.error || !result.data) {
+        return {
+          data: null,
+          error: result.error || "No response data received",
+          toolExecution: result.toolExecution,
+          userMessage: storedUserMessage
+        };
+      }
+      const responseData = result.data;
+      const assistantContent = responseData.choices?.[0]?.message?.content?.map((part) => part.text || "").join("") || "";
+      let storedAssistantMessage;
+      try {
+        storedAssistantMessage = await createMessageOp(storageCtx, {
+          conversationId: convId,
+          role: "assistant",
+          content: assistantContent,
+          model: responseData.model,
+          usage: convertUsageToStored(responseData.usage),
+          responseDuration
+        });
+      } catch (err) {
+        return {
+          data: null,
+          error: err instanceof Error ? err.message : "Failed to store assistant message",
+          toolExecution: result.toolExecution,
+          userMessage: storedUserMessage
+        };
+      }
+      return {
+        data: responseData,
+        error: null,
+        toolExecution: result.toolExecution,
+        userMessage: storedUserMessage,
+        assistantMessage: storedAssistantMessage
+      };
+    },
+    [ensureConversation, getMessages, storageCtx, baseSendMessage]
+  );
+  const searchMessages = useCallback2(
+    async (queryVector, options2) => {
+      return searchMessagesOp(storageCtx, queryVector, options2);
+    },
+    [storageCtx]
+  );
+  const updateMessageEmbedding = useCallback2(
+    async (uniqueId, vector, embeddingModel) => {
+      return updateMessageEmbeddingOp(storageCtx, uniqueId, vector, embeddingModel);
+    },
+    [storageCtx]
+  );
+  return {
+    isLoading,
+    isSelectingTool,
+    sendMessage,
+    stop,
+    conversationId: currentConversationId,
+    setConversationId: setCurrentConversationId,
+    createConversation,
+    getConversation,
+    getConversations,
+    updateConversationTitle,
+    deleteConversation,
+    getMessages,
+    getMessageCount,
+    clearMessages,
+    searchMessages,
+    updateMessageEmbedding
+  };
+}
+
+// src/lib/chatStorage/schema.ts
+import { appSchema, tableSchema } from "@nozbe/watermelondb";
+var chatStorageSchema = appSchema({
+  version: 1,
+  tables: [
+    tableSchema({
+      name: "history",
+      columns: [
+        { name: "message_id", type: "number" },
+        // Sequential ID within conversation
+        { name: "conversation_id", type: "string", isIndexed: true },
+        { name: "role", type: "string", isIndexed: true },
+        // 'user' | 'assistant' | 'system'
+        { name: "content", type: "string" },
+        { name: "model", type: "string", isOptional: true },
+        { name: "files", type: "string", isOptional: true },
+        // JSON stringified FileMetadata[]
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        { name: "vector", type: "string", isOptional: true },
+        // JSON stringified number[]
+        { name: "embedding_model", type: "string", isOptional: true },
+        { name: "usage", type: "string", isOptional: true },
+        // JSON stringified ChatCompletionUsage
+        { name: "sources", type: "string", isOptional: true },
+        // JSON stringified SearchSource[]
+        { name: "response_duration", type: "number", isOptional: true }
+      ]
+    }),
+    tableSchema({
+      name: "conversations",
+      columns: [
+        { name: "conversation_id", type: "string", isIndexed: true },
+        { name: "title", type: "string" },
+        { name: "created_at", type: "number" },
+        { name: "updated_at", type: "number" },
+        { name: "is_deleted", type: "boolean", isIndexed: true }
+      ]
+    })
+  ]
+});
+
+// src/lib/chatStorage/models.ts
+import { Model } from "@nozbe/watermelondb";
+var Message = class extends Model {
+  /** Sequential message ID within conversation */
+  get messageId() {
+    return this._getRaw("message_id");
+  }
+  /** Links message to its conversation */
+  get conversationId() {
+    return this._getRaw("conversation_id");
+  }
+  /** Who sent the message: 'user' | 'assistant' | 'system' */
+  get role() {
+    return this._getRaw("role");
+  }
+  /** The message text content */
+  get content() {
+    return this._getRaw("content");
+  }
+  /** LLM model used (e.g., GPT-4, Claude) */
+  get model() {
+    const value = this._getRaw("model");
+    return value ? value : void 0;
+  }
+  /** Optional attached files */
+  get files() {
+    const raw = this._getRaw("files");
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Created timestamp */
+  get createdAt() {
+    return new Date(this._getRaw("created_at"));
+  }
+  /** Updated timestamp */
+  get updatedAt() {
+    return new Date(this._getRaw("updated_at"));
+  }
+  /** Embedding vector for semantic search */
+  get vector() {
+    const raw = this._getRaw("vector");
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Model used to generate embedding */
+  get embeddingModel() {
+    const value = this._getRaw("embedding_model");
+    return value ? value : void 0;
+  }
+  /** Token counts and cost */
+  get usage() {
+    const raw = this._getRaw("usage");
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Web search sources */
+  get sources() {
+    const raw = this._getRaw("sources");
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Response time in seconds */
+  get responseDuration() {
+    const value = this._getRaw("response_duration");
+    return value !== null && value !== void 0 ? value : void 0;
+  }
+};
+Message.table = "history";
+Message.associations = {
+  conversations: { type: "belongs_to", key: "conversation_id" }
+};
+var Conversation = class extends Model {
+  /** Unique conversation identifier */
+  get conversationId() {
+    return this._getRaw("conversation_id");
+  }
+  /** Conversation title */
+  get title() {
+    return this._getRaw("title");
+  }
+  /** Created timestamp */
+  get createdAt() {
+    return new Date(this._getRaw("created_at"));
+  }
+  /** Updated timestamp */
+  get updatedAt() {
+    return new Date(this._getRaw("updated_at"));
+  }
+  /** Soft delete flag */
+  get isDeleted() {
+    return this._getRaw("is_deleted");
+  }
+};
+Conversation.table = "conversations";
+Conversation.associations = {
+  history: { type: "has_many", foreignKey: "conversation_id" }
+};
+
+// src/react/useMemoryStorage.ts
+import { useCallback as useCallback3, useState as useState3, useMemo as useMemo2, useRef as useRef2 } from "react";
 import { postApiV1ChatCompletions } from "@reverbia/sdk";
 
+// src/lib/memoryStorage/operations.ts
+import { Q as Q2 } from "@nozbe/watermelondb";
+
+// src/lib/memoryStorage/types.ts
+function generateCompositeKey(namespace, key) {
+  return `${namespace}:${key}`;
+}
+function generateUniqueKey(namespace, key, value) {
+  return `${namespace}:${key}:${value}`;
+}
+function cosineSimilarity2(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) {
+    return 0;
+  }
+  return dotProduct / denominator;
+}
+
+// src/lib/memoryStorage/operations.ts
+function memoryToStored(memory) {
+  return {
+    uniqueId: memory.id,
+    type: memory.type,
+    namespace: memory.namespace,
+    key: memory.key,
+    value: memory.value,
+    rawEvidence: memory.rawEvidence,
+    confidence: memory.confidence,
+    pii: memory.pii,
+    compositeKey: memory.compositeKey,
+    uniqueKey: memory.uniqueKey,
+    createdAt: memory.createdAt,
+    updatedAt: memory.updatedAt,
+    embedding: memory.embedding,
+    embeddingModel: memory.embeddingModel,
+    isDeleted: memory.isDeleted
+  };
+}
+async function getAllMemoriesOp(ctx) {
+  const results = await ctx.memoriesCollection.query(Q2.where("is_deleted", false), Q2.sortBy("created_at", Q2.desc)).fetch();
+  return results.map(memoryToStored);
+}
+async function getMemoryByIdOp(ctx, id) {
+  try {
+    const memory = await ctx.memoriesCollection.find(id);
+    if (memory.isDeleted) return null;
+    return memoryToStored(memory);
+  } catch {
+    return null;
+  }
+}
+async function getMemoriesByNamespaceOp(ctx, namespace) {
+  const results = await ctx.memoriesCollection.query(
+    Q2.where("namespace", namespace),
+    Q2.where("is_deleted", false),
+    Q2.sortBy("created_at", Q2.desc)
+  ).fetch();
+  return results.map(memoryToStored);
+}
+async function getMemoriesByKeyOp(ctx, namespace, key) {
+  const compositeKey = generateCompositeKey(namespace, key);
+  const results = await ctx.memoriesCollection.query(
+    Q2.where("composite_key", compositeKey),
+    Q2.where("is_deleted", false),
+    Q2.sortBy("created_at", Q2.desc)
+  ).fetch();
+  return results.map(memoryToStored);
+}
+async function saveMemoryOp(ctx, opts) {
+  const compositeKey = generateCompositeKey(opts.namespace, opts.key);
+  const uniqueKey = generateUniqueKey(opts.namespace, opts.key, opts.value);
+  const result = await ctx.database.write(async () => {
+    const existing = await ctx.memoriesCollection.query(Q2.where("unique_key", uniqueKey)).fetch();
+    if (existing.length > 0) {
+      const existingMemory = existing[0];
+      const shouldPreserveEmbedding = existingMemory.value === opts.value && existingMemory.rawEvidence === opts.rawEvidence && existingMemory.type === opts.type && existingMemory.namespace === opts.namespace && existingMemory.key === opts.key && existingMemory.embedding !== void 0 && existingMemory.embedding.length > 0 && !opts.embedding;
+      await existingMemory.update((mem) => {
+        mem._setRaw("type", opts.type);
+        mem._setRaw("namespace", opts.namespace);
+        mem._setRaw("key", opts.key);
+        mem._setRaw("value", opts.value);
+        mem._setRaw("raw_evidence", opts.rawEvidence);
+        mem._setRaw("confidence", opts.confidence);
+        mem._setRaw("pii", opts.pii);
+        mem._setRaw("composite_key", compositeKey);
+        mem._setRaw("unique_key", uniqueKey);
+        mem._setRaw("is_deleted", false);
+        if (shouldPreserveEmbedding) {
+        } else if (opts.embedding) {
+          mem._setRaw("embedding", JSON.stringify(opts.embedding));
+          if (opts.embeddingModel) {
+            mem._setRaw("embedding_model", opts.embeddingModel);
+          }
+        } else {
+          mem._setRaw("embedding", null);
+          mem._setRaw("embedding_model", null);
+        }
+      });
+      return existingMemory;
+    }
+    return await ctx.memoriesCollection.create((mem) => {
+      mem._setRaw("type", opts.type);
+      mem._setRaw("namespace", opts.namespace);
+      mem._setRaw("key", opts.key);
+      mem._setRaw("value", opts.value);
+      mem._setRaw("raw_evidence", opts.rawEvidence);
+      mem._setRaw("confidence", opts.confidence);
+      mem._setRaw("pii", opts.pii);
+      mem._setRaw("composite_key", compositeKey);
+      mem._setRaw("unique_key", uniqueKey);
+      mem._setRaw("is_deleted", false);
+      if (opts.embedding) {
+        mem._setRaw("embedding", JSON.stringify(opts.embedding));
+        if (opts.embeddingModel) {
+          mem._setRaw("embedding_model", opts.embeddingModel);
+        }
+      }
+    });
+  });
+  return memoryToStored(result);
+}
+async function saveMemoriesOp(ctx, memories) {
+  const results = [];
+  for (const memory of memories) {
+    const saved = await saveMemoryOp(ctx, memory);
+    results.push(saved);
+  }
+  return results;
+}
+async function updateMemoryOp(ctx, id, updates) {
+  let memory;
+  try {
+    memory = await ctx.memoriesCollection.find(id);
+  } catch {
+    return { ok: false, reason: "not_found" };
+  }
+  if (memory.isDeleted) {
+    return { ok: false, reason: "not_found" };
+  }
+  const newNamespace = updates.namespace ?? memory.namespace;
+  const newKey = updates.key ?? memory.key;
+  const newValue = updates.value ?? memory.value;
+  const newCompositeKey = generateCompositeKey(newNamespace, newKey);
+  const newUniqueKey = generateUniqueKey(newNamespace, newKey, newValue);
+  if (newUniqueKey !== memory.uniqueKey) {
+    const existing = await ctx.memoriesCollection.query(Q2.where("unique_key", newUniqueKey), Q2.where("is_deleted", false)).fetch();
+    if (existing.length > 0) {
+      return { ok: false, reason: "conflict", conflictingKey: newUniqueKey };
+    }
+  }
+  try {
+    const updated = await ctx.database.write(async () => {
+      await memory.update((mem) => {
+        if (updates.type !== void 0) mem._setRaw("type", updates.type);
+        if (updates.namespace !== void 0)
+          mem._setRaw("namespace", updates.namespace);
+        if (updates.key !== void 0) mem._setRaw("key", updates.key);
+        if (updates.value !== void 0) mem._setRaw("value", updates.value);
+        if (updates.rawEvidence !== void 0)
+          mem._setRaw("raw_evidence", updates.rawEvidence);
+        if (updates.confidence !== void 0)
+          mem._setRaw("confidence", updates.confidence);
+        if (updates.pii !== void 0) mem._setRaw("pii", updates.pii);
+        if (updates.namespace !== void 0 || updates.key !== void 0 || updates.value !== void 0) {
+          mem._setRaw("composite_key", newCompositeKey);
+          mem._setRaw("unique_key", newUniqueKey);
+        }
+        if (updates.embedding !== void 0) {
+          mem._setRaw(
+            "embedding",
+            updates.embedding ? JSON.stringify(updates.embedding) : null
+          );
+        }
+        if (updates.embeddingModel !== void 0) {
+          mem._setRaw("embedding_model", updates.embeddingModel || null);
+        }
+      });
+      return memory;
+    });
+    return { ok: true, memory: memoryToStored(updated) };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "error",
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+async function deleteMemoryByIdOp(ctx, id) {
+  try {
+    const memory = await ctx.memoriesCollection.find(id);
+    await ctx.database.write(async () => {
+      await memory.update((mem) => {
+        mem._setRaw("is_deleted", true);
+      });
+    });
+  } catch {
+  }
+}
+async function deleteMemoryOp(ctx, namespace, key, value) {
+  const uniqueKey = generateUniqueKey(namespace, key, value);
+  const results = await ctx.memoriesCollection.query(Q2.where("unique_key", uniqueKey)).fetch();
+  if (results.length > 0) {
+    await ctx.database.write(async () => {
+      await results[0].update((mem) => {
+        mem._setRaw("is_deleted", true);
+      });
+    });
+  }
+}
+async function deleteMemoriesByKeyOp(ctx, namespace, key) {
+  const compositeKey = generateCompositeKey(namespace, key);
+  const results = await ctx.memoriesCollection.query(Q2.where("composite_key", compositeKey), Q2.where("is_deleted", false)).fetch();
+  await ctx.database.write(async () => {
+    for (const memory of results) {
+      await memory.update((mem) => {
+        mem._setRaw("is_deleted", true);
+      });
+    }
+  });
+}
+async function clearAllMemoriesOp(ctx) {
+  const results = await ctx.memoriesCollection.query(Q2.where("is_deleted", false)).fetch();
+  await ctx.database.write(async () => {
+    for (const memory of results) {
+      await memory.update((mem) => {
+        mem._setRaw("is_deleted", true);
+      });
+    }
+  });
+}
+async function searchSimilarMemoriesOp(ctx, queryEmbedding, limit = 10, minSimilarity = 0.6) {
+  const allMemories = await ctx.memoriesCollection.query(Q2.where("is_deleted", false)).fetch();
+  const memoriesWithEmbeddings = allMemories.filter(
+    (m) => m.embedding && m.embedding.length > 0
+  );
+  if (memoriesWithEmbeddings.length === 0) {
+    return [];
+  }
+  const results = memoriesWithEmbeddings.map((memory) => {
+    const similarity = cosineSimilarity2(queryEmbedding, memory.embedding);
+    return {
+      ...memoryToStored(memory),
+      similarity
+    };
+  }).filter((result) => result.similarity >= minSimilarity).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  return results;
+}
+async function updateMemoryEmbeddingOp(ctx, id, embedding, embeddingModel) {
+  try {
+    const memory = await ctx.memoriesCollection.find(id);
+    await ctx.database.write(async () => {
+      await memory.update((mem) => {
+        mem._setRaw("embedding", JSON.stringify(embedding));
+        mem._setRaw("embedding_model", embeddingModel);
+      });
+    });
+  } catch {
+  }
+}
+
 // src/lib/memory/service.ts
 var FACT_EXTRACTION_PROMPT = `You are a memory extraction system. Extract durable user memories from chat messages.
 
@@ -1755,180 +2679,6 @@ var preprocessMemories = (items, minConfidence = 0.6) => {
   return Array.from(deduplicatedMap.values());
 };
 
-// src/lib/memory/db.ts
-import Dexie from "dexie";
-var MemoryDatabase = class extends Dexie {
-  constructor() {
-    super("MemoryDatabase");
-    this.version(2).stores({
-      memories: "++id, uniqueKey, compositeKey, namespace, key, type, createdAt, updatedAt"
-    });
-    this.version(3).stores({
-      memories: "++id, uniqueKey, compositeKey, namespace, key, type, createdAt, updatedAt"
-    });
-  }
-};
-var memoryDb = new MemoryDatabase();
-var saveMemory = async (memory) => {
-  const compositeKey = `${memory.namespace}:${memory.key}`;
-  const uniqueKey = `${memory.namespace}:${memory.key}:${memory.value}`;
-  const now = Date.now();
-  const existing = await memoryDb.memories.where("uniqueKey").equals(uniqueKey).first();
-  if (existing) {
-    const shouldPreserveEmbedding = existing.value === memory.value && existing.rawEvidence === memory.rawEvidence && existing.type === memory.type && existing.namespace === memory.namespace && existing.key === memory.key && existing.embedding !== void 0 && existing.embedding.length > 0;
-    const updateData = {
-      ...memory,
-      compositeKey,
-      uniqueKey,
-      updatedAt: now,
-      createdAt: existing.createdAt
-    };
-    if (shouldPreserveEmbedding) {
-      updateData.embedding = existing.embedding;
-      updateData.embeddingModel = existing.embeddingModel;
-    } else {
-      updateData.embedding = [];
-      updateData.embeddingModel = void 0;
-    }
-    await memoryDb.memories.update(existing.id, updateData);
-  } else {
-    await memoryDb.memories.add({
-      ...memory,
-      compositeKey,
-      uniqueKey,
-      createdAt: now,
-      updatedAt: now
-    });
-  }
-};
-var saveMemories = async (memories) => {
-  await Promise.all(memories.map((memory) => saveMemory(memory)));
-};
-var updateMemoryById = async (id, updates, existingMemory, embedding, embeddingModel) => {
-  const now = Date.now();
-  const updatedMemory = {
-    ...updates,
-    updatedAt: now
-  };
-  if ("namespace" in updates || "key" in updates || "value" in updates) {
-    const namespace = updates.namespace ?? existingMemory.namespace;
-    const key = updates.key ?? existingMemory.key;
-    const value = updates.value ?? existingMemory.value;
-    const newUniqueKey = `${namespace}:${key}:${value}`;
-    if (newUniqueKey !== existingMemory.uniqueKey) {
-      const conflicting = await getMemory(namespace, key, value);
-      if (conflicting) {
-        throw new Error(
-          `A memory with uniqueKey "${newUniqueKey}" already exists (id: ${conflicting.id})`
-        );
-      }
-    }
-    updatedMemory.compositeKey = `${namespace}:${key}`;
-    updatedMemory.uniqueKey = newUniqueKey;
-  }
-  updatedMemory.embedding = embedding;
-  updatedMemory.embeddingModel = embeddingModel;
-  return await memoryDb.transaction("rw", memoryDb.memories, async () => {
-    await memoryDb.memories.update(id, updatedMemory);
-    return await memoryDb.memories.get(id);
-  });
-};
-var getAllMemories = async () => {
-  return memoryDb.memories.toArray();
-};
-var getMemoryById = async (id) => {
-  return memoryDb.memories.get(id);
-};
-var getMemoriesByNamespace = async (namespace) => {
-  return memoryDb.memories.where("namespace").equals(namespace).toArray();
-};
-var getMemories = async (namespace, key) => {
-  const compositeKey = `${namespace}:${key}`;
-  return memoryDb.memories.where("compositeKey").equals(compositeKey).toArray();
-};
-var getMemory = async (namespace, key, value) => {
-  const uniqueKey = `${namespace}:${key}:${value}`;
-  return memoryDb.memories.where("uniqueKey").equals(uniqueKey).first();
-};
-var deleteMemories = async (namespace, key) => {
-  const compositeKey = `${namespace}:${key}`;
-  await memoryDb.memories.where("compositeKey").equals(compositeKey).delete();
-};
-var deleteMemory = async (namespace, key, value) => {
-  const uniqueKey = `${namespace}:${key}:${value}`;
-  const existing = await memoryDb.memories.where("uniqueKey").equals(uniqueKey).first();
-  if (existing?.id) {
-    await memoryDb.memories.delete(existing.id);
-  }
-};
-var deleteMemoryById = async (id) => {
-  await memoryDb.memories.delete(id);
-};
-var clearAllMemories = async () => {
-  await memoryDb.memories.clear();
-};
-var cosineSimilarity = (a, b) => {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-  if (denominator === 0) {
-    return 0;
-  }
-  return dotProduct / denominator;
-};
-var searchSimilarMemories = async (queryEmbedding, limit = 10, minSimilarity = 0.6) => {
-  const allMemories = await getAllMemories();
-  const memoriesWithEmbeddings = allMemories.filter(
-    (m) => m.embedding && m.embedding.length > 0
-  );
-  console.log(
-    `[Memory Search] Total memories: ${allMemories.length}, memories with embeddings: ${memoriesWithEmbeddings.length}`
-  );
-  if (memoriesWithEmbeddings.length === 0) {
-    console.warn(
-      "[Memory Search] No memories with embeddings found. Memories may need embeddings generated. Use generateAndStoreEmbeddings() to generate embeddings for existing memories."
-    );
-    return [];
-  }
-  const allResults = memoriesWithEmbeddings.map((memory) => {
-    const similarity = cosineSimilarity(queryEmbedding, memory.embedding);
-    return {
-      ...memory,
-      similarity
-    };
-  }).sort((a, b) => b.similarity - a.similarity);
-  console.log(
-    `[Memory Search] All similarity scores:`,
-    allResults.map((r) => ({
-      key: `${r.namespace}:${r.key}`,
-      value: r.value,
-      similarity: r.similarity.toFixed(4)
-    }))
-  );
-  const results = allResults.filter((result) => result.similarity >= minSimilarity).slice(0, limit);
-  if (results.length === 0 && allResults.length > 0) {
-    const topSimilarity = allResults[0].similarity;
-    const suggestedThreshold = Math.max(0.3, topSimilarity - 0.1);
-    console.warn(
-      `[Memory Search] No memories above threshold ${minSimilarity}. Highest similarity was ${topSimilarity.toFixed(4)}. Consider lowering the threshold to ${suggestedThreshold.toFixed(2)}`
-    );
-  } else {
-    console.log(
-      `[Memory Search] Found ${results.length} memories above similarity threshold ${minSimilarity}. Top similarity: ${results[0]?.similarity.toFixed(4) || "N/A"}`
-    );
-  }
-  return results;
-};
-
 // src/client/sdk.gen.ts
 var postApiV1Embeddings = (options) => {
   return (options.client ?? client).post({
@@ -2037,70 +2787,11 @@ var generateEmbeddingForMemory = async (memory, options = {}) => {
   ].filter(Boolean).join(" ");
   return generateEmbeddingForText(text, options);
 };
-var generateEmbeddingsForMemories = async (memories, options = {}) => {
-  const embeddings = /* @__PURE__ */ new Map();
-  for (const memory of memories) {
-    const uniqueKey = `${memory.namespace}:${memory.key}:${memory.value}`;
-    try {
-      const embedding = await generateEmbeddingForMemory(memory, options);
-      embeddings.set(uniqueKey, embedding);
-    } catch (error) {
-      console.error(
-        `Failed to generate embedding for memory ${uniqueKey}:`,
-        error
-      );
-    }
-  }
-  return embeddings;
-};
-var updateMemoriesWithEmbeddings = async (embeddings, embeddingModel) => {
-  const updates = Array.from(embeddings.entries()).map(
-    async ([uniqueKey, embedding]) => {
-      const existing = await memoryDb.memories.where("uniqueKey").equals(uniqueKey).first();
-      if (existing?.id) {
-        await memoryDb.memories.update(existing.id, {
-          embedding,
-          embeddingModel,
-          updatedAt: Date.now(),
-          createdAt: existing.createdAt
-        });
-      } else {
-        console.warn(
-          `[Embeddings] Memory with uniqueKey ${uniqueKey} not found. It may have been updated or deleted before embedding was generated.`
-        );
-      }
-    }
-  );
-  await Promise.all(updates);
-};
-var generateAndStoreEmbeddings = async (memories, options = {}) => {
-  let { model } = options;
-  const { provider = "local" } = options;
-  if (!model) {
-    if (provider === "local") {
-      model = DEFAULT_LOCAL_EMBEDDING_MODEL;
-    } else {
-      model = DEFAULT_API_EMBEDDING_MODEL;
-    }
-  }
-  if (provider === "local" && model === DEFAULT_API_EMBEDDING_MODEL) {
-    model = DEFAULT_LOCAL_EMBEDDING_MODEL;
-  }
-  if (memories.length === 0) {
-    return;
-  }
-  console.log(`Generating embeddings for ${memories.length} memories...`);
-  const embeddings = await generateEmbeddingsForMemories(memories, {
-    ...options,
-    model
-  });
-  await updateMemoriesWithEmbeddings(embeddings, model);
-  console.log(`Generated and stored ${embeddings.size} embeddings`);
-};
 
-// src/react/useMemory.ts
-function useMemory(options = {}) {
+// src/react/useMemoryStorage.ts
+function useMemoryStorage(options) {
   const {
+    database,
     completionsModel = DEFAULT_COMPLETION_MODEL,
     embeddingModel: userEmbeddingModel,
     embeddingProvider = "local",
@@ -2110,10 +2801,39 @@ function useMemory(options = {}) {
     baseUrl = BASE_URL
   } = options;
   const embeddingModel = userEmbeddingModel === void 0 ? embeddingProvider === "local" ? DEFAULT_LOCAL_EMBEDDING_MODEL : DEFAULT_API_EMBEDDING_MODEL : userEmbeddingModel;
+  const [memories, setMemories] = useState3([]);
   const extractionInProgressRef = useRef2(false);
-  const extractMemoriesFromMessage = useCallback2(
-    async (options2) => {
-      const { messages, model } = options2;
+  const memoriesCollection = useMemo2(
+    () => database.get("memories"),
+    [database]
+  );
+  const storageCtx = useMemo2(
+    () => ({
+      database,
+      memoriesCollection
+    }),
+    [database, memoriesCollection]
+  );
+  const effectiveEmbeddingModel = useMemo2(
+    () => embeddingModel ?? (embeddingProvider === "api" ? DEFAULT_API_EMBEDDING_MODEL : DEFAULT_LOCAL_EMBEDDING_MODEL),
+    [embeddingModel, embeddingProvider]
+  );
+  const embeddingOptions = useMemo2(
+    () => ({
+      model: effectiveEmbeddingModel,
+      provider: embeddingProvider,
+      getToken: getToken || void 0,
+      baseUrl
+    }),
+    [effectiveEmbeddingModel, embeddingProvider, getToken, baseUrl]
+  );
+  const refreshMemories = useCallback3(async () => {
+    const storedMemories = await getAllMemoriesOp(storageCtx);
+    setMemories(storedMemories);
+  }, [storageCtx]);
+  const extractMemoriesFromMessage = useCallback3(
+    async (opts) => {
+      const { messages, model } = opts;
       if (!getToken || extractionInProgressRef.current) {
         return null;
       }
@@ -2199,11 +2919,7 @@ function useMemory(options = {}) {
             if (jsonObjectMatch && jsonObjectMatch[0]) {
               jsonContent = jsonObjectMatch[0];
             } else {
-              console.warn(
-                "Memory extraction returned non-JSON response. The model may not have found any memories to extract, or it returned natural language instead of JSON.",
-                "\nFirst 200 chars of response:",
-                content.substring(0, 200)
-              );
+              console.warn("Memory extraction returned non-JSON response");
               return { items: [] };
             }
           }
@@ -2211,9 +2927,7 @@ function useMemory(options = {}) {
         const trimmedJson = jsonContent.trim();
         if (!trimmedJson.startsWith("{") || !trimmedJson.includes("items")) {
           console.warn(
-            "Memory extraction response doesn't appear to be valid JSON. The model may not have found any memories to extract, or returned natural language instead of JSON.",
-            "\nResponse preview:",
-            content.substring(0, 200)
+            "Memory extraction response doesn't appear to be valid JSON"
           );
           return { items: [] };
         }
@@ -2224,10 +2938,7 @@ function useMemory(options = {}) {
             throw new Error("Invalid JSON structure: not an object");
           }
           if (!Array.isArray(result.items)) {
-            console.warn(
-              "Memory extraction result missing 'items' array. Result:",
-              result
-            );
+            console.warn("Memory extraction result missing 'items' array");
             return { items: [] };
           }
         } catch (parseError) {
@@ -2235,42 +2946,61 @@ function useMemory(options = {}) {
             "Failed to parse memory extraction JSON:",
             parseError instanceof Error ? parseError.message : parseError
           );
-          console.error("Attempted to parse:", jsonContent.substring(0, 200));
-          console.error("Full raw content:", content.substring(0, 500));
           return { items: [] };
         }
         if (result.items && Array.isArray(result.items)) {
-          const originalCount = result.items.length;
           result.items = preprocessMemories(result.items);
-          const filteredCount = result.items.length;
-          if (originalCount !== filteredCount) {
-            console.log(
-              `Preprocessed memories: ${originalCount} -> ${filteredCount} (dropped ${originalCount - filteredCount} entries)`
-            );
-          }
         }
-        console.log("Extracted memories:", JSON.stringify(result, null, 2));
         if (result.items && result.items.length > 0) {
           try {
-            await saveMemories(result.items);
-            console.log(`Saved ${result.items.length} memories to IndexedDB`);
+            const createOptions = result.items.map(
+              (item) => ({
+                type: item.type,
+                namespace: item.namespace,
+                key: item.key,
+                value: item.value,
+                rawEvidence: item.rawEvidence,
+                confidence: item.confidence,
+                pii: item.pii
+              })
+            );
+            const savedMemories = await saveMemoriesOp(storageCtx, createOptions);
+            console.log(
+              `Saved ${savedMemories.length} memories to WatermelonDB`
+            );
             if (generateEmbeddings && embeddingModel) {
               try {
-                await generateAndStoreEmbeddings(result.items, {
-                  model: embeddingModel,
-                  provider: embeddingProvider,
-                  getToken: getToken || void 0,
-                  baseUrl
-                });
+                for (const saved of savedMemories) {
+                  const memoryItem = {
+                    type: saved.type,
+                    namespace: saved.namespace,
+                    key: saved.key,
+                    value: saved.value,
+                    rawEvidence: saved.rawEvidence,
+                    confidence: saved.confidence,
+                    pii: saved.pii
+                  };
+                  const embedding = await generateEmbeddingForMemory(
+                    memoryItem,
+                    embeddingOptions
+                  );
+                  await updateMemoryEmbeddingOp(
+                    storageCtx,
+                    saved.uniqueId,
+                    embedding,
+                    effectiveEmbeddingModel
+                  );
+                }
                 console.log(
-                  `Generated embeddings for ${result.items.length} memories`
+                  `Generated embeddings for ${savedMemories.length} memories`
                 );
               } catch (error) {
                 console.error("Failed to generate embeddings:", error);
               }
             }
+            await refreshMemories();
           } catch (error) {
-            console.error("Failed to save memories to IndexedDB:", error);
+            console.error("Failed to save memories to WatermelonDB:", error);
           }
         }
         if (onFactsExtracted) {
@@ -2287,38 +3017,35 @@ function useMemory(options = {}) {
     [
       completionsModel,
       embeddingModel,
-      embeddingProvider,
+      embeddingOptions,
       generateEmbeddings,
       getToken,
       onFactsExtracted,
-      baseUrl
+      baseUrl,
+      storageCtx,
+      refreshMemories
     ]
   );
-  const searchMemories = useCallback2(
+  const searchMemories = useCallback3(
     async (query, limit = 10, minSimilarity = 0.6) => {
       if (!embeddingModel) {
         console.warn("Cannot search memories: embeddingModel not provided");
         return [];
       }
       try {
-        console.log(`[Memory Search] Searching for: "${query}"`);
-        const queryEmbedding = await generateEmbeddingForText(query, {
-          model: embeddingModel,
-          provider: embeddingProvider,
-          getToken,
-          baseUrl
-        });
-        console.log(
-          `[Memory Search] Generated query embedding (${queryEmbedding.length} dimensions)`
+        const queryEmbedding = await generateEmbeddingForText(
+          query,
+          embeddingOptions
         );
-        const results = await searchSimilarMemories(
+        const results = await searchSimilarMemoriesOp(
+          storageCtx,
           queryEmbedding,
           limit,
           minSimilarity
         );
         if (results.length === 0) {
           console.warn(
-            `[Memory Search] No memories found above similarity threshold ${minSimilarity}. Try lowering the threshold or ensure memories have embeddings generated.`
+            `[Memory Search] No memories found above similarity threshold ${minSimilarity}.`
           );
         } else {
           console.log(
@@ -2326,175 +3053,282 @@ function useMemory(options = {}) {
           );
         }
         return results;
-      } catch (error) {
-        console.error("Failed to search memories:", error);
+      } catch {
         return [];
       }
     },
-    [embeddingModel, embeddingProvider, getToken, baseUrl]
+    [embeddingModel, embeddingOptions, storageCtx]
   );
-  const fetchAllMemories = useCallback2(async () => {
+  const fetchAllMemories = useCallback3(async () => {
     try {
-      return await getAllMemories();
+      return await getAllMemoriesOp(storageCtx);
     } catch (error) {
       throw new Error(
         "Failed to fetch all memories: " + (error instanceof Error ? error.message : String(error))
       );
     }
-  }, []);
-  const fetchMemoriesByNamespace = useCallback2(
+  }, [storageCtx]);
+  const fetchMemoriesByNamespace = useCallback3(
     async (namespace) => {
       if (!namespace) {
         throw new Error("Missing required field: namespace");
       }
       try {
-        return await getMemoriesByNamespace(namespace);
+        return await getMemoriesByNamespaceOp(storageCtx, namespace);
       } catch (error) {
         throw new Error(
           `Failed to fetch memories for namespace "${namespace}": ` + (error instanceof Error ? error.message : String(error))
         );
       }
     },
-    []
+    [storageCtx]
   );
-  const fetchMemoriesByKey = useCallback2(
+  const fetchMemoriesByKey = useCallback3(
     async (namespace, key) => {
       if (!namespace || !key) {
         throw new Error("Missing required fields: namespace, key");
       }
       try {
-        return await getMemories(namespace, key);
+        return await getMemoriesByKeyOp(storageCtx, namespace, key);
       } catch (error) {
         throw new Error(
           `Failed to fetch memories for "${namespace}:${key}": ` + (error instanceof Error ? error.message : String(error))
         );
       }
     },
-    []
+    [storageCtx]
   );
-  const updateMemory = useCallback2(
-    async (id, updates) => {
-      if (!Number.isInteger(id) || id <= 0) {
-        throw new Error("id must be a non-negative integer");
+  const getMemoryById = useCallback3(
+    async (id) => {
+      try {
+        return await getMemoryByIdOp(storageCtx, id);
+      } catch (error) {
+        throw new Error(
+          `Failed to get memory ${id}: ` + (error instanceof Error ? error.message : String(error))
+        );
       }
+    },
+    [storageCtx]
+  );
+  const saveMemory = useCallback3(
+    async (memory) => {
       try {
-        const embeddingModelToUse = embeddingProvider === "api" ? embeddingModel ?? DEFAULT_API_EMBEDDING_MODEL : embeddingModel && embeddingModel !== DEFAULT_API_EMBEDDING_MODEL ? embeddingModel : DEFAULT_LOCAL_EMBEDDING_MODEL;
-        const embeddingOptions = {
-          model: embeddingModelToUse,
-          provider: embeddingProvider,
-          getToken: getToken || void 0,
-          baseUrl
-        };
-        if (!updates.type || !updates.namespace || !updates.key || !updates.value || !updates.rawEvidence || updates.confidence === void 0 || updates.confidence === null || updates.pii === void 0 || updates.pii === null) {
-          throw new Error(
-            "Missing required fields: type, namespace, key, value, rawEvidence, confidence, pii"
-          );
-        }
-        const existingMemory = await getMemoryById(id);
-        if (!existingMemory) {
-          throw new Error(`Memory with id ${id} not found`);
-        }
-        const embeddingFieldsChanged = updates.value !== void 0 && updates.value !== existingMemory.value || updates.rawEvidence !== void 0 && updates.rawEvidence !== existingMemory.rawEvidence || updates.type !== void 0 && updates.type !== existingMemory.type || updates.namespace !== void 0 && updates.namespace !== existingMemory.namespace || updates.key !== void 0 && updates.key !== existingMemory.key;
-        if (!embeddingFieldsChanged) {
-          return existingMemory;
-        }
-        const memory = {
-          type: updates.type,
-          namespace: updates.namespace,
-          key: updates.key,
-          value: updates.value,
-          rawEvidence: updates.rawEvidence,
-          confidence: updates.confidence,
-          pii: updates.pii
-        };
-        let embedding = existingMemory.embedding ?? [];
-        let embeddingModelToStore = existingMemory.embeddingModel ?? "";
-        if (generateEmbeddings && embeddingModelToUse) {
+        const saved = await saveMemoryOp(storageCtx, memory);
+        if (generateEmbeddings && embeddingModel && !memory.embedding) {
           try {
-            embedding = await generateEmbeddingForMemory(
-              memory,
+            const memoryItem = {
+              type: memory.type,
+              namespace: memory.namespace,
+              key: memory.key,
+              value: memory.value,
+              rawEvidence: memory.rawEvidence,
+              confidence: memory.confidence,
+              pii: memory.pii
+            };
+            const embedding = await generateEmbeddingForMemory(
+              memoryItem,
               embeddingOptions
             );
-            embeddingModelToStore = embeddingModelToUse;
-          } catch (embeddingError) {
-            console.error(
-              "Failed to generate embedding, keeping existing:",
-              embeddingError
+            await updateMemoryEmbeddingOp(
+              storageCtx,
+              saved.uniqueId,
+              embedding,
+              effectiveEmbeddingModel
             );
+          } catch (error) {
+            console.error("Failed to generate embedding:", error);
           }
         }
-        return await updateMemoryById(
-          id,
-          updates,
-          existingMemory,
-          embedding,
-          embeddingModelToStore
+        setMemories((prev) => {
+          const existing = prev.find((m) => m.uniqueId === saved.uniqueId);
+          if (existing) {
+            return prev.map((m) => m.uniqueId === saved.uniqueId ? saved : m);
+          }
+          return [saved, ...prev];
+        });
+        return saved;
+      } catch (error) {
+        throw new Error(
+          "Failed to save memory: " + (error instanceof Error ? error.message : String(error))
         );
+      }
+    },
+    [storageCtx, generateEmbeddings, embeddingModel, embeddingOptions]
+  );
+  const saveMemories = useCallback3(
+    async (memoriesToSave) => {
+      try {
+        const saved = await saveMemoriesOp(storageCtx, memoriesToSave);
+        if (generateEmbeddings && embeddingModel) {
+          for (let i = 0; i < saved.length; i++) {
+            const memory = memoriesToSave[i];
+            if (!memory.embedding) {
+              try {
+                const memoryItem = {
+                  type: memory.type,
+                  namespace: memory.namespace,
+                  key: memory.key,
+                  value: memory.value,
+                  rawEvidence: memory.rawEvidence,
+                  confidence: memory.confidence,
+                  pii: memory.pii
+                };
+                const embedding = await generateEmbeddingForMemory(
+                  memoryItem,
+                  embeddingOptions
+                );
+                await updateMemoryEmbeddingOp(
+                  storageCtx,
+                  saved[i].uniqueId,
+                  embedding,
+                  effectiveEmbeddingModel
+                );
+              } catch (error) {
+                console.error("Failed to generate embedding:", error);
+              }
+            }
+          }
+        }
+        await refreshMemories();
+        return saved;
       } catch (error) {
         throw new Error(
-          `Failed to update memory ${id}: ` + (error instanceof Error ? error.message : String(error))
+          "Failed to save memories: " + (error instanceof Error ? error.message : String(error))
+        );
+      }
+    },
+    [
+      storageCtx,
+      generateEmbeddings,
+      embeddingModel,
+      embeddingOptions,
+      refreshMemories
+    ]
+  );
+  const updateMemory = useCallback3(
+    async (id, updates) => {
+      const result = await updateMemoryOp(storageCtx, id, updates);
+      if (!result.ok) {
+        if (result.reason === "not_found") {
+          return null;
+        }
+        if (result.reason === "conflict") {
+          throw new Error(
+            `Cannot update memory: a memory with key "${result.conflictingKey}" already exists`
+          );
+        }
+        throw new Error(
+          `Failed to update memory ${id}: ${result.error.message}`
         );
       }
+      const updated = result.memory;
+      const contentChanged = updates.value !== void 0 || updates.rawEvidence !== void 0 || updates.type !== void 0 || updates.namespace !== void 0 || updates.key !== void 0;
+      if (contentChanged && generateEmbeddings && embeddingModel && !updates.embedding) {
+        try {
+          const memoryItem = {
+            type: updated.type,
+            namespace: updated.namespace,
+            key: updated.key,
+            value: updated.value,
+            rawEvidence: updated.rawEvidence,
+            confidence: updated.confidence,
+            pii: updated.pii
+          };
+          const embedding = await generateEmbeddingForMemory(
+            memoryItem,
+            embeddingOptions
+          );
+          await updateMemoryEmbeddingOp(
+            storageCtx,
+            id,
+            embedding,
+            effectiveEmbeddingModel
+          );
+        } catch (error) {
+          console.error("Failed to regenerate embedding:", error);
+        }
+      }
+      setMemories(
+        (prev) => prev.map((m) => m.uniqueId === id ? updated : m)
+      );
+      return updated;
     },
-    [embeddingModel, embeddingProvider, generateEmbeddings, getToken, baseUrl]
+    [storageCtx, generateEmbeddings, embeddingModel, embeddingOptions]
   );
-  const removeMemory = useCallback2(
+  const removeMemory = useCallback3(
     async (namespace, key, value) => {
       if (!namespace || !key || !value) {
         throw new Error("Missing required fields: namespace, key, value");
       }
       try {
-        await deleteMemory(namespace, key, value);
+        await deleteMemoryOp(storageCtx, namespace, key, value);
+        setMemories(
+          (prev) => prev.filter(
+            (m) => !(m.namespace === namespace && m.key === key && m.value === value)
+          )
+        );
       } catch (error) {
         throw new Error(
           `Failed to delete memory "${namespace}:${key}:${value}": ` + (error instanceof Error ? error.message : String(error))
         );
       }
     },
-    []
+    [storageCtx]
   );
-  const removeMemoryById = useCallback2(async (id) => {
-    if (!Number.isInteger(id) || id <= 0) {
-      throw new Error("id must be a non-negative integer");
-    }
-    try {
-      await deleteMemoryById(id);
-    } catch (error) {
-      throw new Error(
-        `Failed to delete memory with id ${id}: ` + (error instanceof Error ? error.message : String(error))
-      );
-    }
-  }, []);
-  const removeMemories = useCallback2(
+  const removeMemoryById = useCallback3(
+    async (id) => {
+      try {
+        await deleteMemoryByIdOp(storageCtx, id);
+        setMemories((prev) => prev.filter((m) => m.uniqueId !== id));
+      } catch (error) {
+        throw new Error(
+          `Failed to delete memory with id ${id}: ` + (error instanceof Error ? error.message : String(error))
+        );
+      }
+    },
+    [storageCtx]
+  );
+  const removeMemories = useCallback3(
     async (namespace, key) => {
       if (!namespace || !key) {
         throw new Error("Missing required fields: namespace, key");
       }
       try {
-        await deleteMemories(namespace, key);
+        await deleteMemoriesByKeyOp(storageCtx, namespace, key);
+        setMemories(
+          (prev) => prev.filter(
+            (m) => !(m.namespace === namespace && m.key === key)
+          )
+        );
       } catch (error) {
         throw new Error(
           `Failed to delete memories for "${namespace}:${key}": ` + (error instanceof Error ? error.message : String(error))
         );
       }
     },
-    []
+    [storageCtx]
   );
-  const clearMemories = useCallback2(async () => {
+  const clearMemories = useCallback3(async () => {
     try {
-      await clearAllMemories();
+      await clearAllMemoriesOp(storageCtx);
+      setMemories([]);
     } catch (error) {
       throw new Error(
         "Failed to clear all memories: " + (error instanceof Error ? error.message : String(error))
       );
     }
-  }, []);
+  }, [storageCtx]);
   return {
+    memories,
+    refreshMemories,
     extractMemoriesFromMessage,
     searchMemories,
     fetchAllMemories,
     fetchMemoriesByNamespace,
     fetchMemoriesByKey,
+    getMemoryById,
+    saveMemory,
+    saveMemories,
     updateMemory,
     removeMemory,
     removeMemoryById,
@@ -2503,8 +3337,115 @@ function useMemory(options = {}) {
   };
 }
 
+// src/lib/memoryStorage/schema.ts
+import { appSchema as appSchema2, tableSchema as tableSchema2 } from "@nozbe/watermelondb";
+var memoryStorageSchema = appSchema2({
+  version: 1,
+  tables: [
+    tableSchema2({
+      name: "memories",
+      columns: [
+        // Memory type classification
+        { name: "type", type: "string", isIndexed: true },
+        // 'identity' | 'preference' | 'project' | 'skill' | 'constraint'
+        // Hierarchical key structure
+        { name: "namespace", type: "string", isIndexed: true },
+        { name: "key", type: "string", isIndexed: true },
+        { name: "value", type: "string" },
+        // Evidence and confidence
+        { name: "raw_evidence", type: "string" },
+        { name: "confidence", type: "number" },
+        { name: "pii", type: "boolean", isIndexed: true },
+        // Composite keys for efficient lookups
+        { name: "composite_key", type: "string", isIndexed: true },
+        // namespace:key
+        { name: "unique_key", type: "string", isIndexed: true },
+        // namespace:key:value
+        // Timestamps
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        // Vector embeddings for semantic search
+        { name: "embedding", type: "string", isOptional: true },
+        // JSON stringified number[]
+        { name: "embedding_model", type: "string", isOptional: true },
+        // Soft delete flag
+        { name: "is_deleted", type: "boolean", isIndexed: true }
+      ]
+    })
+  ]
+});
+
+// src/lib/memoryStorage/models.ts
+import { Model as Model2 } from "@nozbe/watermelondb";
+var Memory = class extends Model2 {
+  /** Memory type classification */
+  get type() {
+    return this._getRaw("type");
+  }
+  /** Namespace for grouping related memories */
+  get namespace() {
+    return this._getRaw("namespace");
+  }
+  /** Key within the namespace */
+  get key() {
+    return this._getRaw("key");
+  }
+  /** The memory value/content */
+  get value() {
+    return this._getRaw("value");
+  }
+  /** Raw evidence from which this memory was extracted */
+  get rawEvidence() {
+    return this._getRaw("raw_evidence");
+  }
+  /** Confidence score (0-1) */
+  get confidence() {
+    return this._getRaw("confidence");
+  }
+  /** Whether this memory contains PII */
+  get pii() {
+    return this._getRaw("pii");
+  }
+  /** Composite key (namespace:key) for efficient lookups */
+  get compositeKey() {
+    return this._getRaw("composite_key");
+  }
+  /** Unique key (namespace:key:value) for deduplication */
+  get uniqueKey() {
+    return this._getRaw("unique_key");
+  }
+  /** Created timestamp */
+  get createdAt() {
+    return new Date(this._getRaw("created_at"));
+  }
+  /** Updated timestamp */
+  get updatedAt() {
+    return new Date(this._getRaw("updated_at"));
+  }
+  /** Embedding vector for semantic search */
+  get embedding() {
+    const raw = this._getRaw("embedding");
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Model used to generate embedding */
+  get embeddingModel() {
+    const value = this._getRaw("embedding_model");
+    return value ? value : void 0;
+  }
+  /** Soft delete flag */
+  get isDeleted() {
+    return this._getRaw("is_deleted");
+  }
+};
+Memory.table = "memories";
+
 // src/react/usePdf.ts
-import { useCallback as useCallback3, useState as useState2 } from "react";
+import { useCallback as useCallback4, useState as useState4 } from "react";
 
 // src/lib/pdf.ts
 import * as pdfjs from "pdfjs-dist";
@@ -2557,9 +3498,9 @@ async function convertPdfToImages(pdfDataUrl) {
 // src/react/usePdf.ts
 var PDF_MIME_TYPE = "application/pdf";
 function usePdf() {
-  const [isProcessing, setIsProcessing] = useState2(false);
-  const [error, setError] = useState2(null);
-  const extractPdfContext = useCallback3(
+  const [isProcessing, setIsProcessing] = useState4(false);
+  const [error, setError] = useState4(null);
+  const extractPdfContext = useCallback4(
     async (files) => {
       setIsProcessing(true);
       setError(null);
@@ -2606,12 +3547,12 @@ ${text}`;
 }
 
 // src/react/useOCR.ts
-import { useCallback as useCallback4, useState as useState3 } from "react";
+import { useCallback as useCallback5, useState as useState5 } from "react";
 import Tesseract from "tesseract.js";
 function useOCR() {
-  const [isProcessing, setIsProcessing] = useState3(false);
-  const [error, setError] = useState3(null);
-  const extractOCRContext = useCallback4(
+  const [isProcessing, setIsProcessing] = useState5(false);
+  const [error, setError] = useState5(null);
+  const extractOCRContext = useCallback5(
     async (files) => {
       setIsProcessing(true);
       setError(null);
@@ -2697,12 +3638,12 @@ ${text}`;
 }
 
 // src/react/useModels.ts
-import { useCallback as useCallback5, useEffect as useEffect2, useRef as useRef3, useState as useState4 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect2, useRef as useRef3, useState as useState6 } from "react";
 function useModels(options = {}) {
   const { getToken, baseUrl = BASE_URL, provider, autoFetch = true } = options;
-  const [models, setModels] = useState4([]);
-  const [isLoading, setIsLoading] = useState4(false);
-  const [error, setError] = useState4(null);
+  const [models, setModels] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error, setError] = useState6(null);
   const getTokenRef = useRef3(getToken);
   const baseUrlRef = useRef3(baseUrl);
   const providerRef = useRef3(provider);
@@ -2720,7 +3661,7 @@ function useModels(options = {}) {
       }
     };
   }, []);
-  const fetchModels = useCallback5(async () => {
+  const fetchModels = useCallback6(async () => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
     }
@@ -2778,7 +3719,7 @@ function useModels(options = {}) {
       }
     }
   }, []);
-  const refetch = useCallback5(async () => {
+  const refetch = useCallback6(async () => {
     setModels([]);
     await fetchModels();
   }, [fetchModels]);
@@ -2801,13 +3742,13 @@ function useModels(options = {}) {
 }
 
 // src/react/useSearch.ts
-import { useCallback as useCallback6, useEffect as useEffect3, useRef as useRef4, useState as useState5 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect3, useRef as useRef4, useState as useState7 } from "react";
 function useSearch(options = {}) {
   const { getToken, baseUrl = BASE_URL, onError } = options;
-  const [isLoading, setIsLoading] = useState5(false);
-  const [results, setResults] = useState5(null);
-  const [response, setResponse] = useState5(null);
-  const [error, setError] = useState5(null);
+  const [isLoading, setIsLoading] = useState7(false);
+  const [results, setResults] = useState7(null);
+  const [response, setResponse] = useState7(null);
+  const [error, setError] = useState7(null);
   const abortControllerRef = useRef4(null);
   useEffect3(() => {
     return () => {
@@ -2817,7 +3758,7 @@ function useSearch(options = {}) {
       }
     };
   }, []);
-  const search = useCallback6(
+  const search = useCallback7(
     async (query, searchOptions = {}) => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -2885,10 +3826,10 @@ function useSearch(options = {}) {
 }
 
 // src/react/useImageGeneration.ts
-import { useCallback as useCallback7, useEffect as useEffect4, useRef as useRef5, useState as useState6 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect4, useRef as useRef5, useState as useState8 } from "react";
 function useImageGeneration(options = {}) {
   const { getToken, baseUrl = BASE_URL, onFinish, onError } = options;
-  const [isLoading, setIsLoading] = useState6(false);
+  const [isLoading, setIsLoading] = useState8(false);
   const abortControllerRef = useRef5(null);
   useEffect4(() => {
     return () => {
@@ -2898,13 +3839,13 @@ function useImageGeneration(options = {}) {
       }
     };
   }, []);
-  const stop = useCallback7(() => {
+  const stop = useCallback8(() => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
     }
   }, []);
-  const generateImage = useCallback7(
+  const generateImage = useCallback8(
     async (args) => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -3021,7 +3962,11 @@ var extractConversationContext = (messages, maxMessages = 3) => {
   return userMessages.trim();
 };
 export {
+  Conversation as ChatConversation,
+  Message as ChatMessage,
   DEFAULT_TOOL_SELECTOR_MODEL,
+  Memory as StoredMemoryModel,
+  chatStorageSchema,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
@@ -3029,13 +3974,18 @@ export {
   executeTool,
   extractConversationContext,
   formatMemoriesForChat,
+  generateCompositeKey,
+  generateConversationId,
+  generateUniqueKey,
   hasEncryptionKey,
+  memoryStorageSchema,
   requestEncryptionKey,
   selectTool,
   useChat,
+  useChatStorage,
   useEncryption,
   useImageGeneration,
-  useMemory,
+  useMemoryStorage,
   useModels,
   useOCR,
   usePdf,