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

package/dist/expo/index.mjs

@@ -280,8 +280,404 @@ function useChat(options) {
   };
 }
 
+// src/expo/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);
+}
+
+// src/expo/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
+  } = 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,
+    sendMessage: baseSendMessage,
+    stop
+  } = useChat({
+    getToken,
+    baseUrl,
+    onData,
+    onFinish,
+    onError
+  });
+  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
+      } = 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?.length) {
+        for (const file of files) {
+          if (file.url) {
+            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
+      });
+      const responseDuration = (Date.now() - startTime) / 1e3;
+      if (result.error || !result.data) {
+        return {
+          data: null,
+          error: result.error || "No response data received",
+          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",
+          userMessage: storedUserMessage
+        };
+      }
+      return {
+        data: responseData,
+        error: null,
+        userMessage: storedUserMessage,
+        assistantMessage: storedAssistantMessage
+      };
+    },
+    [ensureConversation, getMessages, storageCtx, baseSendMessage]
+  );
+  return {
+    isLoading,
+    sendMessage,
+    stop,
+    conversationId: currentConversationId,
+    setConversationId: setCurrentConversationId,
+    createConversation,
+    getConversation,
+    getConversations,
+    updateConversationTitle,
+    deleteConversation,
+    getMessages,
+    getMessageCount,
+    clearMessages
+  };
+}
+
 // src/react/useImageGeneration.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2, useState as useState3 } from "react";
 
 // src/client/core/bodySerializer.gen.ts
 var jsonBodySerializer = {
@@ -1112,7 +1508,7 @@ var getApiV1Models = (options) => {
 // src/react/useImageGeneration.ts
 function useImageGeneration(options = {}) {
   const { getToken, baseUrl = BASE_URL, onFinish, onError } = options;
-  const [isLoading, setIsLoading] = useState2(false);
+  const [isLoading, setIsLoading] = useState3(false);
   const abortControllerRef = useRef2(null);
   useEffect2(() => {
     return () => {
@@ -1122,13 +1518,13 @@ function useImageGeneration(options = {}) {
       }
     };
   }, []);
-  const stop = useCallback2(() => {
+  const stop = useCallback3(() => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
     }
   }, []);
-  const generateImage = useCallback2(
+  const generateImage = useCallback3(
     async (args) => {
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
@@ -1191,12 +1587,12 @@ function useImageGeneration(options = {}) {
 }
 
 // src/react/useModels.ts
-import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
 function useModels(options = {}) {
   const { getToken, baseUrl = BASE_URL, provider, autoFetch = true } = options;
-  const [models, setModels] = useState3([]);
-  const [isLoading, setIsLoading] = useState3(false);
-  const [error, setError] = useState3(null);
+  const [models, setModels] = useState4([]);
+  const [isLoading, setIsLoading] = useState4(false);
+  const [error, setError] = useState4(null);
   const getTokenRef = useRef3(getToken);
   const baseUrlRef = useRef3(baseUrl);
   const providerRef = useRef3(provider);
@@ -1214,7 +1610,7 @@ function useModels(options = {}) {
       }
     };
   }, []);
-  const fetchModels = useCallback3(async () => {
+  const fetchModels = useCallback4(async () => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
     }
@@ -1272,7 +1668,7 @@ function useModels(options = {}) {
       }
     }
   }, []);
-  const refetch = useCallback3(async () => {
+  const refetch = useCallback4(async () => {
     setModels([]);
     await fetchModels();
   }, [fetchModels]);
@@ -1293,8 +1689,1243 @@ function useModels(options = {}) {
     refetch
   };
 }
+
+// src/expo/useMemoryStorage.ts
+import { useCallback as useCallback5, useState as useState5, useMemo as useMemo2, useRef as useRef4 } 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 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;
+}
+
+// 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 = cosineSimilarity(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.
+
+CRITICAL: You MUST respond with ONLY valid JSON. No explanations, no markdown, no code blocks, just pure JSON.
+
+Only store clear, factual statements that might be relevant for future context or reference. Extract facts that will be useful in future conversations, such as identity, stable preferences, ongoing projects, skills, locations, favorites, and constraints.
+
+Do not extract sensitive attributes, temporary things, or single-use instructions.
+
+You must also extract stable personal preferences, including food likes/dislikes, hobbies, favorite items, favorite genres, or other enduring tastes. 
+
+If there are no memories to extract, return: {"items": []}
+
+Response format (JSON only, no other text):
+
+{
+  "items": [
+    {
+      "type": "identity",
+      "namespace": "identity",
+      "key": "name",
+      "value": "Charlie",
+      "rawEvidence": "I'm Charlie",
+      "confidence": 0.98,
+      "pii": true
+    },
+    {
+      "type": "identity",
+      "namespace": "work",
+      "key": "company",
+      "value": "ZetaChain",
+      "rawEvidence": "called ZetaChain",
+      "confidence": 0.99,
+      "pii": false
+    },
+    {
+      "type": "identity",
+      "namespace": "location",
+      "key": "city",
+      "value": "San Francisco",
+      "rawEvidence": "I live in San Francisco",
+      "confidence": 0.99,
+      "pii": false
+    },
+    {
+      "type": "preference",
+      "namespace": "location",
+      "key": "country",
+      "value": "Japan",
+      "rawEvidence": "I like to travel to the Japan",
+      "confidence": 0.94,
+      "pii": false
+    },
+    {
+      "type": "preference",
+      "namespace": "answer_style",
+      "key": "verbosity",
+      "value": "concise_direct",
+      "rawEvidence": "I prefer concise, direct answers",
+      "confidence": 0.96,
+      "pii": false
+    },
+    {
+      "type": "identity",
+      "namespace": "timezone",
+      "key": "tz",
+      "value": "America/Los_Angeles",
+      "rawEvidence": "I'm in PST",
+      "confidence": 0.9,
+      "pii": false
+    },
+    {
+      "type": "preference",
+      "namespace": "food",
+      "key": "likes_ice_cream",
+      "value": "ice cream",
+      "rawEvidence": "I like ice cream",
+      "confidence": 0.95,
+      "pii": false
+    }
+  ]
+}`;
+var preprocessMemories = (items, minConfidence = 0.6) => {
+  if (!items || !Array.isArray(items)) {
+    return [];
+  }
+  const validItems = items.filter((item) => {
+    if (item.namespace == null || item.key == null || item.value == null) {
+      console.warn(
+        "Dropping memory item with null/undefined namespace, key, or value:",
+        item
+      );
+      return false;
+    }
+    const namespace = String(item.namespace).trim();
+    const key = String(item.key).trim();
+    const value = String(item.value).trim();
+    if (namespace === "" || key === "" || value === "") {
+      console.warn(
+        "Dropping memory item with empty namespace, key, or value after trimming:",
+        item
+      );
+      return false;
+    }
+    if (typeof item.confidence !== "number" || item.confidence < minConfidence) {
+      console.warn(
+        `Dropping memory item with confidence ${item.confidence} below threshold ${minConfidence}:`,
+        item
+      );
+      return false;
+    }
+    return true;
+  });
+  const deduplicatedMap = /* @__PURE__ */ new Map();
+  for (const item of validItems) {
+    const uniqueKey = `${item.namespace}:${item.key}:${item.value}`;
+    const existing = deduplicatedMap.get(uniqueKey);
+    if (!existing || item.confidence > existing.confidence) {
+      deduplicatedMap.set(uniqueKey, item);
+    } else {
+      console.debug(
+        `Deduplicating memory item: keeping entry with higher confidence (${existing.confidence} > ${item.confidence})`,
+        { namespace: item.namespace, key: item.key, value: item.value }
+      );
+    }
+  }
+  return Array.from(deduplicatedMap.values());
+};
+
+// src/lib/memory/constants.ts
+var DEFAULT_API_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+var DEFAULT_COMPLETION_MODEL = "openai/gpt-4o";
+
+// src/expo/useMemoryStorage.ts
+import { postApiV1Embeddings } from "@reverbia/sdk";
+async function generateEmbeddingForTextApi(text, options) {
+  const token = options.getToken ? await options.getToken() : null;
+  if (!token) {
+    throw new Error("No auth token available for embedding generation");
+  }
+  const response = await postApiV1Embeddings({
+    baseUrl: options.baseUrl,
+    body: {
+      input: text,
+      model: options.model
+    },
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.data || typeof response.data === "string") {
+    throw new Error("Failed to generate embedding");
+  }
+  const embedding = response.data.data?.[0]?.embedding;
+  if (!embedding) {
+    throw new Error("No embedding in response");
+  }
+  return embedding;
+}
+async function generateEmbeddingForMemoryApi(memory, options) {
+  const text = `${memory.type}: ${memory.namespace}/${memory.key} = ${memory.value}. Evidence: ${memory.rawEvidence}`;
+  return generateEmbeddingForTextApi(text, options);
+}
+function useMemoryStorage(options) {
+  const {
+    database,
+    completionsModel = DEFAULT_COMPLETION_MODEL,
+    embeddingModel: userEmbeddingModel,
+    embeddingProvider = "api",
+    // Default to API for Expo
+    generateEmbeddings = true,
+    onFactsExtracted,
+    getToken,
+    baseUrl = BASE_URL
+  } = options;
+  const embeddingModel = userEmbeddingModel === void 0 ? DEFAULT_API_EMBEDDING_MODEL : userEmbeddingModel;
+  const [memories, setMemories] = useState5([]);
+  const extractionInProgressRef = useRef4(false);
+  const memoriesCollection = useMemo2(
+    () => database.get("memories"),
+    [database]
+  );
+  const storageCtx = useMemo2(
+    () => ({
+      database,
+      memoriesCollection
+    }),
+    [database, memoriesCollection]
+  );
+  const embeddingOptions = useMemo2(
+    () => ({
+      model: embeddingModel ?? DEFAULT_API_EMBEDDING_MODEL,
+      getToken: getToken || void 0,
+      baseUrl
+    }),
+    [embeddingModel, getToken, baseUrl]
+  );
+  const refreshMemories = useCallback5(async () => {
+    const storedMemories = await getAllMemoriesOp(storageCtx);
+    setMemories(storedMemories);
+  }, [storageCtx]);
+  const extractMemoriesFromMessage = useCallback5(
+    async (opts) => {
+      const { messages, model } = opts;
+      if (!getToken || extractionInProgressRef.current) {
+        return null;
+      }
+      extractionInProgressRef.current = true;
+      try {
+        const token = await getToken();
+        if (!token) {
+          console.error("No access token available for memory extraction");
+          return null;
+        }
+        const completion = await postApiV1ChatCompletions({
+          baseUrl,
+          body: {
+            messages: [
+              {
+                role: "system",
+                content: [{ type: "text", text: FACT_EXTRACTION_PROMPT }]
+              },
+              ...messages.map((m) => ({
+                role: m.role,
+                content: [{ type: "text", text: m.content }]
+              }))
+            ],
+            model: model || completionsModel
+          },
+          headers: {
+            Authorization: `Bearer ${token}`
+          }
+        });
+        if (!completion.data) {
+          console.error(
+            "Memory extraction failed:",
+            completion.error?.error ?? "API did not return a response"
+          );
+          return null;
+        }
+        if (typeof completion.data === "string") {
+          console.error(
+            "Memory extraction failed: API returned a string response"
+          );
+          return null;
+        }
+        const messageContent = completion.data.choices?.[0]?.message?.content;
+        let content = "";
+        if (Array.isArray(messageContent)) {
+          content = messageContent.map((p) => p.text || "").join("").trim();
+        } else if (typeof messageContent === "string") {
+          content = messageContent.trim();
+        }
+        if (!content) {
+          console.error("No content in memory extraction response");
+          return null;
+        }
+        let jsonContent = content;
+        jsonContent = jsonContent.replace(/^data:\s*/gm, "").trim();
+        if (jsonContent.startsWith("{")) {
+          let braceCount = 0;
+          let jsonStart = -1;
+          let jsonEnd = -1;
+          for (let i = 0; i < jsonContent.length; i++) {
+            if (jsonContent[i] === "{") {
+              if (jsonStart === -1) jsonStart = i;
+              braceCount++;
+            } else if (jsonContent[i] === "}") {
+              braceCount--;
+              if (braceCount === 0 && jsonStart !== -1) {
+                jsonEnd = i + 1;
+                break;
+              }
+            }
+          }
+          if (jsonStart !== -1 && jsonEnd !== -1) {
+            jsonContent = jsonContent.substring(jsonStart, jsonEnd);
+          }
+        } else {
+          const jsonMatch = jsonContent.match(
+            /```(?:json)?\s*(\{[\s\S]*?\})\s*```/
+          );
+          if (jsonMatch && jsonMatch[1]) {
+            jsonContent = jsonMatch[1].trim();
+          } else {
+            const jsonObjectMatch = jsonContent.match(/\{[\s\S]*\}/);
+            if (jsonObjectMatch && jsonObjectMatch[0]) {
+              jsonContent = jsonObjectMatch[0];
+            } else {
+              console.warn("Memory extraction returned non-JSON response.");
+              return { items: [] };
+            }
+          }
+        }
+        const trimmedJson = jsonContent.trim();
+        if (!trimmedJson.startsWith("{") || !trimmedJson.includes("items")) {
+          console.warn("Memory extraction response doesn't appear to be valid JSON.");
+          return { items: [] };
+        }
+        let result;
+        try {
+          result = JSON.parse(jsonContent);
+          if (!result || typeof result !== "object") {
+            throw new Error("Invalid JSON structure: not an object");
+          }
+          if (!Array.isArray(result.items)) {
+            console.warn("Memory extraction result missing 'items' array.");
+            return { items: [] };
+          }
+        } catch (parseError) {
+          console.error(
+            "Failed to parse memory extraction JSON:",
+            parseError instanceof Error ? parseError.message : "Unknown error"
+          );
+          return { items: [] };
+        }
+        if (result.items && Array.isArray(result.items)) {
+          result.items = preprocessMemories(result.items);
+        }
+        if (result.items && result.items.length > 0) {
+          try {
+            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 {
+                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 generateEmbeddingForMemoryApi(
+                    memoryItem,
+                    embeddingOptions
+                  );
+                  await updateMemoryEmbeddingOp(
+                    storageCtx,
+                    saved.uniqueId,
+                    embedding,
+                    embeddingOptions.model
+                  );
+                }
+                console.log(`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 WatermelonDB:", error);
+          }
+        }
+        if (onFactsExtracted) {
+          onFactsExtracted(result);
+        }
+        return result;
+      } catch (error) {
+        console.error("Failed to extract facts:", error);
+        return null;
+      } finally {
+        extractionInProgressRef.current = false;
+      }
+    },
+    [
+      completionsModel,
+      embeddingModel,
+      embeddingOptions,
+      generateEmbeddings,
+      getToken,
+      onFactsExtracted,
+      baseUrl,
+      storageCtx,
+      refreshMemories
+    ]
+  );
+  const searchMemories = useCallback5(
+    async (query, limit = 10, minSimilarity = 0.6) => {
+      if (!embeddingModel) {
+        console.warn("Cannot search memories: embeddingModel not provided");
+        return [];
+      }
+      try {
+        const queryEmbedding = await generateEmbeddingForTextApi(
+          query,
+          embeddingOptions
+        );
+        const results = await searchSimilarMemoriesOp(
+          storageCtx,
+          queryEmbedding,
+          limit,
+          minSimilarity
+        );
+        if (results.length === 0) {
+          console.warn(
+            `[Memory Search] No memories found above similarity threshold ${minSimilarity}.`
+          );
+        } else {
+          console.log(
+            `[Memory Search] Found ${results.length} memories. Similarity scores: ${results.map((r) => r.similarity.toFixed(3)).join(", ")}`
+          );
+        }
+        return results;
+      } catch {
+        return [];
+      }
+    },
+    [embeddingModel, embeddingOptions, storageCtx]
+  );
+  const fetchAllMemories = useCallback5(async () => {
+    try {
+      return await getAllMemoriesOp(storageCtx);
+    } catch (error) {
+      throw new Error(
+        "Failed to fetch all memories: " + (error instanceof Error ? error.message : String(error))
+      );
+    }
+  }, [storageCtx]);
+  const fetchMemoriesByNamespace = useCallback5(
+    async (namespace) => {
+      if (!namespace) {
+        throw new Error("Missing required field: namespace");
+      }
+      try {
+        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 = useCallback5(
+    async (namespace, key) => {
+      if (!namespace || !key) {
+        throw new Error("Missing required fields: namespace, key");
+      }
+      try {
+        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 getMemoryById = useCallback5(
+    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 = useCallback5(
+    async (memory) => {
+      try {
+        const saved = await saveMemoryOp(storageCtx, memory);
+        if (generateEmbeddings && embeddingModel && !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 generateEmbeddingForMemoryApi(
+              memoryItem,
+              embeddingOptions
+            );
+            await updateMemoryEmbeddingOp(
+              storageCtx,
+              saved.uniqueId,
+              embedding,
+              embeddingOptions.model
+            );
+          } catch (error) {
+            console.error("Failed to generate embedding:", error);
+          }
+        }
+        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 = useCallback5(
+    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 generateEmbeddingForMemoryApi(
+                  memoryItem,
+                  embeddingOptions
+                );
+                await updateMemoryEmbeddingOp(
+                  storageCtx,
+                  saved[i].uniqueId,
+                  embedding,
+                  embeddingOptions.model
+                );
+              } catch (error) {
+                console.error("Failed to generate embedding:", error);
+              }
+            }
+          }
+        }
+        await refreshMemories();
+        return saved;
+      } catch (error) {
+        throw new Error(
+          "Failed to save memories: " + (error instanceof Error ? error.message : String(error))
+        );
+      }
+    },
+    [storageCtx, generateEmbeddings, embeddingModel, embeddingOptions, refreshMemories]
+  );
+  const updateMemory = useCallback5(
+    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 generateEmbeddingForMemoryApi(
+            memoryItem,
+            embeddingOptions
+          );
+          await updateMemoryEmbeddingOp(storageCtx, id, embedding, embeddingOptions.model);
+        } catch (error) {
+          console.error("Failed to regenerate embedding:", error);
+        }
+      }
+      setMemories((prev) => prev.map((m) => m.uniqueId === id ? updated : m));
+      return updated;
+    },
+    [storageCtx, generateEmbeddings, embeddingModel, embeddingOptions]
+  );
+  const removeMemory = useCallback5(
+    async (namespace, key, value) => {
+      if (!namespace || !key || !value) {
+        throw new Error("Missing required fields: namespace, key, value");
+      }
+      try {
+        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 = useCallback5(
+    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 = useCallback5(
+    async (namespace, key) => {
+      if (!namespace || !key) {
+        throw new Error("Missing required fields: namespace, key");
+      }
+      try {
+        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 = useCallback5(async () => {
+    try {
+      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,
+    removeMemories,
+    clearMemories
+  };
+}
+
+// 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/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";
 export {
+  Conversation as ChatConversation,
+  Message as ChatMessage,
+  Memory as StoredMemoryModel,
+  chatStorageSchema,
+  generateCompositeKey,
+  generateConversationId,
+  generateUniqueKey,
+  memoryStorageSchema,
   useChat,
+  useChatStorage,
   useImageGeneration,
+  useMemoryStorage,
   useModels
 };