@reverbia/sdk 1.0.0-next.20251219092050 → 1.0.0-next.20251219162520

package/dist/react/index.mjs

@@ -1704,7 +1704,7 @@ import {
   addColumns
 } from "@nozbe/watermelondb/Schema/migrations";
 var chatStorageSchema = appSchema({
-  version: 2,
+  version: 3,
   tables: [
     tableSchema({
       name: "history",
@@ -1722,7 +1722,8 @@ var chatStorageSchema = appSchema({
         { 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: "was_stopped", type: "boolean", isOptional: true },
+        { name: "error", type: "string", isOptional: true }
       ]
     }),
     tableSchema({
@@ -1747,6 +1748,15 @@ var chatStorageMigrations = schemaMigrations({
           columns: [{ name: "was_stopped", type: "boolean", isOptional: true }]
         })
       ]
+    },
+    {
+      toVersion: 3,
+      steps: [
+        addColumns({
+          table: "history",
+          columns: [{ name: "error", type: "string", isOptional: true }]
+        })
+      ]
     }
   ]
 });
@@ -1802,6 +1812,9 @@ __decorateClass([
 __decorateClass([
   field("was_stopped")
 ], Message.prototype, "wasStopped", 2);
+__decorateClass([
+  text("error")
+], Message.prototype, "error", 2);
 var Conversation = class extends Model {
 };
 Conversation.table = "conversations";
@@ -1856,7 +1869,8 @@ function messageToStored(message) {
     usage: message.usage,
     sources: message.sources,
     responseDuration: message.responseDuration,
-    wasStopped: message.wasStopped
+    wasStopped: message.wasStopped,
+    error: message.error
   };
 }
 function conversationToStored(conversation) {
@@ -1946,6 +1960,7 @@ async function createMessageOp(ctx, opts) {
       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);
     });
   });
   return messageToStored(created);
@@ -1965,6 +1980,20 @@ async function updateMessageEmbeddingOp(ctx, uniqueId, vector, embeddingModel) {
   });
   return messageToStored(message);
 }
+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);
+}
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) return 0;
   let dotProduct = 0;
@@ -2182,7 +2211,8 @@ function useChatStorage(options) {
       let messagesToSend = [];
       if (includeHistory && !providedMessages) {
         const storedMessages = await getMessages(convId);
-        const limitedMessages = storedMessages.slice(-maxHistoryMessages);
+        const validMessages = storedMessages.filter((msg) => !msg.error);
+        const limitedMessages = validMessages.slice(-maxHistoryMessages);
         messagesToSend = limitedMessages.map(storedToLlmapiMessage);
       } else if (providedMessages) {
         messagesToSend = providedMessages;
@@ -2281,14 +2311,37 @@ function useChatStorage(options) {
               userMessage: storedUserMessage,
               assistantMessage: storedAssistantMessage2
             };
-          } catch (err) {
+          } catch {
+            return {
+              data: null,
+              error: "Request aborted",
+              toolExecution: abortedResult.toolExecution,
+              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,
+            error: errorMessage
+          });
+        } catch {
+        }
         return {
           data: null,
-          error: result.error || "No response data received",
+          error: errorMessage,
           toolExecution: result.toolExecution,
-          userMessage: storedUserMessage
+          userMessage: { ...storedUserMessage, error: errorMessage }
         };
       }
       const responseData = result.data;
@@ -2430,7 +2483,7 @@ __decorateClass([
 ], ModelPreference.prototype, "models", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 4;
+var SDK_SCHEMA_VERSION = 5;
 var sdkSchema = appSchema2({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -2451,7 +2504,8 @@ var sdkSchema = appSchema2({
         { 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: "was_stopped", type: "boolean", isOptional: true },
+        { name: "error", type: "string", isOptional: true }
       ]
     }),
     tableSchema2({
@@ -2518,6 +2572,16 @@ var sdkMigrations = schemaMigrations2({
           ]
         })
       ]
+    },
+    // v4 -> v5: Added error column to history for error persistence
+    {
+      toVersion: 5,
+      steps: [
+        addColumns2({
+          table: "history",
+          columns: [{ name: "error", type: "string", isOptional: true }]
+        })
+      ]
     }
   ]
 });
@@ -5575,7 +5639,7 @@ function useGoogleDriveBackup(options) {
   };
 }
 
