@blinkdotnew/sdk 2.0.0 → 2.0.1

package/dist/index.mjs

@@ -674,7 +674,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI text generation - uses Vercel AI SDK's pipeUIMessageStreamToResponse (Data Stream Protocol)
+   * Stream AI text generation with Vercel AI SDK data stream format
    */
   async streamAiText(prompt, options = {}, onChunk) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/text`);
@@ -704,7 +704,7 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      return this.parseDataStreamProtocol(response.body, onChunk);
+      return this.parseDataStream(response.body, onChunk);
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -729,7 +729,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI object generation - uses Vercel AI SDK's pipeTextStreamToResponse
+   * Stream AI object generation with Vercel AI SDK data stream format
    */
   async streamAiObject(prompt, options = {}, onPartial) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/object`);
@@ -759,35 +759,7 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      let latestObject = {};
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const chunk = decoder.decode(value, { stream: true });
-          buffer += chunk;
-          try {
-            const parsed = JSON.parse(buffer);
-            latestObject = parsed;
-            if (onPartial) {
-              onPartial(parsed);
-            }
-          } catch {
-          }
-        }
-        if (buffer) {
-          try {
-            latestObject = JSON.parse(buffer);
-          } catch {
-          }
-        }
-        return { object: latestObject };
-      } finally {
-        reader.releaseLock();
-      }
+      return this.parseDataStream(response.body, void 0, onPartial);
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -950,94 +922,93 @@ var HttpClient = class {
     }
   }
   /**
-   * Parse Vercel AI SDK v5 Data Stream Protocol (Server-Sent Events)
-   * Supports all event types from the UI Message Stream protocol
+   * Parse Vercel AI SDK data stream format
+   * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
    */
