@reverbia/sdk 1.0.0 → 1.1.0-next.20251230221037

package/dist/expo/index.mjs

@@ -0,0 +1,3395 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/expo/useChat.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/clientConfig.ts
+var BASE_URL = "https://ai-portal-dev.zetachain.com";
+var createClientConfig = (config) => ({
+  ...config,
+  baseUrl: BASE_URL
+});
+
+// src/lib/chat/useChat/utils.ts
+var VALIDATION_ERROR_MESSAGES = {
+  messages_required: "messages are required to call sendMessage.",
+  model_required: "model is required to call sendMessage.",
+  token_getter_required: "Token getter function is required.",
+  token_unavailable: "No access token available."
+};
+function validateMessages(messages) {
+  if (!messages?.length) {
+    return {
+      valid: false,
+      error: "messages_required",
+      message: VALIDATION_ERROR_MESSAGES.messages_required
+    };
+  }
+  return { valid: true };
+}
+function validateModel(model) {
+  if (!model) {
+    return {
+      valid: false,
+      error: "model_required",
+      message: VALIDATION_ERROR_MESSAGES.model_required
+    };
+  }
+  return { valid: true };
+}
+function validateTokenGetter(getToken) {
+  if (!getToken) {
+    return {
+      valid: false,
+      error: "token_getter_required",
+      message: VALIDATION_ERROR_MESSAGES.token_getter_required
+    };
+  }
+  return { valid: true };
+}
+function validateToken(token) {
+  if (!token) {
+    return {
+      valid: false,
+      error: "token_unavailable",
+      message: VALIDATION_ERROR_MESSAGES.token_unavailable
+    };
+  }
+  return { valid: true };
+}
+function extractTextFromContentPart(part) {
+  if (part.type === "text" && part.text) {
+    return part.text;
+  }
+  return "";
+}
+function messagesToInput(messages) {
+  return messages.map((msg) => {
+    const role = msg.role || "user";
+    const content = Array.isArray(msg.content) ? msg.content.map(extractTextFromContentPart).filter(Boolean).join("\n") : String(msg.content || "");
+    return `${role}: ${content}`;
+  }).join("\n\n");
+}
+function createStreamAccumulator() {
+  return {
+    content: "",
+    thinking: "",
+    responseId: "",
+    responseModel: "",
+    usage: {}
+  };
+}
+function buildResponseResponse(accumulator) {
+  const output = [];
+  if (accumulator.thinking) {
+    output.push({
+      type: "reasoning",
+      role: "assistant",
+      content: [{ type: "output_text", text: accumulator.thinking }],
+      status: "completed"
+    });
+  }
+  output.push({
+    type: "message",
+    role: "assistant",
+    content: [{ type: "output_text", text: accumulator.content }],
+    status: "completed"
+  });
+  return {
+    id: accumulator.responseId,
+    model: accumulator.responseModel,
+    object: "response",
+    output,
+    usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0
+  };
+}
+function createErrorResult(message, onError) {
+  if (onError) {
+    onError(new Error(message));
+  }
+  return { data: null, error: message };
+}
+function handleError(err, onError) {
+  const errorMsg = err instanceof Error ? err.message : "Failed to send message.";
+  const errorObj = err instanceof Error ? err : new Error(errorMsg);
+  if (onError) {
+    onError(errorObj);
+  }
+  return { data: null, error: errorMsg };
+}
+function parseSSEDataLine(line) {
+  if (!line.startsWith("data: ")) {
+    return null;
+  }
+  const data = line.substring(6).trim();
+  if (data === "[DONE]") {
+    return null;
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+// src/expo/useChat.ts
+function processSSELines(lines, accumulator, onData, globalOnData, onThinking, globalOnThinking) {
+  for (const line of lines) {
+    const chunk = parseSSEDataLine(line);
+    if (!chunk) continue;
+    if (chunk.type === "response.created" && chunk.response && typeof chunk.response === "object") {
+      const response = chunk.response;
+      if (response.id && !accumulator.responseId) {
+        accumulator.responseId = response.id;
+      }
+      if (response.model && !accumulator.responseModel) {
+        accumulator.responseModel = response.model;
+      }
+      continue;
+    }
+    if (chunk.type === "response.completed" && chunk.response && typeof chunk.response === "object") {
+      const response = chunk.response;
+      if (response.usage) {
+        accumulator.usage = {
+          ...accumulator.usage,
+          prompt_tokens: response.usage.input_tokens,
+          completion_tokens: response.usage.output_tokens,
+          total_tokens: (response.usage.input_tokens || 0) + (response.usage.output_tokens || 0)
+        };
+      }
+      continue;
+    }
+    if (chunk.id && !accumulator.responseId) {
+      accumulator.responseId = chunk.id;
+    }
+    if (chunk.model && !accumulator.responseModel) {
+      accumulator.responseModel = chunk.model;
+    }
+    if (chunk.usage) {
+      accumulator.usage = { ...accumulator.usage, ...chunk.usage };
+    }
+    if (chunk.type === "response.reasoning.delta" || chunk.type === "response.reasoning_summary_text.delta" || chunk.type === "response.thinking.delta") {
+      const delta = chunk.delta;
+      if (delta) {
+        const deltaText = typeof delta === "string" ? delta : delta.OfString || delta.OfResponseReasoningSummaryDeltaEventDelta;
+        if (deltaText) {
+          accumulator.thinking += deltaText;
+          if (onThinking) onThinking(deltaText);
+          if (globalOnThinking) globalOnThinking(deltaText);
+        }
+      }
+      continue;
+    }
+    if (chunk.type === "response.output_text.delta" && chunk.delta) {
+      const deltaText = typeof chunk.delta === "string" ? chunk.delta : chunk.delta.OfString;
+      if (deltaText) {
+        accumulator.content += deltaText;
+        if (onData) onData(deltaText);
+        if (globalOnData) globalOnData(deltaText);
+      }
+    }
+  }
+}
+function useChat(options) {
+  const {
+    getToken,
+    baseUrl = BASE_URL,
+    onData: globalOnData,
+    onThinking: globalOnThinking,
+    onFinish,
+    onError
+  } = options || {};
+  const [isLoading, setIsLoading] = useState(false);
+  const abortControllerRef = useRef(null);
+  const stop = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, []);
+  const sendMessage = useCallback(
+    async ({
+      messages,
+      model,
+      onData,
+      onThinking,
+      // Responses API options
+      store,
+      previousResponseId,
+      conversation,
+      temperature,
+      maxOutputTokens,
+      tools,
+      toolChoice,
+      reasoning,
+      thinking
+    }) => {
+      const messagesValidation = validateMessages(messages);
+      if (!messagesValidation.valid) {
+        return createErrorResult(messagesValidation.message, onError);
+      }
+      const modelValidation = validateModel(model);
+      if (!modelValidation.valid) {
+        return createErrorResult(modelValidation.message, onError);
+      }
+      const tokenGetterValidation = validateTokenGetter(getToken);
+      if (!tokenGetterValidation.valid) {
+        return createErrorResult(tokenGetterValidation.message, onError);
+      }
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      setIsLoading(true);
+      try {
+        const token = await getToken();
+        const tokenValidation = validateToken(token);
+        if (!tokenValidation.valid) {
+          setIsLoading(false);
+          return createErrorResult(tokenValidation.message, onError);
+        }
+        const result = await new Promise((resolve) => {
+          const xhr = new XMLHttpRequest();
+          const url = `${baseUrl}/api/v1/responses`;
+          const accumulator = createStreamAccumulator();
+          let lastProcessedIndex = 0;
+          let incompleteLineBuffer = "";
+          const abortHandler = () => {
+            xhr.abort();
+          };
+          abortController.signal.addEventListener("abort", abortHandler);
+          xhr.open("POST", url, true);
+          xhr.setRequestHeader("Content-Type", "application/json");
+          xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+          xhr.setRequestHeader("Accept", "text/event-stream");
+          xhr.onprogress = () => {
+            const newData = xhr.responseText.substring(lastProcessedIndex);
+            lastProcessedIndex = xhr.responseText.length;
+            const dataToProcess = incompleteLineBuffer + newData;
+            incompleteLineBuffer = "";
+            const lines = dataToProcess.split("\n");
+            if (!newData.endsWith("\n") && lines.length > 0) {
+              incompleteLineBuffer = lines.pop() || "";
+            }
+            processSSELines(lines, accumulator, onData, globalOnData, onThinking, globalOnThinking);
+          };
+          xhr.onload = () => {
+            abortController.signal.removeEventListener("abort", abortHandler);
+            if (incompleteLineBuffer) {
+              processSSELines(
+                [incompleteLineBuffer.trim()],
+                accumulator,
+                onData,
+                globalOnData,
+                onThinking,
+                globalOnThinking
+              );
+              incompleteLineBuffer = "";
+            }
+            if (xhr.status >= 200 && xhr.status < 300) {
+              const response = buildResponseResponse(accumulator);
+              setIsLoading(false);
+              if (onFinish) onFinish(response);
+              resolve({ data: response, error: null });
+            } else {
+              const errorMsg = `Request failed with status ${xhr.status}`;
+              setIsLoading(false);
+              if (onError) onError(new Error(errorMsg));
+              resolve({ data: null, error: errorMsg });
+            }
+          };
+          xhr.onerror = () => {
+            abortController.signal.removeEventListener("abort", abortHandler);
+            const errorMsg = "Network error";
+            setIsLoading(false);
+            if (onError) onError(new Error(errorMsg));
+            resolve({ data: null, error: errorMsg });
+          };
+          xhr.onabort = () => {
+            abortController.signal.removeEventListener("abort", abortHandler);
+            setIsLoading(false);
+            resolve({ data: null, error: "Request aborted" });
+          };
+          xhr.send(
+            JSON.stringify({
+              input: messagesToInput(messages),
+              model,
+              stream: true,
+              // Responses API options (only include if defined)
+              ...store !== void 0 && { store },
+              ...previousResponseId && { previous_response_id: previousResponseId },
+              ...conversation && { conversation },
+              ...temperature !== void 0 && { temperature },
+              ...maxOutputTokens !== void 0 && { max_output_tokens: maxOutputTokens },
+              ...tools && { tools },
+              ...toolChoice && { tool_choice: toolChoice },
+              ...reasoning && { reasoning },
+              ...thinking && { thinking }
+            })
+          );
+        });
+        return result;
+      } catch (err) {
+        setIsLoading(false);
+        return handleError(err, onError);
+      } finally {
+        if (abortControllerRef.current === abortController) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [getToken, baseUrl, globalOnData, globalOnThinking, onFinish, onError]
+  );
+  return {
+    isLoading,
+    sendMessage,
+    stop
+  };
+}
+
+// src/expo/useChatStorage.ts
+import { useCallback as useCallback2, useState as useState2, useMemo } from "react";
+
+// src/lib/db/chat/schema.ts
+import { appSchema, tableSchema } from "@nozbe/watermelondb";
+import {
+  schemaMigrations,
+  addColumns
+} from "@nozbe/watermelondb/Schema/migrations";
+var chatStorageSchema = appSchema({
+  version: 5,
+  tables: [
+    tableSchema({
+      name: "history",
+      columns: [
+        { name: "message_id", type: "number" },
+        { name: "conversation_id", type: "string", isIndexed: true },
+        { name: "role", type: "string", isIndexed: true },
+        { name: "content", type: "string" },
+        { name: "model", type: "string", isOptional: true },
+        { name: "files", type: "string", isOptional: true },
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        { name: "vector", type: "string", isOptional: true },
+        { name: "embedding_model", type: "string", isOptional: true },
+        { name: "usage", type: "string", isOptional: true },
+        { name: "sources", type: "string", isOptional: true },
+        { name: "response_duration", type: "number", isOptional: true },
+        { name: "was_stopped", type: "boolean", isOptional: true },
+        { name: "error", type: "string", isOptional: true },
+        { name: "thought_process", type: "string", isOptional: true },
+        // JSON stringified ActivityPhase[]
+        { name: "thinking", type: "string", isOptional: true }
+        // Reasoning/thinking content
+      ]
+    }),
+    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 }
+      ]
+    })
+  ]
+});
+var chatStorageMigrations = schemaMigrations({
+  migrations: [
+    {
+      toVersion: 2,
+      steps: [
+        addColumns({
+          table: "history",
+          columns: [{ name: "was_stopped", type: "boolean", isOptional: true }]
+        })
+      ]
+    },
+    {
+      toVersion: 3,
+      steps: [
+        addColumns({
+          table: "history",
+          columns: [{ name: "error", type: "string", isOptional: true }]
+        })
+      ]
+    },
+    {
+      toVersion: 4,
+      steps: [
+        addColumns({
+          table: "history",
+          columns: [
+            { name: "thought_process", type: "string", isOptional: true }
+          ]
+        })
+      ]
+    },
+    {
+      toVersion: 5,
+      steps: [
+        addColumns({
+          table: "history",
+          columns: [
+            { name: "thinking", type: "string", isOptional: true }
+          ]
+        })
+      ]
+    }
+  ]
+});
+
+// src/lib/db/chat/models.ts
+import { Model } from "@nozbe/watermelondb";
+import { field, text, date, json } from "@nozbe/watermelondb/decorators";
+var Message = class extends Model {
+};
+Message.table = "history";
+Message.associations = {
+  conversations: { type: "belongs_to", key: "conversation_id" }
+};
+__decorateClass([
+  field("message_id")
+], Message.prototype, "messageId", 2);
+__decorateClass([
+  text("conversation_id")
+], Message.prototype, "conversationId", 2);
+__decorateClass([
+  text("role")
+], Message.prototype, "role", 2);
+__decorateClass([
+  text("content")
+], Message.prototype, "content", 2);
+__decorateClass([
+  text("model")
+], Message.prototype, "model", 2);
+__decorateClass([
+  json("files", (json3) => json3)
+], Message.prototype, "files", 2);
+__decorateClass([
+  date("created_at")
+], Message.prototype, "createdAt", 2);
+__decorateClass([
+  date("updated_at")
+], Message.prototype, "updatedAt", 2);
+__decorateClass([
+  json("vector", (json3) => json3)
+], Message.prototype, "vector", 2);
+__decorateClass([
+  text("embedding_model")
+], Message.prototype, "embeddingModel", 2);
+__decorateClass([
+  json("usage", (json3) => json3)
+], Message.prototype, "usage", 2);
+__decorateClass([
+  json("sources", (json3) => json3)
+], Message.prototype, "sources", 2);
+__decorateClass([
+  field("response_duration")
+], Message.prototype, "responseDuration", 2);
+__decorateClass([
+  field("was_stopped")
+], Message.prototype, "wasStopped", 2);
+__decorateClass([
+  text("error")
+], Message.prototype, "error", 2);
+__decorateClass([
+  json("thought_process", (json3) => json3)
+], Message.prototype, "thoughtProcess", 2);
+__decorateClass([
+  text("thinking")
+], Message.prototype, "thinking", 2);
+var Conversation = class extends Model {
+};
+Conversation.table = "conversations";
+Conversation.associations = {
+  history: { type: "has_many", foreignKey: "conversation_id" }
+};
+__decorateClass([
+  text("conversation_id")
+], Conversation.prototype, "conversationId", 2);
+__decorateClass([
+  text("title")
+], Conversation.prototype, "title", 2);
+__decorateClass([
+  date("created_at")
+], Conversation.prototype, "createdAt", 2);
+__decorateClass([
+  date("updated_at")
+], Conversation.prototype, "updatedAt", 2);
+__decorateClass([
+  field("is_deleted")
+], Conversation.prototype, "isDeleted", 2);
+
+// src/lib/db/chat/types.ts
+function generateConversationId() {
+  return `conv_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+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 finalizeThoughtProcess(thoughtProcess) {
+  if (!thoughtProcess?.length) return thoughtProcess;
+  return thoughtProcess.map(
+    (phase, idx) => idx === thoughtProcess.length - 1 ? { ...phase, status: "completed" } : phase
+  );
+}
+
+// src/lib/db/chat/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,
+    wasStopped: message.wasStopped,
+    error: message.error,
+    thoughtProcess: message.thoughtProcess,
+    thinking: message.thinking
+  };
+}
+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);
+      if (opts.wasStopped) msg._setRaw("was_stopped", opts.wasStopped);
+      if (opts.error) msg._setRaw("error", opts.error);
+      if (opts.thoughtProcess)
+        msg._setRaw("thought_process", JSON.stringify(opts.thoughtProcess));
+      if (opts.thinking) msg._setRaw("thinking", opts.thinking);
+    });
+  });
+  return messageToStored(created);
+}
+async function updateMessageErrorOp(ctx, uniqueId, error) {
+  let message;
+  try {
+    message = await ctx.messagesCollection.find(uniqueId);
+  } catch {
+    return null;
+  }
+  await ctx.database.write(async () => {
+    await message.update((msg) => {
+      msg._setRaw("error", error);
+    });
+  });
+  return messageToStored(message);
+}
+async function updateMessageOp(ctx, uniqueId, opts) {
+  let message;
+  try {
+    message = await ctx.messagesCollection.find(uniqueId);
+  } catch {
+    return null;
+  }
+  await ctx.database.write(async () => {
+    await message.update((msg) => {
+      if (opts.content !== void 0) msg._setRaw("content", opts.content);
+      if (opts.model !== void 0) msg._setRaw("model", opts.model);
+      if (opts.files !== void 0)
+        msg._setRaw("files", JSON.stringify(opts.files));
+      if (opts.usage !== void 0)
+        msg._setRaw("usage", JSON.stringify(opts.usage));
+      if (opts.sources !== void 0)
+        msg._setRaw("sources", JSON.stringify(opts.sources));
+      if (opts.responseDuration !== void 0)
+        msg._setRaw("response_duration", opts.responseDuration);
+      if (opts.vector !== void 0)
+        msg._setRaw("vector", JSON.stringify(opts.vector));
+      if (opts.embeddingModel !== void 0)
+        msg._setRaw("embedding_model", opts.embeddingModel);
+      if (opts.wasStopped !== void 0)
+        msg._setRaw("was_stopped", opts.wasStopped);
+      if (opts.error !== void 0)
+        msg._setRaw("error", opts.error === null ? "" : opts.error);
+      if (opts.thoughtProcess !== void 0)
+        msg._setRaw("thought_process", JSON.stringify(opts.thoughtProcess));
+      if (opts.thinking !== void 0)
+        msg._setRaw("thinking", opts.thinking === null ? "" : opts.thinking);
+    });
+  });
+  return messageToStored(message);
+}
+
+// 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 updateMessage = useCallback2(
+    async (uniqueId, options2) => {
+      return updateMessageOp(storageCtx, uniqueId, options2);
+    },
+    [storageCtx]
+  );
+  const extractSourcesFromAssistantMessage = useCallback2(
+    (assistantMessage) => {
+      try {
+        const extractedSources = [];
+        const seenUrls = /* @__PURE__ */ new Set();
+        if (assistantMessage.sources) {
+          for (const source of assistantMessage.sources) {
+            if (source.url) {
+              seenUrls.add(source.url);
+            }
+            extractedSources.push(source);
+          }
+        }
+        const content = assistantMessage.content;
+        if (!content) {
+          return extractedSources;
+        }
+        const markdownLinkRegex = /\[([^\]]*)\]\(([^()]*(?:\([^()]*\)[^()]*)*)\)/g;
+        const plainUrlRegex = /https?:\/\/[^\s<>\[\]()'"]+/g;
+        let match;
+        while ((match = markdownLinkRegex.exec(content)) !== null) {
+          const title = match[1].trim();
+          const url = match[2].trim();
+          if (url && !seenUrls.has(url)) {
+            seenUrls.add(url);
+            extractedSources.push({
+              title: title || void 0,
+              url
+            });
+          }
+        }
+        while ((match = plainUrlRegex.exec(content)) !== null) {
+          const url = match[0].replace(/[.,;:!?]+$/, "").trim();
+          if (url && !seenUrls.has(url)) {
+            seenUrls.add(url);
+            try {
+              const urlObj = new URL(url);
+              extractedSources.push({
+                title: urlObj.hostname,
+                url
+              });
+            } catch {
+              extractedSources.push({
+                url
+              });
+            }
+          }
+        }
+        return extractedSources;
+      } catch {
+        return [];
+      }
+    },
+    []
+  );
+  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,
+        onThinking: perRequestOnThinking,
+        sources,
+        thoughtProcess,
+        // Responses API options
+        store,
+        previousResponseId,
+        serverConversation,
+        temperature,
+        maxOutputTokens,
+        tools,
+        toolChoice,
+        reasoning,
+        thinking
+      } = 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 validMessages = storedMessages.filter((msg) => !msg.error);
+        const limitedMessages = validMessages.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,
+          model
+        });
+      } 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,
+        onThinking: perRequestOnThinking,
+        // Responses API options
+        store,
+        previousResponseId,
+        conversation: serverConversation,
+        temperature,
+        maxOutputTokens,
+        tools,
+        toolChoice,
+        reasoning,
+        thinking
+      });
+      const responseDuration = (Date.now() - startTime) / 1e3;
+      if (result.error || !result.data) {
+        const abortedResult = result;
+        if (abortedResult.error === "Request aborted") {
+          const assistantContent2 = abortedResult.data?.output?.[0]?.content?.map((part) => part.text || "").join("") || "";
+          const responseModel = abortedResult.data?.model || model || "";
+          let storedAssistantMessage2;
+          try {
+            storedAssistantMessage2 = await createMessageOp(storageCtx, {
+              conversationId: convId,
+              role: "assistant",
+              content: assistantContent2,
+              model: responseModel,
+              usage: convertUsageToStored(abortedResult.data?.usage),
+              responseDuration,
+              wasStopped: true,
+              sources,
+              thoughtProcess: finalizeThoughtProcess(thoughtProcess)
+            });
+            const responseData2 = abortedResult.data || {
+              id: `aborted-${Date.now()}`,
+              model: responseModel,
+              object: "response",
+              output: [{
+                type: "message",
+                role: "assistant",
+                content: [{ type: "output_text", text: assistantContent2 }],
+                status: "completed"
+              }],
+              usage: void 0
+            };
+            return {
+              data: responseData2,
+              error: null,
+              // Treat as success to the caller
+              userMessage: storedUserMessage,
+              assistantMessage: storedAssistantMessage2
+            };
+          } catch {
+            return {
+              data: null,
+              error: "Request aborted",
+              userMessage: storedUserMessage
+            };
+          }
+        }
+        const errorMessage = result.error || "No response data received";
+        try {
+          await updateMessageErrorOp(
+            storageCtx,
+            storedUserMessage.uniqueId,
+            errorMessage
+          );
+          await createMessageOp(storageCtx, {
+            conversationId: convId,
+            role: "assistant",
+            content: "",
+            model: model || "",
+            responseDuration,
+            sources,
+            thoughtProcess: finalizeThoughtProcess(thoughtProcess),
+            error: errorMessage
+          });
+        } catch {
+        }
+        return {
+          data: null,
+          error: errorMessage,
+          userMessage: { ...storedUserMessage, error: errorMessage }
+        };
+      }
+      const responseData = result.data;
+      const messageOutput = responseData.output?.find(
+        (item) => item.type === "message"
+      );
+      const assistantContent = messageOutput?.content?.map((part) => part.text || "").join("") || "";
+      const reasoningOutput = responseData.output?.find(
+        (item) => item.type === "reasoning"
+      );
+      const thinkingContent = reasoningOutput?.content?.map((part) => part.text || "").join("") || void 0;
+      const combinedSources = extractSourcesFromAssistantMessage({
+        content: assistantContent,
+        sources
+      });
+      let storedAssistantMessage;
+      try {
+        storedAssistantMessage = await createMessageOp(storageCtx, {
+          conversationId: convId,
+          role: "assistant",
+          content: assistantContent,
+          model: responseData.model || model,
+          usage: convertUsageToStored(responseData.usage),
+          responseDuration,
+          sources: combinedSources,
+          thoughtProcess: finalizeThoughtProcess(thoughtProcess),
+          thinking: thinkingContent
+        });
+      } 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,
+    extractSourcesFromAssistantMessage,
+    updateMessage
+  };
+}
+
+// src/react/useImageGeneration.ts
+import { useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2, useState as useState3 } from "react";
+
+// src/client/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(
+    body,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  )
+};
+
+// src/client/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+
+// src/client/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(
+            `SSE failed: ${response.status} ${response.statusText}`
+          );
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(
+                    line.replace(/^retry:\s*/, ""),
+                    10
+                  );
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(
+          retryDelay * 2 ** (attempt - 1),
+          sseMaxRetryDelay ?? 3e4
+        );
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// src/client/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [
+        ...values,
+        key,
+        allowReserved ? v : encodeURIComponent(v)
+      ];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// src/client/core/utils.gen.ts
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+
+// src/client/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// src/client/client/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(
+          match,
+          serializeArrayParam({ explode, name, style, value })
+        );
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(
+        style === "label" ? `.${value}` : value
+      );
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some(
+    (type) => cleanContent.startsWith(type)
+  )) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+var setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+var buildUrl = (options) => {
+  const url = getUrl({
+    baseUrl: options.baseUrl,
+    path: options.path,
+    query: options.query,
+    querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+    url: options.url
+  });
+  return url;
+};
+var getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header || typeof header !== "object") {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : value
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+var Interceptors = class {
+  constructor() {
+    this.fns = [];
+  }
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// src/client/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        await fn(opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    const requestInit = {
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let response = await _fetch(url, requestInit);
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, opts);
+      }
+    }
+    const result = {
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData();
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "json":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "stream":
+          return {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+    }
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        const requestInit = {
+          ...init,
+          method: init.method,
+          url: url2
+        };
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            await fn(requestInit);
+            request2 = new Request(requestInit.url, requestInit);
+          }
+        }
+        return request2;
+      },
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+
+// src/client/client.gen.ts
+var client = createClient(createClientConfig(createConfig()));
+
+// src/client/sdk.gen.ts
+var postApiV1ImagesGenerations = (options) => {
+  return (options.client ?? client).post({
+    url: "/api/v1/images/generations",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
+var getApiV1Models = (options) => {
+  return (options?.client ?? client).get({
+    url: "/api/v1/models",
+    ...options
+  });
+};
+
+// src/react/useImageGeneration.ts
+function useImageGeneration(options = {}) {
+  const { getToken, baseUrl = BASE_URL, onFinish, onError } = options;
+  const [isLoading, setIsLoading] = useState3(false);
+  const abortControllerRef = useRef2(null);
+  useEffect2(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, []);
+  const stop = useCallback3(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+  const generateImage = useCallback3(
+    async (args) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      setIsLoading(true);
+      try {
+        if (!getToken) {
+          throw new Error("Token getter function is required.");
+        }
+        const token = await getToken();
+        if (!token) {
+          throw new Error("No access token available.");
+        }
+        const response = await postApiV1ImagesGenerations({
+          baseUrl,
+          body: args,
+          headers: {
+            Authorization: `Bearer ${token}`
+          },
+          signal: abortController.signal
+        });
+        if (response.error) {
+          const errorMsg = response.error.error || "Failed to generate image";
+          throw new Error(errorMsg);
+        }
+        if (!response.data) {
+          throw new Error("No data received from image generation API");
+        }
+        const result = response.data;
+        if (onFinish) {
+          onFinish(result);
+        }
+        return { data: result, error: null };
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          return { data: null, error: "Request aborted" };
+        }
+        const errorMsg = err instanceof Error ? err.message : "Failed to generate image.";
+        const errorObj = err instanceof Error ? err : new Error(errorMsg);
+        if (onError) {
+          onError(errorObj);
+        }
+        return { data: null, error: errorMsg };
+      } finally {
+        if (abortControllerRef.current === abortController) {
+          setIsLoading(false);
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [getToken, baseUrl, onFinish, onError]
+  );
+  return {
+    isLoading,
+    generateImage,
+    stop
+  };
+}
+
+// src/react/useModels.ts
+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] = useState4([]);
+  const [isLoading, setIsLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const getTokenRef = useRef3(getToken);
+  const baseUrlRef = useRef3(baseUrl);
+  const providerRef = useRef3(provider);
+  const abortControllerRef = useRef3(null);
+  useEffect3(() => {
+    getTokenRef.current = getToken;
+    baseUrlRef.current = baseUrl;
+    providerRef.current = provider;
+  });
+  useEffect3(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, []);
+  const fetchModels = useCallback4(async () => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    const signal = abortController.signal;
+    setIsLoading(true);
+    setError(null);
+    try {
+      let token;
+      if (getTokenRef.current) {
+        token = await getTokenRef.current() ?? void 0;
+      }
+      if (signal.aborted) return;
+      const headers = {};
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      let allModels = [];
+      let nextPageToken;
+      do {
+        if (signal.aborted) return;
+        const response = await getApiV1Models({
+          baseUrl: baseUrlRef.current,
+          headers,
+          query: {
+            provider: providerRef.current,
+            page_token: nextPageToken
+          },
+          signal
+        });
+        if (response.error) {
+          const errorMsg = response.error.error ?? "Failed to fetch models";
+          throw new Error(errorMsg);
+        }
+        if (response.data) {
+          const newModels = response.data.data || [];
+          allModels = [...allModels, ...newModels];
+          nextPageToken = response.data.next_page_token;
+        }
+      } while (nextPageToken);
+      if (signal.aborted) return;
+      setModels(allModels);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return;
+      }
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (!signal.aborted) {
+        setIsLoading(false);
+      }
+      if (abortControllerRef.current === abortController) {
+        abortControllerRef.current = null;
+      }
+    }
+  }, []);
+  const refetch = useCallback4(async () => {
+    setModels([]);
+    await fetchModels();
+  }, [fetchModels]);
+  const hasFetchedRef = useRef3(false);
+  useEffect3(() => {
+    if (autoFetch && !hasFetchedRef.current) {
+      hasFetchedRef.current = true;
+      fetchModels();
+    }
+    if (!autoFetch) {
+      hasFetchedRef.current = false;
+    }
+  }, [autoFetch, fetchModels]);
+  return {
+    models,
+    isLoading,
+    error,
+    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/db/memory/schema.ts
+import { appSchema as appSchema2, tableSchema as tableSchema2 } from "@nozbe/watermelondb";
+var memoryStorageSchema = appSchema2({
+  version: 1,
+  tables: [
+    tableSchema2({
+      name: "memories",
+      columns: [
+        { name: "type", type: "string", isIndexed: true },
+        { name: "namespace", type: "string", isIndexed: true },
+        { name: "key", type: "string", isIndexed: true },
+        { name: "value", type: "string" },
+        { name: "raw_evidence", type: "string" },
+        { name: "confidence", type: "number" },
+        { name: "pii", type: "boolean", isIndexed: true },
+        { name: "composite_key", type: "string", isIndexed: true },
+        { name: "unique_key", type: "string", isIndexed: true },
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        { name: "embedding", type: "string", isOptional: true },
+        { name: "embedding_model", type: "string", isOptional: true },
+        { name: "is_deleted", type: "boolean", isIndexed: true }
+      ]
+    })
+  ]
+});
+
+// src/lib/db/memory/models.ts
+import { Model as Model2 } from "@nozbe/watermelondb";
+import { field as field2, text as text2, date as date2, json as json2 } from "@nozbe/watermelondb/decorators";
+var Memory = class extends Model2 {
+};
+Memory.table = "memories";
+__decorateClass([
+  text2("type")
+], Memory.prototype, "type", 2);
+__decorateClass([
+  text2("namespace")
+], Memory.prototype, "namespace", 2);
+__decorateClass([
+  text2("key")
+], Memory.prototype, "key", 2);
+__decorateClass([
+  text2("value")
+], Memory.prototype, "value", 2);
+__decorateClass([
+  text2("raw_evidence")
+], Memory.prototype, "rawEvidence", 2);
+__decorateClass([
+  field2("confidence")
+], Memory.prototype, "confidence", 2);
+__decorateClass([
+  field2("pii")
+], Memory.prototype, "pii", 2);
+__decorateClass([
+  text2("composite_key")
+], Memory.prototype, "compositeKey", 2);
+__decorateClass([
+  text2("unique_key")
+], Memory.prototype, "uniqueKey", 2);
+__decorateClass([
+  date2("created_at")
+], Memory.prototype, "createdAt", 2);
+__decorateClass([
+  date2("updated_at")
+], Memory.prototype, "updatedAt", 2);
+__decorateClass([
+  json2("embedding", (json3) => json3)
+], Memory.prototype, "embedding", 2);
+__decorateClass([
+  text2("embedding_model")
+], Memory.prototype, "embeddingModel", 2);
+__decorateClass([
+  field2("is_deleted")
+], Memory.prototype, "isDeleted", 2);
+
+// src/lib/db/memory/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/db/memory/operations.ts
+import { Q as Q2 } from "@nozbe/watermelondb";
+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) {
+  if (!opts.namespace || typeof opts.namespace !== "string") {
+    throw new Error("Namespace is required and must be a string");
+  }
+  if (!opts.key || typeof opts.key !== "string") {
+    throw new Error("Key is required and must be a string");
+  }
+  if (!opts.value || typeof opts.value !== "string") {
+    throw new Error("Value is required and must be a string");
+  }
+  if (!opts.type || typeof opts.type !== "string") {
+    throw new Error("Type is required and must be a string");
+  }
+  if (typeof opts.confidence !== "number" || opts.confidence < 0 || opts.confidence > 1) {
+    throw new Error("Confidence must be a number between 0 and 1");
+  }
+  if (typeof opts.pii !== "boolean") {
+    throw new Error("PII must be a boolean");
+  }
+  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(text4, 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: text4,
+      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 text4 = `${memory.type}: ${memory.namespace}/${memory.key} = ${memory.value}. Evidence: ${memory.rawEvidence}`;
+  return generateEmbeddingForTextApi(text4, options);
+}
+function useMemoryStorage(options) {
+  const {
+    database,
+    completionsModel = DEFAULT_COMPLETION_MODEL,
+    embeddingModel: userEmbeddingModel,
+    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/db/schema.ts
+import { appSchema as appSchema3, tableSchema as tableSchema3 } from "@nozbe/watermelondb";
+import {
+  schemaMigrations as schemaMigrations2,
+  addColumns as addColumns2,
+  createTable
+} from "@nozbe/watermelondb/Schema/migrations";
+
+// src/lib/db/settings/models.ts
+import { Model as Model3 } from "@nozbe/watermelondb";
+import { text as text3 } from "@nozbe/watermelondb/decorators";
+var ModelPreference = class extends Model3 {
+};
+ModelPreference.table = "modelPreferences";
+__decorateClass([
+  text3("wallet_address")
+], ModelPreference.prototype, "walletAddress", 2);
+__decorateClass([
+  text3("models")
+], ModelPreference.prototype, "models", 2);
+
+// src/lib/db/schema.ts
+var SDK_SCHEMA_VERSION = 6;
+var sdkSchema = appSchema3({
+  version: SDK_SCHEMA_VERSION,
+  tables: [
+    // Chat storage tables
+    tableSchema3({
+      name: "history",
+      columns: [
+        { name: "message_id", type: "number" },
+        { name: "conversation_id", type: "string", isIndexed: true },
+        { name: "role", type: "string", isIndexed: true },
+        { name: "content", type: "string" },
+        { name: "model", type: "string", isOptional: true },
+        { name: "files", type: "string", isOptional: true },
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        { name: "vector", type: "string", isOptional: true },
+        { name: "embedding_model", type: "string", isOptional: true },
+        { name: "usage", type: "string", isOptional: true },
+        { name: "sources", type: "string", isOptional: true },
+        { name: "response_duration", type: "number", isOptional: true },
+        { name: "was_stopped", type: "boolean", isOptional: true },
+        { name: "error", type: "string", isOptional: true },
+        { name: "thought_process", type: "string", isOptional: true }
+        // JSON stringified ActivityPhase[]
+      ]
+    }),
+    tableSchema3({
+      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 }
+      ]
+    }),
+    // Memory storage tables
+    tableSchema3({
+      name: "memories",
+      columns: [
+        { name: "type", type: "string", isIndexed: true },
+        { name: "namespace", type: "string", isIndexed: true },
+        { name: "key", type: "string", isIndexed: true },
+        { name: "value", type: "string" },
+        { name: "raw_evidence", type: "string" },
+        { name: "confidence", type: "number" },
+        { name: "pii", type: "boolean", isIndexed: true },
+        { name: "composite_key", type: "string", isIndexed: true },
+        { name: "unique_key", type: "string", isIndexed: true },
+        { name: "created_at", type: "number", isIndexed: true },
+        { name: "updated_at", type: "number" },
+        { name: "embedding", type: "string", isOptional: true },
+        { name: "embedding_model", type: "string", isOptional: true },
+        { name: "is_deleted", type: "boolean", isIndexed: true }
+      ]
+    }),
+    // Settings storage tables
+    tableSchema3({
+      name: "modelPreferences",
+      columns: [
+        { name: "wallet_address", type: "string", isIndexed: true },
+        { name: "models", type: "string", isOptional: true }
+      ]
+    })
+  ]
+});
+var sdkMigrations = schemaMigrations2({
+  migrations: [
+    // v2 -> v3: Added was_stopped column to history
+    {
+      toVersion: 3,
+      steps: [
+        addColumns2({
+          table: "history",
+          columns: [{ name: "was_stopped", type: "boolean", isOptional: true }]
+        })
+      ]
+    },
+    // v3 -> v4: Added settings storage (modelPreferences table)
+    {
+      toVersion: 4,
+      steps: [
+        createTable({
+          name: "modelPreferences",
+          columns: [
+            { name: "wallet_address", type: "string", isIndexed: true },
+            { name: "models", type: "string", isOptional: true }
+          ]
+        })
+      ]
+    },
+    // v4 -> v5: Added error column to history for error persistence
+    {
+      toVersion: 5,
+      steps: [
+        addColumns2({
+          table: "history",
+          columns: [{ name: "error", type: "string", isOptional: true }]
+        })
+      ]
+    },
+    // v5 -> v6: Added thought_process column to history table
+    {
+      toVersion: 6,
+      steps: [
+        addColumns2({
+          table: "history",
+          columns: [
+            { name: "thought_process", type: "string", isOptional: true }
+          ]
+        })
+      ]
+    }
+  ]
+});
+var sdkModelClasses = [
+  Message,
+  Conversation,
+  Memory,
+  ModelPreference
+];
+export {
+  Conversation as ChatConversation,
+  Message as ChatMessage,
+  Memory as StoredMemoryModel,
+  chatStorageMigrations,
+  chatStorageSchema,
+  generateCompositeKey,
+  generateConversationId,
+  generateUniqueKey,
+  memoryStorageSchema,
+  sdkMigrations,
+  sdkModelClasses,
+  sdkSchema,
+  useChat,
+  useChatStorage,
+  useImageGeneration,
+  useMemoryStorage,
+  useModels
+};