-// src/react/useBackupAuth.ts
+// src/react/useICloudAuth.ts
 import {
   createContext as createContext3,
   createElement as createElement3,
@@ -5584,20 +5648,593 @@ import {
   useEffect as useEffect8,
   useState as useState12
 } from "react";
-var BackupAuthContext = createContext3(null);
+
+// src/lib/backup/icloud/api.ts
+var CLOUDKIT_JS_URL = "https://cdn.apple-cloudkit.com/ck/2/cloudkit.js";
+var DEFAULT_BACKUP_FOLDER2 = "conversations";
+var DEFAULT_CONTAINER_ID = "iCloud.Memoryless";
+var RECORD_TYPE = "ConversationBackup";
+var cloudKitLoadPromise = null;
+function isCloudKitAvailable() {
+  return typeof window !== "undefined" && !!window.CloudKit;
+}
+async function loadCloudKit() {
+  if (typeof window === "undefined") {
+    throw new Error("CloudKit JS can only be loaded in browser environment");
+  }
+  if (window.CloudKit) {
+    return;
+  }
+  if (cloudKitLoadPromise) {
+    return cloudKitLoadPromise;
+  }
+  cloudKitLoadPromise = new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = CLOUDKIT_JS_URL;
+    script.async = true;
+    script.onload = () => {
+      if (window.CloudKit) {
+        resolve();
+      } else {
+        reject(new Error("CloudKit JS loaded but CloudKit object not found"));
+      }
+    };
+    script.onerror = () => {
+      cloudKitLoadPromise = null;
+      reject(new Error("Failed to load CloudKit JS"));
+    };
+    document.head.appendChild(script);
+  });
+  return cloudKitLoadPromise;
+}
+async function ensureCloudKitLoaded() {
+  if (!isCloudKitAvailable()) {
+    await loadCloudKit();
+  }
+}
+async function configureCloudKit(config) {
+  await ensureCloudKitLoaded();
+  ensureAuthElements();
+  window.CloudKit.configure({
+    containers: [
+      {
+        containerIdentifier: config.containerIdentifier,
+        apiTokenAuth: {
+          apiToken: config.apiToken,
+          persist: true,
+          signInButton: {
+            id: "apple-sign-in-button",
+            theme: "black"
+          },
+          signOutButton: {
+            id: "apple-sign-out-button",
+            theme: "black"
+          }
+        },
+        environment: config.environment
+      }
+    ]
+  });
+}
+async function getContainer() {
+  await ensureCloudKitLoaded();
+  return window.CloudKit.getDefaultContainer();
+}
+function ensureAuthElements() {
+  let signInButton = document.getElementById("apple-sign-in-button");
+  let signOutButton = document.getElementById("apple-sign-out-button");
+  if (!signInButton) {
+    signInButton = document.createElement("div");
+    signInButton.id = "apple-sign-in-button";
+    signInButton.style.position = "fixed";
+    signInButton.style.top = "-9999px";
+    signInButton.style.left = "-9999px";
+    document.body.appendChild(signInButton);
+  }
+  if (!signOutButton) {
+    signOutButton = document.createElement("div");
+    signOutButton.id = "apple-sign-out-button";
+    signOutButton.style.position = "fixed";
+    signOutButton.style.top = "-9999px";
+    signOutButton.style.left = "-9999px";
+    document.body.appendChild(signOutButton);
+  }
+  return { signIn: signInButton, signOut: signOutButton };
+}
+async function authenticateICloud() {
+  const container = await getContainer();
+  ensureAuthElements();
+  return container.setUpAuth();
+}
+async function requestICloudSignIn() {
+  const container = await getContainer();
+  const { signIn } = ensureAuthElements();
+  const existingUser = await container.setUpAuth();
+  if (existingUser) {
+    return existingUser;
+  }
+  console.log("[CloudKit] Sign-in container innerHTML:", signIn.innerHTML);
+  console.log("[CloudKit] Sign-in container children:", signIn.children.length);
+  const appleButton = signIn.querySelector("a, button, [role='button'], div[id*='apple']");
+  console.log("[CloudKit] Found button element:", appleButton);
+  if (appleButton) {
+    console.log("[CloudKit] Clicking button...");
+    appleButton.click();
+  } else {
+    const anyClickable = signIn.firstElementChild;
+    if (anyClickable) {
+      console.log("[CloudKit] Clicking first child element:", anyClickable);
+      anyClickable.click();
+    }
+  }
+  return container.whenUserSignsIn();
+}
+async function uploadFileToICloud(filename, content) {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const recordName = `backup_${filename.replace(/[^a-zA-Z0-9]/g, "_")}`;
+  const arrayBuffer = await content.arrayBuffer();
+  const base64Data = btoa(
+    String.fromCharCode(...new Uint8Array(arrayBuffer))
+  );
+  const record = {
+    recordType: RECORD_TYPE,
+    recordName,
+    fields: {
+      filename: { value: filename },
+      data: { value: base64Data },
+      size: { value: content.size },
+      contentType: { value: content.type || "application/json" }
+    }
+  };
+  const response = await database.saveRecords(record);
+  if (!response.records || response.records.length === 0) {
+    throw new Error("Failed to upload file to iCloud");
+  }
+  const savedRecord = response.records[0];
+  return {
+    recordName: savedRecord.recordName,
+    filename,
+    modifiedAt: new Date(savedRecord.modified?.timestamp ?? Date.now()),
+    size: content.size
+  };
+}
+async function listICloudFiles() {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const query = {
+    recordType: RECORD_TYPE
+    // Note: Sorting requires SORTABLE index on the field in CloudKit Dashboard
+    // For now, we skip sorting and sort client-side after fetching
+  };
+  const allRecords = [];
+  let response = await database.performQuery(query);
+  if (response.records) {
+    allRecords.push(...response.records);
+  }
+  while (response.continuationMarker) {
+    break;
+  }
+  const files = allRecords.map((record) => ({
+    recordName: record.recordName,
+    filename: record.fields.filename?.value ?? "",
+    modifiedAt: new Date(record.modified?.timestamp ?? Date.now()),
+    size: typeof record.fields.data?.value === "object" && record.fields.data?.value !== null ? record.fields.data.value.size : 0
+  }));
+  return files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+}
+async function downloadICloudFile(recordName) {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const response = await database.fetchRecords([{ recordName }], {
+    desiredKeys: ["filename", "data", "contentType"]
+  });
+  if (!response.records || response.records.length === 0) {
+    throw new Error(`File not found: ${recordName}`);
+  }
+  const record = response.records[0];
+  const dataField = record.fields.data?.value;
+  if (!dataField) {
+    throw new Error("No data in record");
+  }
+  if (typeof dataField === "string") {
+    const binaryString = atob(dataField);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return new Blob([bytes], { type: "application/json" });
+  }
+  if (typeof dataField === "object" && "downloadURL" in dataField) {
+    const fetchResponse = await fetch(
+      dataField.downloadURL
+    );
+    if (!fetchResponse.ok) {
+      throw new Error(`Failed to download from iCloud: ${fetchResponse.status}`);
+    }
+    return fetchResponse.blob();
+  }
+  throw new Error("Unknown data format in iCloud record");
+}
+async function findICloudFile(filename) {
+  const container = await getContainer();
+  const database = container.privateCloudDatabase;
+  const query = {
+    recordType: RECORD_TYPE,
+    filterBy: [
+      {
+        fieldName: "filename",
+        comparator: "EQUALS",
+        fieldValue: { value: filename }
+      }
+    ]
+  };
+  const response = await database.performQuery(query);
+  if (!response.records || response.records.length === 0) {
+    return null;
+  }
+  const record = response.records[0];
+  return {
+    recordName: record.recordName,
+    filename: record.fields.filename?.value ?? "",
+    modifiedAt: new Date(record.modified?.timestamp ?? Date.now()),
+    size: typeof record.fields.data?.value === "object" && record.fields.data?.value !== null ? record.fields.data.value.size : 0
+  };
+}
+
+// src/react/useICloudAuth.ts
+var ICloudAuthContext = createContext3(null);
+function ICloudAuthProvider({
+  apiToken,
+  containerIdentifier = DEFAULT_CONTAINER_ID,
+  environment = "production",
+  children
+}) {
+  const [isAuthenticated, setIsAuthenticated] = useState12(false);
+  const [userRecordName, setUserRecordName] = useState12(null);
+  const [isAvailable, setIsAvailable] = useState12(false);
+  const [isConfigured, setIsConfigured] = useState12(false);
+  const [isLoading, setIsLoading] = useState12(false);
+  useEffect8(() => {
+    if (!apiToken || typeof window === "undefined") {
+      return;
+    }
+    const initCloudKit = async () => {
+      setIsLoading(true);
+      try {
+        await loadCloudKit();
+        setIsAvailable(true);
+        const config = {
+          containerIdentifier,
+          apiToken,
+          environment
+        };
+        await configureCloudKit(config);
+        setIsConfigured(true);
+        try {
+          const userIdentity = await authenticateICloud();
+          if (userIdentity) {
+            setIsAuthenticated(true);
+            setUserRecordName(userIdentity.userRecordName);
+          }
+        } catch {
+        }
+      } catch {
+        setIsAvailable(false);
+        setIsConfigured(false);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    initCloudKit();
+  }, [apiToken, containerIdentifier, environment]);
+  const requestAccess = useCallback14(async () => {
+    if (!isConfigured) {
+      throw new Error("iCloud is not configured");
+    }
+    if (isAuthenticated) {
+      return;
+    }
+    try {
+      const userIdentity = await requestICloudSignIn();
+      setIsAuthenticated(true);
+      setUserRecordName(userIdentity.userRecordName);
+    } catch (err) {
+      throw new Error(
+        err instanceof Error ? err.message : "Failed to sign in to iCloud"
+      );
+    }
+  }, [isAuthenticated, isConfigured]);
+  const logout = useCallback14(() => {
+    setIsAuthenticated(false);
+    setUserRecordName(null);
+  }, []);
+  return createElement3(
+    ICloudAuthContext.Provider,
+    {
+      value: {
+        isAuthenticated,
+        isConfigured,
+        isAvailable,
+        userRecordName,
+        requestAccess,
+        logout
+      }
+    },
+    children
+  );
+}
+function useICloudAuth() {
+  const context = useContext3(ICloudAuthContext);
+  if (!context) {
+    throw new Error("useICloudAuth must be used within ICloudAuthProvider");
+  }
+  return context;
+}
+function hasICloudCredentials() {
+  return isCloudKitAvailable();
+}
+function clearICloudAuth() {
+}
+
+// src/react/useICloudBackup.ts
+import { useCallback as useCallback15, useMemo as useMemo6 } from "react";
+
+// src/lib/backup/icloud/backup.ts
+var isAuthError3 = (err) => err instanceof Error && (err.message.includes("AUTHENTICATION") || err.message.includes("NOT_AUTHENTICATED") || err.message.includes("sign in"));
+async function pushConversationToICloud(database, conversationId, userAddress, deps, _retried = false) {
+  try {
+    await deps.requestEncryptionKey(userAddress);
+    const filename = `${conversationId}.json`;
+    const existingFile = await findICloudFile(filename);
+    if (existingFile) {
+      const { Q: Q4 } = await import("@nozbe/watermelondb");
+      const conversationsCollection = database.get("conversations");
+      const records = await conversationsCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+      if (records.length > 0) {
+        const conversation = conversationToStored(records[0]);
+        const localUpdated = conversation.updatedAt.getTime();
+        const remoteModified = existingFile.modifiedAt.getTime();
+        if (localUpdated <= remoteModified) {
+          return "skipped";
+        }
+      }
+    }
+    const exportResult = await deps.exportConversation(
+      conversationId,
+      userAddress
+    );
+    if (!exportResult.success || !exportResult.blob) {
+      return "failed";
+    }
+    await uploadFileToICloud(filename, exportResult.blob);
+    return "uploaded";
+  } catch (err) {
+    if (isAuthError3(err) && !_retried) {
+      try {
+        await deps.requestICloudAccess();
+        return pushConversationToICloud(
+          database,
+          conversationId,
+          userAddress,
+          deps,
+          true
+        );
+      } catch {
+        return "failed";
+      }
+    }
+    return "failed";
+  }
+}
+async function performICloudExport(database, userAddress, deps, onProgress) {
+  await deps.requestEncryptionKey(userAddress);
+  const { Q: Q4 } = await import("@nozbe/watermelondb");
+  const conversationsCollection = database.get("conversations");
+  const records = await conversationsCollection.query(Q4.where("is_deleted", false)).fetch();
+  const conversations = records.map(conversationToStored);
+  const total = conversations.length;
+  if (total === 0) {
+    return { success: true, uploaded: 0, skipped: 0, total: 0 };
+  }
+  let uploaded = 0;
+  let skipped = 0;
+  for (let i = 0; i < conversations.length; i++) {
+    const conv = conversations[i];
+    onProgress?.(i + 1, total);
+    const result = await pushConversationToICloud(
+      database,
+      conv.conversationId,
+      userAddress,
+      deps
+    );
+    if (result === "uploaded") uploaded++;
+    if (result === "skipped") skipped++;
+  }
+  return { success: true, uploaded, skipped, total };
+}
+async function performICloudImport(userAddress, deps, onProgress) {
+  await deps.requestEncryptionKey(userAddress);
+  const remoteFiles = await listICloudFiles();
+  if (remoteFiles.length === 0) {
+    return {
+      success: false,
+      restored: 0,
+      failed: 0,
+      total: 0,
+      noBackupsFound: true
+    };
+  }
+  const jsonFiles = remoteFiles.filter(
+    (file) => file.filename.endsWith(".json")
+  );
+  const total = jsonFiles.length;
+  let restored = 0;
+  let failed = 0;
+  for (let i = 0; i < jsonFiles.length; i++) {
+    const file = jsonFiles[i];
+    onProgress?.(i + 1, total);
+    try {
+      const blob = await downloadICloudFile(file.recordName);
+      const result = await deps.importConversation(blob, userAddress);
+      if (result.success) {
+        restored++;
+      } else {
+        failed++;
+      }
+    } catch (err) {
+      if (isAuthError3(err)) {
+        try {
+          await deps.requestICloudAccess();
+          const blob = await downloadICloudFile(file.recordName);
+          const result = await deps.importConversation(blob, userAddress);
+          if (result.success) {
+            restored++;
+          } else {
+            failed++;
+          }
+        } catch {
+          failed++;
+        }
+      } else {
+        failed++;
+      }
+    }
+  }
+  return { success: true, restored, failed, total };
+}
+
+// src/react/useICloudBackup.ts
+function useICloudBackup(options) {
+  const {
+    database,
+    userAddress,
+    requestEncryptionKey: requestEncryptionKey2,
+    exportConversation,
+    importConversation
+  } = options;
+  const {
+    isAuthenticated,
+    isConfigured,
+    isAvailable,
+    requestAccess
+  } = useICloudAuth();
+  const deps = useMemo6(
+    () => ({
+      requestICloudAccess: requestAccess,
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const ensureAuthenticated = useCallback15(async () => {
+    if (isAuthenticated) return true;
+    try {
+      await requestAccess();
+      return true;
+    } catch {
+      return false;
+    }
+  }, [isAuthenticated, requestAccess]);
+  const backup = useCallback15(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to iCloud" };
+      }
+      if (!isAvailable) {
+        return { error: "CloudKit JS is not loaded" };
+      }
+      if (!isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      const authenticated = await ensureAuthenticated();
+      if (!authenticated) {
+        return { error: "iCloud access denied" };
+      }
+      try {
+        return await performICloudExport(
+          database,
+          userAddress,
+          deps,
+          backupOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to iCloud"
+        };
+      }
+    },
+    [database, userAddress, isAvailable, isConfigured, ensureAuthenticated, deps]
+  );
+  const restore = useCallback15(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from iCloud" };
+      }
+      if (!isAvailable) {
+        return { error: "CloudKit JS is not loaded" };
+      }
+      if (!isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      const authenticated = await ensureAuthenticated();
+      if (!authenticated) {
+        return { error: "iCloud access denied" };
+      }
+      try {
+        return await performICloudImport(
+          userAddress,
+          deps,
+          restoreOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from iCloud"
+        };
+      }
+    },
+    [userAddress, isAvailable, isConfigured, ensureAuthenticated, deps]
+  );
+  return {
+    backup,
+    restore,
+    isConfigured,
+    isAuthenticated,
+    isAvailable
+  };
+}
+
+// src/react/useBackupAuth.ts
+import {
+  createContext as createContext4,
+  createElement as createElement4,
+  useCallback as useCallback16,
+  useContext as useContext4,
+  useEffect as useEffect9,
+  useState as useState13
+} from "react";
+var BackupAuthContext = createContext4(null);
 function BackupAuthProvider({
   dropboxAppKey,
   dropboxCallbackPath = "/auth/dropbox/callback",
   googleClientId,
   googleCallbackPath = "/auth/google/callback",
+  icloudApiToken,
+  icloudContainerIdentifier = DEFAULT_CONTAINER_ID,
+  icloudEnvironment = "production",
   apiClient,
   children
 }) {
-  const [dropboxToken, setDropboxToken] = useState12(null);
+  const [dropboxToken, setDropboxToken] = useState13(null);
   const isDropboxConfigured = !!dropboxAppKey;
-  const [googleToken, setGoogleToken] = useState12(null);
+  const [googleToken, setGoogleToken] = useState13(null);
   const isGoogleConfigured = !!googleClientId;
-  useEffect8(() => {
+  const [icloudAuthenticated, setIcloudAuthenticated] = useState13(false);
+  const [icloudUserRecordName, setIcloudUserRecordName] = useState13(null);
+  const [isIcloudAvailable, setIsIcloudAvailable] = useState13(false);
+  const isIcloudConfigured = isIcloudAvailable && !!icloudApiToken;
+  useEffect9(() => {
     const checkStoredTokens = async () => {
       if (hasDropboxCredentials()) {
         const token = await getDropboxAccessToken(apiClient);
@@ -5614,7 +6251,35 @@ function BackupAuthProvider({
     };
     checkStoredTokens();
   }, [apiClient]);
-  useEffect8(() => {
+  useEffect9(() => {
+    if (!icloudApiToken || typeof window === "undefined") {
+      return;
+    }
+    const initCloudKit = async () => {
+      try {
+        await loadCloudKit();
+        setIsIcloudAvailable(true);
+        const config = {
+          containerIdentifier: icloudContainerIdentifier,
+          apiToken: icloudApiToken,
+          environment: icloudEnvironment
+        };
+        await configureCloudKit(config);
+        try {
+          const userIdentity = await authenticateICloud();
+          if (userIdentity) {
+            setIcloudAuthenticated(true);
+            setIcloudUserRecordName(userIdentity.userRecordName);
+          }
+        } catch {
+        }
+      } catch {
+        setIsIcloudAvailable(false);
+      }
+    };
+    initCloudKit();
+  }, [icloudApiToken, icloudContainerIdentifier, icloudEnvironment]);
+  useEffect9(() => {
     if (!isDropboxConfigured) return;
     const handleCallback = async () => {
       if (isDropboxCallback()) {
@@ -5629,7 +6294,7 @@ function BackupAuthProvider({
     };
     handleCallback();
   }, [dropboxCallbackPath, isDropboxConfigured, apiClient]);
-  useEffect8(() => {
+  useEffect9(() => {
     if (!isGoogleConfigured) return;
     const handleCallback = async () => {
       if (isGoogleDriveCallback()) {
@@ -5644,14 +6309,14 @@ function BackupAuthProvider({
     };
     handleCallback();
   }, [googleCallbackPath, isGoogleConfigured, apiClient]);
-  const refreshDropboxTokenFn = useCallback14(async () => {
+  const refreshDropboxTokenFn = useCallback16(async () => {
     const token = await getDropboxAccessToken(apiClient);
     if (token) {
       setDropboxToken(token);
     }
     return token;
   }, [apiClient]);
-  const requestDropboxAccess = useCallback14(async () => {
+  const requestDropboxAccess = useCallback16(async () => {
     if (!isDropboxConfigured || !dropboxAppKey) {
       throw new Error("Dropbox is not configured");
     }
@@ -5671,18 +6336,18 @@ function BackupAuthProvider({
     isDropboxConfigured,
     apiClient
   ]);
-  const logoutDropbox = useCallback14(async () => {
+  const logoutDropbox = useCallback16(async () => {
     await revokeDropboxToken(apiClient);
     setDropboxToken(null);
   }, [apiClient]);
-  const refreshGoogleTokenFn = useCallback14(async () => {
+  const refreshGoogleTokenFn = useCallback16(async () => {
     const token = await getGoogleDriveAccessToken(apiClient);
     if (token) {
       setGoogleToken(token);
     }
     return token;
   }, [apiClient]);
-  const requestGoogleAccess = useCallback14(async () => {
+  const requestGoogleAccess = useCallback16(async () => {
     if (!isGoogleConfigured || !googleClientId) {
       throw new Error("Google Drive is not configured");
     }
@@ -5702,16 +6367,51 @@ function BackupAuthProvider({
     isGoogleConfigured,
     apiClient
   ]);
-  const logoutGoogle = useCallback14(async () => {
+  const logoutGoogle = useCallback16(async () => {
     await revokeGoogleDriveToken(apiClient);
     setGoogleToken(null);
   }, [apiClient]);
-  const logoutAll = useCallback14(async () => {
+  const refreshIcloudTokenFn = useCallback16(async () => {
+    try {
+      const userIdentity = await authenticateICloud();
+      if (userIdentity) {
+        setIcloudAuthenticated(true);
+        setIcloudUserRecordName(userIdentity.userRecordName);
+        return userIdentity.userRecordName;
+      }
+    } catch {
+    }
+    return null;
+  }, []);
+  const requestIcloudAccess = useCallback16(async () => {
+    if (!isIcloudConfigured) {
+      throw new Error("iCloud is not configured");
+    }
+    if (icloudAuthenticated && icloudUserRecordName) {
+      return icloudUserRecordName;
+    }
+    try {
+      const userIdentity = await requestICloudSignIn();
+      setIcloudAuthenticated(true);
+      setIcloudUserRecordName(userIdentity.userRecordName);
+      return userIdentity.userRecordName;
+    } catch (err) {
+      throw new Error(
+        err instanceof Error ? err.message : "Failed to sign in to iCloud"
+      );
+    }
+  }, [icloudAuthenticated, icloudUserRecordName, isIcloudConfigured]);
+  const logoutIcloud = useCallback16(async () => {
+    setIcloudAuthenticated(false);
+    setIcloudUserRecordName(null);
+  }, []);
+  const logoutAll = useCallback16(async () => {
     await Promise.all([
       isDropboxConfigured ? logoutDropbox() : Promise.resolve(),
-      isGoogleConfigured ? logoutGoogle() : Promise.resolve()
+      isGoogleConfigured ? logoutGoogle() : Promise.resolve(),
+      isIcloudConfigured ? logoutIcloud() : Promise.resolve()
     ]);
-  }, [isDropboxConfigured, isGoogleConfigured, logoutDropbox, logoutGoogle]);
+  }, [isDropboxConfigured, isGoogleConfigured, isIcloudConfigured, logoutDropbox, logoutGoogle, logoutIcloud]);
   const dropboxState = {
     accessToken: dropboxToken,
     isAuthenticated: !!dropboxToken,
@@ -5728,14 +6428,24 @@ function BackupAuthProvider({
     logout: logoutGoogle,
     refreshToken: refreshGoogleTokenFn
   };
-  return createElement3(
+  const icloudState = {
+    accessToken: icloudUserRecordName,
+    // Use userRecordName as the "token" for iCloud
+    isAuthenticated: icloudAuthenticated,
+    isConfigured: isIcloudConfigured,
+    requestAccess: requestIcloudAccess,
+    logout: logoutIcloud,
+    refreshToken: refreshIcloudTokenFn
+  };
+  return createElement4(
     BackupAuthContext.Provider,
     {
       value: {
         dropbox: dropboxState,
         googleDrive: googleDriveState,
-        hasAnyProvider: isDropboxConfigured || isGoogleConfigured,
-        hasAnyAuthentication: !!dropboxToken || !!googleToken,
+        icloud: icloudState,
+        hasAnyProvider: isDropboxConfigured || isGoogleConfigured || isIcloudConfigured,
+        hasAnyAuthentication: !!dropboxToken || !!googleToken || icloudAuthenticated,
         logoutAll
       }
     },
@@ -5743,7 +6453,7 @@ function BackupAuthProvider({
   );
 }
 function useBackupAuth() {
-  const context = useContext3(BackupAuthContext);
+  const context = useContext4(BackupAuthContext);
   if (!context) {
     throw new Error("useBackupAuth must be used within BackupAuthProvider");
   }
@@ -5751,7 +6461,7 @@ function useBackupAuth() {
 }
 
 // src/react/useBackup.ts
-import { useCallback as useCallback15, useMemo as useMemo6 } from "react";
+import { useCallback as useCallback17, useMemo as useMemo7 } from "react";
 function useBackup(options) {
   const {
     database,
@@ -5766,11 +6476,12 @@ function useBackup(options) {
   const {
     dropbox: dropboxAuth,
     googleDrive: googleDriveAuth,
+    icloud: icloudAuth,
     hasAnyProvider,
     hasAnyAuthentication,
     logoutAll
   } = useBackupAuth();
-  const dropboxDeps = useMemo6(
+  const dropboxDeps = useMemo7(
     () => ({
       requestDropboxAccess: dropboxAuth.requestAccess,
       requestEncryptionKey: requestEncryptionKey2,
@@ -5779,7 +6490,7 @@ function useBackup(options) {
     }),
     [dropboxAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
   );
-  const googleDriveDeps = useMemo6(
+  const googleDriveDeps = useMemo7(
     () => ({
       requestDriveAccess: googleDriveAuth.requestAccess,
       requestEncryptionKey: requestEncryptionKey2,
@@ -5788,7 +6499,18 @@ function useBackup(options) {
     }),
     [googleDriveAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
   );
-  const dropboxBackup = useCallback15(
+  const icloudDeps = useMemo7(
+    () => ({
+      requestICloudAccess: async () => {
+        await icloudAuth.requestAccess();
+      },
+      requestEncryptionKey: requestEncryptionKey2,
+      exportConversation,
+      importConversation
+    }),
+    [icloudAuth.requestAccess, requestEncryptionKey2, exportConversation, importConversation]
+  );
+  const dropboxBackup = useCallback17(
     async (backupOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to backup to Dropbox" };
@@ -5818,7 +6540,7 @@ function useBackup(options) {
     },
     [database, userAddress, dropboxAuth, dropboxDeps, dropboxFolder]
   );
-  const dropboxRestore = useCallback15(
+  const dropboxRestore = useCallback17(
     async (restoreOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to restore from Dropbox" };
@@ -5847,7 +6569,7 @@ function useBackup(options) {
     },
     [userAddress, dropboxAuth, dropboxDeps, dropboxFolder]
   );
-  const googleDriveBackup = useCallback15(
+  const googleDriveBackup = useCallback17(
     async (backupOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to backup to Google Drive" };
@@ -5885,7 +6607,7 @@ function useBackup(options) {
       googleConversationsFolder
     ]
   );
-  const googleDriveRestore = useCallback15(
+  const googleDriveRestore = useCallback17(
     async (restoreOptions) => {
       if (!userAddress) {
         return { error: "Please sign in to restore from Google Drive" };
@@ -5937,9 +6659,77 @@ function useBackup(options) {
     connect: googleDriveAuth.requestAccess,
     disconnect: googleDriveAuth.logout
   };
+  const icloudBackup = useCallback17(
+    async (backupOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to backup to iCloud" };
+      }
+      if (!icloudAuth.isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      if (!icloudAuth.isAuthenticated) {
+        try {
+          await icloudAuth.requestAccess();
+        } catch {
+          return { error: "iCloud access denied" };
+        }
+      }
+      try {
+        return await performICloudExport(
+          database,
+          userAddress,
+          icloudDeps,
+          backupOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to backup to iCloud"
+        };
+      }
+    },
+    [database, userAddress, icloudAuth, icloudDeps]
+  );
+  const icloudRestore = useCallback17(
+    async (restoreOptions) => {
+      if (!userAddress) {
+        return { error: "Please sign in to restore from iCloud" };
+      }
+      if (!icloudAuth.isConfigured) {
+        return { error: "iCloud is not configured" };
+      }
+      if (!icloudAuth.isAuthenticated) {
+        try {
+          await icloudAuth.requestAccess();
+        } catch {
+          return { error: "iCloud access denied" };
+        }
+      }
+      try {
+        return await performICloudImport(
+          userAddress,
+          icloudDeps,
+          restoreOptions?.onProgress
+        );
+      } catch (err) {
+        return {
+          error: err instanceof Error ? err.message : "Failed to restore from iCloud"
+        };
+      }
+    },
+    [userAddress, icloudAuth, icloudDeps]
+  );
+  const icloudState = {
+    isConfigured: icloudAuth.isConfigured,
+    isAuthenticated: icloudAuth.isAuthenticated,
+    backup: icloudBackup,
+    restore: icloudRestore,
+    connect: icloudAuth.requestAccess,
+    disconnect: icloudAuth.logout
+  };
   return {
     dropbox: dropboxState,
     googleDrive: googleDriveState,
+    icloud: icloudState,
     hasAnyProvider,
     hasAnyAuthentication,
     disconnectAll: logoutAll
@@ -5948,6 +6738,7 @@ function useBackup(options) {
 export {
   DEFAULT_CONVERSATIONS_FOLDER as BACKUP_DRIVE_CONVERSATIONS_FOLDER,
   DEFAULT_ROOT_FOLDER as BACKUP_DRIVE_ROOT_FOLDER,
+  DEFAULT_BACKUP_FOLDER2 as BACKUP_ICLOUD_FOLDER,
   BackupAuthProvider,
   Conversation as ChatConversation,
   Message as ChatMessage,
@@ -5955,15 +6746,18 @@ export {
   DEFAULT_CONVERSATIONS_FOLDER as DEFAULT_DRIVE_CONVERSATIONS_FOLDER,
   DEFAULT_ROOT_FOLDER as DEFAULT_DRIVE_ROOT_FOLDER,
   DEFAULT_BACKUP_FOLDER as DEFAULT_DROPBOX_FOLDER,
+  DEFAULT_BACKUP_FOLDER2 as DEFAULT_ICLOUD_BACKUP_FOLDER,
   DEFAULT_TOOL_SELECTOR_MODEL,
   DropboxAuthProvider,
   GoogleDriveAuthProvider,
+  ICloudAuthProvider,
   Memory as StoredMemoryModel,
   ModelPreference as StoredModelPreferenceModel,
   chatStorageMigrations,
   chatStorageSchema,
   clearToken as clearDropboxToken,
   clearGoogleDriveToken,
+  clearICloudAuth,
   createMemoryContextSystemMessage,
   decryptData,
   decryptDataBytes,
@@ -5978,6 +6772,7 @@ export {
   hasDropboxCredentials,
   hasEncryptionKey,
   hasGoogleDriveCredentials,
+  hasICloudCredentials,
   memoryStorageSchema,
   requestEncryptionKey,
   sdkMigrations,
@@ -5994,6 +6789,8 @@ export {
   useEncryption,
   useGoogleDriveAuth,
   useGoogleDriveBackup,
+  useICloudAuth,
+  useICloudBackup,
   useImageGeneration,
   useMemoryStorage,
   useModels,