-  async parseDataStreamProtocol(body, onChunk) {
+  async parseDataStream(body, onChunk, onPartial) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
-    const finalResult = {
-      text: "",
-      toolCalls: [],
-      toolResults: [],
-      sources: [],
-      files: [],
-      reasoning: []
-    };
     let buffer = "";
+    let finalResult = {};
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
+        const lines = buffer.split(/\r?\n/);
         buffer = lines.pop() || "";
         for (const line of lines) {
           if (!line.trim()) continue;
-          if (line === "[DONE]") {
-            continue;
-          }
-          if (!line.startsWith("data: ")) continue;
           try {
-            const jsonStr = line.slice(6);
-            const part = JSON.parse(jsonStr);
-            switch (part.type) {
-              case "text-start":
-                break;
-              case "text-delta":
-                if (part.delta) {
-                  finalResult.text += part.delta;
-                  if (onChunk) onChunk(part.delta);
+            if (line.startsWith("f:")) {
+              const metadata = JSON.parse(line.slice(2));
+              finalResult.messageId = metadata.messageId;
+            } else if (line.startsWith("0:")) {
+              const textChunk = JSON.parse(line.slice(2));
+              if (onChunk) {
+                onChunk(textChunk);
+              }
+              finalResult.text = (finalResult.text || "") + textChunk;
+            } else if (line.startsWith("2:")) {
+              const data = JSON.parse(line.slice(2));
+              if (Array.isArray(data) && data.length > 0) {
+                const item = data[0];
+                if (typeof item === "string") {
+                  finalResult.status = item;
+                } else if (typeof item === "object") {
+                  if (onPartial) {
+                    onPartial(item);
+                  }
+                  finalResult.object = item;
                 }
-                if (part.textDelta) {
-                  finalResult.text += part.textDelta;
-                  if (onChunk) onChunk(part.textDelta);
+              }
+            } else if (line.startsWith("d:")) {
+              const metadata = JSON.parse(line.slice(2));
+              if (metadata.usage) {
+                finalResult.usage = metadata.usage;
+              }
+              if (metadata.finishReason) {
+                finalResult.finishReason = metadata.finishReason;
+              }
+            } else if (line.startsWith("e:")) {
+              const errorData = JSON.parse(line.slice(2));
+              finalResult.error = errorData;
+            }
+          } catch (error) {
+            console.warn("Failed to parse stream line:", line, error);
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          if (buffer.startsWith("0:")) {
+            const textChunk = JSON.parse(buffer.slice(2));
+            if (onChunk) {
+              onChunk(textChunk);
+            }
+            finalResult.text = (finalResult.text || "") + textChunk;
+          } else if (buffer.startsWith("2:")) {
+            const data = JSON.parse(buffer.slice(2));
+            if (Array.isArray(data) && data.length > 0) {
+              const item = data[0];
+              if (typeof item === "object") {
+                if (onPartial) {
+                  onPartial(item);
                 }
-                break;
-              case "text-end":
-                break;
-              case "tool-call":
-                finalResult.toolCalls.push({
-                  toolCallId: part.toolCallId,
-                  toolName: part.toolName,
-                  args: part.args
-                });
-                break;
-              case "tool-result":
-                finalResult.toolResults.push({
-                  toolCallId: part.toolCallId,
-                  toolName: part.toolName,
-                  result: part.result
-                });
-                break;
-              case "source-url":
-                finalResult.sources.push({
-                  id: part.id,
-                  url: part.url,
-                  title: part.title
-                });
-                break;
-              case "file":
-                finalResult.files.push(part.file);
-                break;
-              case "reasoning":
-                finalResult.reasoning.push(part.content);
-                break;
-              case "finish":
-                finalResult.finishReason = part.finishReason;
-                finalResult.usage = part.usage;
-                if (part.response) finalResult.response = part.response;
-                break;
-              case "error":
-                finalResult.error = part.error;
-                throw new Error(part.error);
-              case "data":
-                if (!finalResult.customData) finalResult.customData = [];
-                finalResult.customData.push(part.value);
-                break;
+                finalResult.object = item;
+              }
+            }
+          } else if (buffer.startsWith("d:")) {
+            const metadata = JSON.parse(buffer.slice(2));
+            if (metadata.usage) {
+              finalResult.usage = metadata.usage;
+            }
+            if (metadata.finishReason) {
+              finalResult.finishReason = metadata.finishReason;
             }
-          } catch (e) {
           }
+        } catch (error) {
+          console.warn("Failed to parse final buffer:", buffer, error);
         }
       }
       return finalResult;
@@ -1047,6 +1018,142 @@ var HttpClient = class {
   }
 };
 
+// src/utils/browser-env.ts
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function hasWindowLocation() {
+  return typeof window !== "undefined" && typeof window.location !== "undefined";
+}
+function hasDocument() {
+  return typeof document !== "undefined";
+}
+function isReactNative2() {
+  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
+}
+function getWindowLocation() {
+  if (!hasWindow()) return null;
+  try {
+    return window.location;
+  } catch {
+    return null;
+  }
+}
+function getLocationHref() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.href;
+  } catch {
+    return null;
+  }
+}
+function getLocationOrigin() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.origin;
+  } catch {
+    return null;
+  }
+}
+function getLocationHostname() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.hostname;
+  } catch {
+    return null;
+  }
+}
+function getLocationPathname() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.pathname;
+  } catch {
+    return null;
+  }
+}
+function getLocationSearch() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.search;
+  } catch {
+    return null;
+  }
+}
+function getLocationHash() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.hash;
+  } catch {
+    return null;
+  }
+}
+function getLocationProtocol() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.protocol;
+  } catch {
+    return null;
+  }
+}
+function getLocationHost() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.host;
+  } catch {
+    return null;
+  }
+}
+function constructFullUrl() {
+  if (!hasWindow()) return null;
+  const protocol = getLocationProtocol();
+  const host = getLocationHost();
+  const pathname = getLocationPathname();
+  const search = getLocationSearch();
+  const hash = getLocationHash();
+  if (!protocol || !host) return null;
+  return `${protocol}//${host}${pathname || ""}${search || ""}${hash || ""}`;
+}
+function getDocumentReferrer() {
+  if (!hasDocument()) return null;
+  try {
+    return document.referrer || null;
+  } catch {
+    return null;
+  }
+}
+function getWindowInnerWidth() {
+  if (!hasWindow()) return null;
+  try {
+    return window.innerWidth;
+  } catch {
+    return null;
+  }
+}
+function isIframe() {
+  if (!hasWindow()) return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+function getSessionStorage() {
+  if (!hasWindow()) return null;
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
 // src/auth.ts
 var BlinkAuth = class {
   config;
@@ -1070,11 +1177,14 @@ var BlinkAuth = class {
       // Default mode
       authUrl: "https://blink.new",
       coreUrl: "https://core.blink.new",
+      detectSessionInUrl: true,
+      // Default to true for web compatibility
       ...config.auth
     };
     this.authUrl = this.authConfig.authUrl || "https://blink.new";
     this.coreUrl = this.authConfig.coreUrl || "https://core.blink.new";
-    if (typeof window !== "undefined" && this.authUrl === "https://blink.new" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1")) {
+    const hostname = getLocationHostname();
+    if (hostname && this.authUrl === "https://blink.new" && (hostname === "localhost" || hostname === "127.0.0.1")) {
       console.warn("\u26A0\uFE0F Using default authUrl in development. Set auth.authUrl to your app origin for headless auth endpoints to work.");
     }
     if (config.authRequired !== void 0 && !config.auth?.mode) {
@@ -1088,7 +1198,7 @@ var BlinkAuth = class {
     };
     this.storage = config.auth?.storage || config.storage || getDefaultStorageAdapter();
     if (isWeb) {
-      this.isIframe = window.self !== window.top;
+      this.isIframe = isIframe();
       this.setupParentWindowListener();
       this.setupCrossTabSync();
       this.initializationPromise = this.initialize();
@@ -1124,7 +1234,7 @@ var BlinkAuth = class {
    * Setup listener for tokens from parent window
    */
   setupParentWindowListener() {
-    if (!isWeb || !this.isIframe) return;
+    if (!isWeb || !this.isIframe || !hasWindow()) return;
     window.addEventListener("message", (event) => {
       if (event.origin !== "https://blink.new" && event.origin !== "http://localhost:3000" && event.origin !== "http://localhost:3001") {
         return;
@@ -1146,7 +1256,7 @@ var BlinkAuth = class {
         this.clearTokens();
       }
     });
-    if (window.parent !== window) {
+    if (hasWindow() && window.parent !== window) {
       console.log("\u{1F504} Requesting auth tokens from parent window");
       window.parent.postMessage({
         type: "BLINK_REQUEST_AUTH_TOKENS",
@@ -1171,13 +1281,15 @@ var BlinkAuth = class {
           return;
         }
       }
-      const tokensFromUrl = this.extractTokensFromUrl();
-      if (tokensFromUrl) {
-        console.log("\u{1F4E5} Found tokens in URL, setting them...");
-        await this.setTokens(tokensFromUrl, true);
-        this.clearUrlTokens();
-        console.log("\u2705 Auth initialization complete (from URL)");
-        return;
+      if (this.authConfig.detectSessionInUrl !== false) {
+        const tokensFromUrl = this.extractTokensFromUrl();
+        if (tokensFromUrl) {
+          console.log("\u{1F4E5} Found tokens in URL, setting them...");
+          await this.setTokens(tokensFromUrl, true);
+          this.clearUrlTokens();
+          console.log("\u2705 Auth initialization complete (from URL)");
+          return;
+        }
       }
       const storedTokens = await this.getStoredTokens();
       if (storedTokens) {
@@ -1201,11 +1313,11 @@ var BlinkAuth = class {
         }
       }
       console.log("\u274C No tokens found");
-      if (this.config.authRequired) {
+      if (this.config.authRequired && hasWindowLocation()) {
         console.log("\u{1F504} Auth required, redirecting to auth page...");
         this.redirectToAuth();
       } else {
-        console.log("\u26A0\uFE0F Auth not required, continuing without authentication");
+        console.log("\u26A0\uFE0F Auth not required or no window.location, continuing without authentication");
       }
     } finally {
       this.setLoading(false);
@@ -1216,15 +1328,20 @@ var BlinkAuth = class {
    * Redirect to Blink auth page
    */
   login(nextUrl) {
+    if (!hasWindowLocation()) {
+      console.warn("login() called in non-browser environment (no window.location available)");
+      return;
+    }
     let redirectUrl = nextUrl || this.authConfig.redirectUrl;
-    if (!redirectUrl && typeof window !== "undefined") {
-      if (window.location.href.startsWith("http")) {
-        redirectUrl = window.location.href;
+    if (!redirectUrl) {
+      const href = getLocationHref();
+      if (href && href.startsWith("http")) {
+        redirectUrl = href;
       } else {
-        redirectUrl = `${window.location.protocol}//${window.location.host}${window.location.pathname}${window.location.search}${window.location.hash}`;
+        redirectUrl = constructFullUrl() || void 0;
       }
     }
-    if (redirectUrl && typeof window !== "undefined") {
+    if (redirectUrl) {
       try {
         const url = new URL(redirectUrl);
         url.searchParams.delete("redirect_url");
@@ -1239,16 +1356,14 @@ var BlinkAuth = class {
     if (this.config.projectId) {
       authUrl.searchParams.set("project_id", this.config.projectId);
     }
-    if (typeof window !== "undefined") {
-      window.location.href = authUrl.toString();
-    }
+    window.location.href = authUrl.toString();
   }
   /**
    * Logout and clear stored tokens
    */
   logout(redirectUrl) {
     this.clearTokens();
-    if (redirectUrl && typeof window !== "undefined") {
+    if (redirectUrl && hasWindowLocation()) {
       window.location.href = redirectUrl;
     }
   }
@@ -1497,6 +1612,16 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with Google (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * 
+   * On React Native, requires `webBrowser` to be configured in client:
+   * ```typescript
+   * const blink = createClient({
+   *   auth: { mode: 'headless', webBrowser: WebBrowser }
+   * })
+   * await blink.auth.signInWithGoogle() // Works on both platforms!
+   * ```
    */
   async signInWithGoogle(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1506,6 +1631,9 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with GitHub (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * See signInWithGoogle() for setup instructions.
    */
   async signInWithGitHub(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1515,6 +1643,9 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with Apple (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * See signInWithGoogle() for setup instructions.
    */
   async signInWithApple(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1524,6 +1655,9 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with Microsoft (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * See signInWithGoogle() for setup instructions.
    */
   async signInWithMicrosoft(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1531,28 +1665,267 @@ var BlinkAuth = class {
     }
     return this.signInWithProvider("microsoft", options);
   }
+  /**
+   * Initiate OAuth for mobile without deep linking (expo-web-browser pattern)
+   * 
+   * This method:
+   * 1. Generates a unique session ID
+   * 2. Returns OAuth URL with session parameter
+   * 3. App opens URL in expo-web-browser
+   * 4. App polls checkMobileOAuthSession() until complete
+   * 
+   * @param provider - OAuth provider (google, github, apple, etc.)
+   * @param options - Optional metadata
+   * @returns Session ID and OAuth URL
+   * 
+   * @example
+   * // React Native with expo-web-browser
+   * import * as WebBrowser from 'expo-web-browser';
+   * 
+   * const { sessionId, authUrl } = await blink.auth.initiateMobileOAuth('google');
+   * 
+   * // Open browser
+   * await WebBrowser.openAuthSessionAsync(authUrl);
+   * 
+   * // Poll for completion
+   * const user = await blink.auth.pollMobileOAuthSession(sessionId);
+   * console.log('Authenticated:', user.email);
+   */
+  async initiateMobileOAuth(provider, options) {
+    if (this.authConfig.mode !== "headless") {
+      throw new BlinkAuthError(
+        "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+        "initiateMobileOAuth is only available in headless mode"
+      );
+    }
+    const sessionId = this.generateSessionId();
+    const authUrl = new URL("/auth", this.authUrl);
+    authUrl.searchParams.set("provider", provider);
+    authUrl.searchParams.set("project_id", this.config.projectId);
+    authUrl.searchParams.set("mode", "mobile-session");
+    authUrl.searchParams.set("session_id", sessionId);
+    if (options?.metadata) {
+      authUrl.searchParams.set("metadata", JSON.stringify(options.metadata));
+    }
+    return {
+      sessionId,
+      authUrl: authUrl.toString()
+    };
+  }
+  /**
+   * Check mobile OAuth session status (single check)
+   * 
+   * @param sessionId - Session ID from initiateMobileOAuth
+   * @returns Tokens if session is complete, null if still pending
+   */
+  async checkMobileOAuthSession(sessionId) {
+    try {
+      const response = await fetch(`${this.authUrl}/api/auth/mobile-session/${sessionId}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (response.status === 404 || response.status === 202) {
+        return null;
+      }
+      if (!response.ok) {
+        const errorData = await response.json();
+        const errorCode = this.mapErrorCodeFromResponse(errorData.code);
+        throw new BlinkAuthError(
+          errorCode,
+          errorData.error || "Failed to check OAuth session"
+        );
+      }
+      const data = await response.json();
+      return {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        token_type: data.token_type || "Bearer",
+        expires_in: data.expires_in || 3600,
+        refresh_expires_in: data.refresh_expires_in
+      };
+    } catch (error) {
+      if (error instanceof BlinkAuthError) {
+        throw error;
+      }
+      throw new BlinkAuthError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Poll mobile OAuth session until complete (convenience method)
+   * 
+   * @param sessionId - Session ID from initiateMobileOAuth
+   * @param options - Polling options
+   * @returns Authenticated user
+   * 
+   * @example
+   * const { sessionId, authUrl } = await blink.auth.initiateMobileOAuth('google');
+   * await WebBrowser.openAuthSessionAsync(authUrl);
+   * const user = await blink.auth.pollMobileOAuthSession(sessionId, {
+   *   maxAttempts: 60,
+   *   intervalMs: 1000
+   * });
+   */
+  async pollMobileOAuthSession(sessionId, options) {
+    const maxAttempts = options?.maxAttempts || 60;
+    const intervalMs = options?.intervalMs || 1e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const tokens = await this.checkMobileOAuthSession(sessionId);
+      if (tokens) {
+        await this.setTokens(tokens, true);
+        return this.authState.user;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new BlinkAuthError(
+      "AUTH_TIMEOUT" /* AUTH_TIMEOUT */,
+      "Mobile OAuth session timed out"
+    );
+  }
+  /**
+   * Sign in with OAuth provider using expo-web-browser (React Native)
+   * 
+   * This is a convenience method that handles the entire flow:
+   * 1. Initiates mobile OAuth session
+   * 2. Returns auth URL to open in WebBrowser
+   * 3. Provides polling function to call after browser opens
+   * 
+   * @param provider - OAuth provider
+   * @returns Object with authUrl and authenticate function
+   * 
+   * @example
+   * import * as WebBrowser from 'expo-web-browser';
+   * 
+   * const { authUrl, authenticate } = await blink.auth.signInWithProviderMobile('google');
+   * 
+   * // Open browser
+   * await WebBrowser.openAuthSessionAsync(authUrl);
+   * 
+   * // Wait for authentication
+   * const user = await authenticate();
+   */
+  async signInWithProviderMobile(provider, options) {
+    const { sessionId, authUrl } = await this.initiateMobileOAuth(provider, options);
+    return {
+      authUrl,
+      authenticate: () => this.pollMobileOAuthSession(sessionId, {
+        maxAttempts: 60,
+        intervalMs: 1e3
+      })
+    };
+  }
+  /**
+   * Universal OAuth flow using session-based authentication (internal)
+   * Works on ALL platforms: Web, iOS, Android
+   * Uses expo-web-browser to open auth URL and polls for completion
+   */
+  async signInWithProviderUniversal(provider, options) {
+    const webBrowser = this.authConfig.webBrowser;
+    if (!webBrowser) {
+      throw new BlinkAuthError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "webBrowser module is required for universal OAuth flow"
+      );
+    }
+    const { sessionId, authUrl } = await this.initiateMobileOAuth(provider, options);
+    console.log("\u{1F510} Opening OAuth browser for", provider);
+    const result = await webBrowser.openAuthSessionAsync(authUrl);
+    console.log("\u{1F510} Browser closed with result:", result.type);
+    try {
+      const user = await this.pollMobileOAuthSession(sessionId, {
+        maxAttempts: 60,
+        // 30 seconds (500ms intervals)
+        intervalMs: 500
+      });
+      console.log("\u2705 OAuth completed successfully");
+      return user;
+    } catch (pollError) {
+      if (result.type === "cancel" || result.type === "dismiss") {
+        throw new BlinkAuthError(
+          "POPUP_CANCELED" /* POPUP_CANCELED */,
+          "Authentication was canceled"
+        );
+      }
+      throw pollError;
+    }
+  }
   /**
    * Generic provider sign-in method (headless mode)
+   * 
+   * **Universal OAuth** - Works seamlessly on both Web and React Native!
+   * 
+   * When `webBrowser` is configured in the client, this method automatically
+   * uses the session-based OAuth flow that works on ALL platforms.
+   * 
+   * **Universal Setup (configure once, works everywhere):**
+   * ```typescript
+   * import * as WebBrowser from 'expo-web-browser'
+   * import AsyncStorage from '@react-native-async-storage/async-storage'
+   * 
+   * const blink = createClient({
+   *   projectId: 'your-project',
+   *   auth: {
+   *     mode: 'headless',
+   *     webBrowser: WebBrowser  // Pass the module here
+   *   },
+   *   storage: new AsyncStorageAdapter(AsyncStorage)
+   * })
+   * 
+   * // Now this works on ALL platforms - no platform checks needed!
+   * const user = await blink.auth.signInWithGoogle()
+   * ```
+   * 
+   * @param provider - OAuth provider (google, github, apple, etc.)
+   * @param options - Optional redirect URL and metadata
+   * @returns Promise that resolves with authenticated user
    */
   async signInWithProvider(provider, options) {
     if (this.authConfig.mode !== "headless") {
       throw new BlinkAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "signInWithProvider is only available in headless mode");
     }
+    if (this.authConfig.webBrowser) {
+      return this.signInWithProviderUniversal(provider, options);
+    }
+    if (isReactNative2()) {
+      throw new BlinkAuthError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        'React Native OAuth requires webBrowser in config!\n\nimport * as WebBrowser from "expo-web-browser";\n\nconst blink = createClient({\n  projectId: "your-project",\n  auth: {\n    mode: "headless",\n    webBrowser: WebBrowser\n  }\n})\n\nawait blink.auth.signInWithGoogle() // Works on all platforms!'
+      );
+    }
+    if (!hasWindow()) {
+      throw new BlinkAuthError("NETWORK_ERROR" /* NETWORK_ERROR */, "signInWithProvider requires a browser environment");
+    }
+    const shouldPreferRedirect = isWeb && this.isIframe || typeof window !== "undefined" && window.crossOriginIsolated === true;
+    const state = this.generateState();
+    try {
+      const sessionStorage = getSessionStorage();
+      if (sessionStorage) {
+        sessionStorage.setItem("blink_oauth_state", state);
+      }
+    } catch {
+    }
+    const redirectUrl = options?.redirectUrl || getLocationOrigin() || "";
+    const buildAuthUrl = (mode) => {
+      const url = new URL("/auth", this.authUrl);
+      url.searchParams.set("provider", provider);
+      url.searchParams.set("project_id", this.config.projectId);
+      url.searchParams.set("state", state);
+      url.searchParams.set("mode", mode);
+      url.searchParams.set("redirect_url", redirectUrl);
+      url.searchParams.set("opener_origin", getLocationOrigin() || "");
+      return url;
+    };
+    if (shouldPreferRedirect) {
+      window.location.href = buildAuthUrl("redirect").toString();
+      return new Promise(() => {
+      });
+    }
     return new Promise((resolve, reject) => {
-      const state = this.generateState();
-      try {
-        if (typeof window !== "undefined") {
-          sessionStorage.setItem("blink_oauth_state", state);
-        }
-      } catch {
-      }
-      const redirectUrl = options?.redirectUrl || window.location.origin;
-      const popupUrl = new URL("/auth", this.authUrl);
-      popupUrl.searchParams.set("provider", provider);
-      popupUrl.searchParams.set("project_id", this.config.projectId);
-      popupUrl.searchParams.set("state", state);
-      popupUrl.searchParams.set("mode", "popup");
-      popupUrl.searchParams.set("redirect_url", redirectUrl);
+      const popupUrl = buildAuthUrl("popup");
       const popup = window.open(
         popupUrl.toString(),
         "blink-auth",
@@ -1563,6 +1936,15 @@ var BlinkAuth = class {
         return;
       }
       let timeoutId;
+      let closedIntervalId;
+      let cleanedUp = false;
+      const cleanup = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        clearTimeout(timeoutId);
+        if (closedIntervalId) clearInterval(closedIntervalId);
+        window.removeEventListener("message", messageListener);
+      };
       const messageListener = (event) => {
         let allowed = false;
         try {
@@ -1575,7 +1957,8 @@ var BlinkAuth = class {
         if (event.data?.type === "BLINK_AUTH_TOKENS") {
           const { access_token, refresh_token, token_type, expires_in, refresh_expires_in, projectId, state: returnedState } = event.data;
           try {
-            const expected = sessionStorage.getItem("blink_oauth_state");
+            const sessionStorage = getSessionStorage();
+            const expected = sessionStorage?.getItem("blink_oauth_state");
             if (returnedState && expected && returnedState !== expected) {
               reject(new BlinkAuthError("VERIFICATION_FAILED" /* VERIFICATION_FAILED */, "State mismatch"));
               clearTimeout(timeoutId);
@@ -1598,29 +1981,34 @@ var BlinkAuth = class {
           }, true).then(() => {
             resolve(this.authState.user);
           }).catch(reject);
-          clearTimeout(timeoutId);
-          window.removeEventListener("message", messageListener);
+          cleanup();
           popup.close();
         } else if (event.data?.type === "BLINK_AUTH_ERROR") {
           const errorCode = this.mapErrorCodeFromResponse(event.data.code);
           reject(new BlinkAuthError(errorCode, event.data.message || "Authentication failed"));
-          clearTimeout(timeoutId);
-          window.removeEventListener("message", messageListener);
+          cleanup();
           popup.close();
         }
       };
+      if (popup.opener === null) {
+        try {
+          popup.close();
+        } catch {
+        }
+        cleanup();
+        window.location.href = buildAuthUrl("redirect").toString();
+        return;
+      }
       timeoutId = setTimeout(() => {
-        window.removeEventListener("message", messageListener);
+        cleanup();
         if (!popup.closed) {
           popup.close();
         }
         reject(new BlinkAuthError("AUTH_TIMEOUT" /* AUTH_TIMEOUT */, "Authentication timed out"));
       }, 3e5);
-      const checkClosed = setInterval(() => {
+      closedIntervalId = setInterval(() => {
         if (popup.closed) {
-          clearInterval(checkClosed);
-          clearTimeout(timeoutId);
-          window.removeEventListener("message", messageListener);
+          cleanup();
           reject(new BlinkAuthError("POPUP_CANCELED" /* POPUP_CANCELED */, "Authentication was canceled"));
         }
       }, 1e3);
@@ -2099,6 +2487,48 @@ var BlinkAuth = class {
     };
     await this.setTokens(tokens, persist);
   }
+  /**
+   * Manually set auth session from tokens (React Native deep link OAuth)
+   * 
+   * Use this method to set the user session after receiving tokens from a deep link callback.
+   * This is the React Native equivalent of automatic URL token detection on web.
+   * 
+   * @param tokens - Auth tokens received from deep link or OAuth callback
+   * @param persist - Whether to persist tokens to storage (default: true)
+   * 
+   * @example
+   * // React Native: Handle deep link OAuth callback
+   * import * as Linking from 'expo-linking'
+   * 
+   * Linking.addEventListener('url', async ({ url }) => {
+   *   const { queryParams } = Linking.parse(url)
+   *   
+   *   if (queryParams.access_token) {
+   *     await blink.auth.setSession({
+   *       access_token: queryParams.access_token,
+   *       refresh_token: queryParams.refresh_token,
+   *       expires_in: parseInt(queryParams.expires_in) || 3600,
+   *       refresh_expires_in: parseInt(queryParams.refresh_expires_in)
+   *     })
+   *     
+   *     console.log('User authenticated:', blink.auth.currentUser())
+   *   }
+   * })
+   */
+  async setSession(tokens, persist = true) {
+    const authTokens = {
+      access_token: tokens.access_token,
+      refresh_token: tokens.refresh_token,
+      token_type: "Bearer",
+      expires_in: tokens.expires_in || 3600,
+      // Default 1 hour
+      refresh_expires_in: tokens.refresh_expires_in,
+      issued_at: Math.floor(Date.now() / 1e3)
+    };
+    await this.setTokens(authTokens, persist);
+    const user = await this.me();
+    return user;
+  }
   /**
    * Refresh access token using refresh token
    */
@@ -2332,12 +2762,13 @@ var BlinkAuth = class {
     }
   }
   extractTokensFromUrl() {
-    if (typeof window === "undefined") return null;
-    const params = new URLSearchParams(window.location.search);
+    const search = getLocationSearch();
+    if (!search) return null;
+    const params = new URLSearchParams(search);
     const accessToken = params.get("access_token");
     const refreshToken = params.get("refresh_token");
     console.log("\u{1F50D} Extracting tokens from URL:", {
-      url: window.location.href,
+      url: getLocationHref(),
       accessToken: accessToken ? `${accessToken.substring(0, 20)}...` : null,
       refreshToken: refreshToken ? `${refreshToken.substring(0, 20)}...` : null,
       allParams: Object.fromEntries(params.entries())
@@ -2364,8 +2795,9 @@ var BlinkAuth = class {
     return null;
   }
   clearUrlTokens() {
-    if (typeof window === "undefined") return;
-    const url = new URL(window.location.href);
+    const href = getLocationHref();
+    if (!href || !hasWindowLocation()) return;
+    const url = new URL(href);
     url.searchParams.delete("access_token");
     url.searchParams.delete("refresh_token");
     url.searchParams.delete("token_type");
@@ -2380,7 +2812,7 @@ var BlinkAuth = class {
     console.log("\u{1F9F9} URL cleaned up, removed auth parameters");
   }
   redirectToAuth() {
-    if (typeof window !== "undefined") {
+    if (hasWindowLocation()) {
       this.login();
     }
   }
@@ -2412,12 +2844,25 @@ var BlinkAuth = class {
       return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
     }
   }
+  /**
+   * Generate unique session ID for mobile OAuth
+   */
+  generateSessionId() {
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      const array = new Uint8Array(32);
+      crypto.getRandomValues(array);
+      return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    } else {
+      return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    }
+  }
   /**
    * Extract magic link token from URL
    */
   extractMagicTokenFromUrl() {
-    if (typeof window === "undefined") return null;
-    const params = new URLSearchParams(window.location.search);
+    const search = getLocationSearch();
+    if (!search) return null;
+    const params = new URLSearchParams(search);
     return params.get("magic_token") || params.get("token");
   }
   /**
@@ -2473,7 +2918,7 @@ var BlinkAuth = class {
    * Setup cross-tab authentication synchronization
    */
   setupCrossTabSync() {
-    if (!isWeb) return;
+    if (!isWeb || !hasWindow()) return;
     window.addEventListener("storage", (e) => {
       if (e.key === this.getStorageKey("tokens")) {
         const newTokens = e.newValue ? JSON.parse(e.newValue) : null;
@@ -3280,7 +3725,13 @@ var BlinkAIImpl = class {
         options.prompt || "",
         requestBody
       );
-      return response.data;
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.text) {
+        return response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing text");
+      }
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3349,14 +3800,9 @@ var BlinkAIImpl = class {
       );
       return {
         text: result.text || "",
-        finishReason: result.finishReason || "stop",
+        finishReason: "stop",
         usage: result.usage,
-        toolCalls: result.toolCalls,
-        toolResults: result.toolResults,
-        sources: result.sources,
-        files: result.files,
-        reasoningDetails: result.reasoning,
-        response: result.response
+        ...result
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -3435,7 +3881,13 @@ var BlinkAIImpl = class {
           signal: options.signal
         }
       );
-      return response.data;
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.object) {
+        return response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing object");
+      }
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3497,7 +3949,8 @@ var BlinkAIImpl = class {
       return {
         object: result.object || {},
         finishReason: "stop",
-        usage: result.usage
+        usage: result.usage,
+        ...result
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -4769,9 +5222,9 @@ var BlinkAnalyticsImpl = class {
       user_id: this.userId,
       user_email: this.userEmail,
       session_id: sessionId,
-      pathname: window.location.pathname,
-      referrer: document.referrer || null,
-      screen_width: window.innerWidth,
+      pathname: getLocationPathname(),
+      referrer: getDocumentReferrer(),
+      screen_width: getWindowInnerWidth(),
       channel,
       utm_source: this.utmParams.utm_source || this.persistedAttribution.utm_source || null,
       utm_medium: this.utmParams.utm_medium || this.persistedAttribution.utm_medium || null,
@@ -4924,7 +5377,7 @@ var BlinkAnalyticsImpl = class {
     window.__blinkAnalyticsInstances?.add(this);
   }
   setupUnloadListener() {
-    if (!isWeb) return;
+    if (!isWeb || !hasWindow()) return;
     window.addEventListener("pagehide", () => {
       this.flush();
     });
@@ -4934,7 +5387,12 @@ var BlinkAnalyticsImpl = class {
   }
   captureUTMParams() {
     if (!isWeb) return;
-    const urlParams = new URLSearchParams(window.location.search);
+    const search = getLocationSearch();
+    if (!search) {
+      this.utmParams = {};
+      return;
+    }
+    const urlParams = new URLSearchParams(search);
     this.utmParams = {
       utm_source: urlParams.get("utm_source"),
       utm_medium: urlParams.get("utm_medium"),
@@ -4971,7 +5429,7 @@ var BlinkAnalyticsImpl = class {
     }
   }
   detectChannel() {
-    const referrer = document.referrer;
+    const referrer = getDocumentReferrer();
     const utmMedium = this.utmParams.utm_medium;
     this.utmParams.utm_source;
     if (utmMedium) {