@blinkdotnew/sdk 0.19.6 → 2.0.0

package/dist/index.mjs

@@ -674,7 +674,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI text generation with Vercel AI SDK data stream format
+   * Stream AI text generation - uses Vercel AI SDK's pipeUIMessageStreamToResponse (Data Stream Protocol)
    */
   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.parseDataStream(response.body, onChunk);
+      return this.parseDataStreamProtocol(response.body, onChunk);
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -729,7 +729,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI object generation with Vercel AI SDK data stream format
+   * Stream AI object generation - uses Vercel AI SDK's pipeTextStreamToResponse
    */
   async streamAiObject(prompt, options = {}, onPartial) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/object`);
@@ -759,7 +759,35 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      return this.parseDataStream(response.body, void 0, onPartial);
+      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();
+      }
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -922,93 +950,94 @@ var HttpClient = class {
     }
   }
   /**
-   * Parse Vercel AI SDK data stream format
-   * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
+   * Parse Vercel AI SDK v5 Data Stream Protocol (Server-Sent Events)
+   * Supports all event types from the UI Message Stream protocol
    */
-  async parseDataStream(body, onChunk, onPartial) {
+  async parseDataStreamProtocol(body, onChunk) {
     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(/\r?\n/);
+        const lines = buffer.split("\n");
         buffer = lines.pop() || "";
         for (const line of lines) {
           if (!line.trim()) continue;
+          if (line === "[DONE]") {
+            continue;
+          }
+          if (!line.startsWith("data: ")) continue;
           try {
-            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;
+            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);
                 }
-              }
-            } 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);
+                if (part.textDelta) {
+                  finalResult.text += part.textDelta;
+                  if (onChunk) onChunk(part.textDelta);
                 }
-                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;
+                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;
             }
+          } catch (e) {
           }
-        } catch (error) {
-          console.warn("Failed to parse final buffer:", buffer, error);
         }
       }
       return finalResult;
@@ -1018,142 +1047,6 @@ 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;
@@ -1177,14 +1070,11 @@ 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";
-    const hostname = getLocationHostname();
-    if (hostname && this.authUrl === "https://blink.new" && (hostname === "localhost" || hostname === "127.0.0.1")) {
+    if (typeof window !== "undefined" && this.authUrl === "https://blink.new" && (window.location.hostname === "localhost" || window.location.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) {
@@ -1198,7 +1088,7 @@ var BlinkAuth = class {
     };
     this.storage = config.auth?.storage || config.storage || getDefaultStorageAdapter();
     if (isWeb) {
-      this.isIframe = isIframe();
+      this.isIframe = window.self !== window.top;
       this.setupParentWindowListener();
       this.setupCrossTabSync();
       this.initializationPromise = this.initialize();
@@ -1234,12 +1124,9 @@ var BlinkAuth = class {
    * Setup listener for tokens from parent window
    */
   setupParentWindowListener() {
-    if (!isWeb || !this.isIframe || !hasWindow()) return;
+    if (!isWeb || !this.isIframe) return;
     window.addEventListener("message", (event) => {
-      const origin = event.origin;
-      const isTrustedOrigin = origin === "https://blink.new" || origin === "http://localhost:3000" || origin === "http://localhost:3001" || origin.endsWith(".sites.blink.new") || // Trust all preview URLs
-      origin.endsWith(".preview-blink.com");
-      if (!isTrustedOrigin) {
+      if (event.origin !== "https://blink.new" && event.origin !== "http://localhost:3000" && event.origin !== "http://localhost:3001") {
         return;
       }
       if (event.data?.type === "BLINK_AUTH_TOKENS") {
@@ -1259,7 +1146,7 @@ var BlinkAuth = class {
         this.clearTokens();
       }
     });
-    if (hasWindow() && window.parent !== window) {
+    if (window.parent !== window) {
       console.log("\u{1F504} Requesting auth tokens from parent window");
       window.parent.postMessage({
         type: "BLINK_REQUEST_AUTH_TOKENS",
@@ -1284,15 +1171,13 @@ var BlinkAuth = class {
           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 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) {
@@ -1316,11 +1201,11 @@ var BlinkAuth = class {
         }
       }
       console.log("\u274C No tokens found");
-      if (this.config.authRequired && hasWindowLocation()) {
+      if (this.config.authRequired) {
         console.log("\u{1F504} Auth required, redirecting to auth page...");
         this.redirectToAuth();
       } else {
-        console.log("\u26A0\uFE0F Auth not required or no window.location, continuing without authentication");
+        console.log("\u26A0\uFE0F Auth not required, continuing without authentication");
       }
     } finally {
       this.setLoading(false);
@@ -1331,20 +1216,15 @@ 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) {
-      const href = getLocationHref();
-      if (href && href.startsWith("http")) {
-        redirectUrl = href;
+    if (!redirectUrl && typeof window !== "undefined") {
+      if (window.location.href.startsWith("http")) {
+        redirectUrl = window.location.href;
       } else {
-        redirectUrl = constructFullUrl() || void 0;
+        redirectUrl = `${window.location.protocol}//${window.location.host}${window.location.pathname}${window.location.search}${window.location.hash}`;
       }
     }
-    if (redirectUrl) {
+    if (redirectUrl && typeof window !== "undefined") {
       try {
         const url = new URL(redirectUrl);
         url.searchParams.delete("redirect_url");
@@ -1359,14 +1239,16 @@ var BlinkAuth = class {
     if (this.config.projectId) {
       authUrl.searchParams.set("project_id", this.config.projectId);
     }
-    window.location.href = authUrl.toString();
+    if (typeof window !== "undefined") {
+      window.location.href = authUrl.toString();
+    }
   }
   /**
    * Logout and clear stored tokens
    */
   logout(redirectUrl) {
     this.clearTokens();
-    if (redirectUrl && hasWindowLocation()) {
+    if (redirectUrl && typeof window !== "undefined") {
       window.location.href = redirectUrl;
     }
   }
@@ -1649,237 +1531,22 @@ 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
-      })
-    };
-  }
-  /**
-   * Sign in with Google using expo-web-browser (React Native convenience)
-   */
-  async signInWithGoogleMobile(options) {
-    return this.signInWithProviderMobile("google", options);
-  }
-  /**
-   * Sign in with GitHub using expo-web-browser (React Native convenience)
-   */
-  async signInWithGitHubMobile(options) {
-    return this.signInWithProviderMobile("github", options);
-  }
-  /**
-   * Sign in with Apple using expo-web-browser (React Native convenience)
-   */
-  async signInWithAppleMobile(options) {
-    return this.signInWithProviderMobile("apple", options);
-  }
-  /**
-   * React Native OAuth flow using expo-web-browser (internal)
-   * Automatically handles opening browser and extracting tokens from redirect
-   */
-  async signInWithProviderReactNative(provider, options) {
-    throw new BlinkAuthError(
-      "NETWORK_ERROR" /* NETWORK_ERROR */,
-      'React Native OAuth detected!\n\nPlease use the mobile-specific methods:\n\nimport * as WebBrowser from "expo-web-browser";\n\nconst { authUrl, authenticate } = await blink.auth.signInWithGoogleMobile();\nawait WebBrowser.openAuthSessionAsync(authUrl);\nconst user = await authenticate();\n\nOr update your useAuth hook to handle this automatically.'
-    );
-  }
   /**
    * Generic provider sign-in method (headless mode)
-   * 
-   * Supports both web (popup) and React Native (deep link) OAuth flows.
-   * 
-   * **React Native Setup:**
-   * 1. Configure deep linking in your app (app.json):
-   *    ```json
-   *    { "expo": { "scheme": "com.yourapp" } }
-   *    ```
-   * 
-   * 2. Add redirect URL in Blink Dashboard:
-   *    `com.yourapp://**`
-   * 
-   * 3. Handle deep link callbacks:
-   *    ```typescript
-   *    import * as Linking from 'expo-linking'
-   *    
-   *    Linking.addEventListener('url', async ({ url }) => {
-   *      const { queryParams } = Linking.parse(url)
-   *      if (queryParams.access_token) {
-   *        await blink.auth.setSession(queryParams)
-   *      }
-   *    })
-   *    ```
-   * 
-   * @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 (!hasWindow()) {
-      throw new BlinkAuthError("NETWORK_ERROR" /* NETWORK_ERROR */, "signInWithProvider requires a browser environment");
-    }
-    if (isReactNative2()) {
-      return this.signInWithProviderReactNative(provider, options);
-    }
     return new Promise((resolve, reject) => {
       const state = this.generateState();
       try {
-        const sessionStorage = getSessionStorage();
-        if (sessionStorage) {
+        if (typeof window !== "undefined") {
           sessionStorage.setItem("blink_oauth_state", state);
         }
       } catch {
       }
-      const redirectUrl = options?.redirectUrl || getLocationOrigin() || "";
+      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);
@@ -1904,13 +1571,11 @@ var BlinkAuth = class {
         } catch {
         }
         if (event.origin === "http://localhost:3000" || event.origin === "http://localhost:3001") allowed = true;
-        if (event.origin.endsWith(".sites.blink.new") || event.origin.endsWith(".preview-blink.com")) allowed = true;
         if (!allowed) return;
         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 sessionStorage = getSessionStorage();
-            const expected = sessionStorage?.getItem("blink_oauth_state");
+            const expected = sessionStorage.getItem("blink_oauth_state");
             if (returnedState && expected && returnedState !== expected) {
               reject(new BlinkAuthError("VERIFICATION_FAILED" /* VERIFICATION_FAILED */, "State mismatch"));
               clearTimeout(timeoutId);
@@ -2434,48 +2099,6 @@ 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
    */
@@ -2709,13 +2332,12 @@ var BlinkAuth = class {
     }
   }
   extractTokensFromUrl() {
-    const search = getLocationSearch();
-    if (!search) return null;
-    const params = new URLSearchParams(search);
+    if (typeof window === "undefined") return null;
+    const params = new URLSearchParams(window.location.search);
     const accessToken = params.get("access_token");
     const refreshToken = params.get("refresh_token");
     console.log("\u{1F50D} Extracting tokens from URL:", {
-      url: getLocationHref(),
+      url: window.location.href,
       accessToken: accessToken ? `${accessToken.substring(0, 20)}...` : null,
       refreshToken: refreshToken ? `${refreshToken.substring(0, 20)}...` : null,
       allParams: Object.fromEntries(params.entries())
@@ -2742,9 +2364,8 @@ var BlinkAuth = class {
     return null;
   }
   clearUrlTokens() {
-    const href = getLocationHref();
-    if (!href || !hasWindowLocation()) return;
-    const url = new URL(href);
+    if (typeof window === "undefined") return;
+    const url = new URL(window.location.href);
     url.searchParams.delete("access_token");
     url.searchParams.delete("refresh_token");
     url.searchParams.delete("token_type");
@@ -2759,7 +2380,7 @@ var BlinkAuth = class {
     console.log("\u{1F9F9} URL cleaned up, removed auth parameters");
   }
   redirectToAuth() {
-    if (hasWindowLocation()) {
+    if (typeof window !== "undefined") {
       this.login();
     }
   }
@@ -2791,25 +2412,12 @@ 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() {
-    const search = getLocationSearch();
-    if (!search) return null;
-    const params = new URLSearchParams(search);
+    if (typeof window === "undefined") return null;
+    const params = new URLSearchParams(window.location.search);
     return params.get("magic_token") || params.get("token");
   }
   /**
@@ -2865,7 +2473,7 @@ var BlinkAuth = class {
    * Setup cross-tab authentication synchronization
    */
   setupCrossTabSync() {
-    if (!isWeb || !hasWindow()) return;
+    if (!isWeb) return;
     window.addEventListener("storage", (e) => {
       if (e.key === this.getStorageKey("tokens")) {
         const newTokens = e.newValue ? JSON.parse(e.newValue) : null;
@@ -3672,13 +3280,7 @@ var BlinkAIImpl = class {
         options.prompt || "",
         requestBody
       );
-      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");
-      }
+      return response.data;
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3747,9 +3349,14 @@ var BlinkAIImpl = class {
       );
       return {
         text: result.text || "",
-        finishReason: "stop",
+        finishReason: result.finishReason || "stop",
         usage: result.usage,
-        ...result
+        toolCalls: result.toolCalls,
+        toolResults: result.toolResults,
+        sources: result.sources,
+        files: result.files,
+        reasoningDetails: result.reasoning,
+        response: result.response
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -3828,13 +3435,7 @@ var BlinkAIImpl = class {
           signal: options.signal
         }
       );
-      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");
-      }
+      return response.data;
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3896,8 +3497,7 @@ var BlinkAIImpl = class {
       return {
         object: result.object || {},
         finishReason: "stop",
-        usage: result.usage,
-        ...result
+        usage: result.usage
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -5169,9 +4769,9 @@ var BlinkAnalyticsImpl = class {
       user_id: this.userId,
       user_email: this.userEmail,
       session_id: sessionId,
-      pathname: getLocationPathname(),
-      referrer: getDocumentReferrer(),
-      screen_width: getWindowInnerWidth(),
+      pathname: window.location.pathname,
+      referrer: document.referrer || null,
+      screen_width: window.innerWidth,
       channel,
       utm_source: this.utmParams.utm_source || this.persistedAttribution.utm_source || null,
       utm_medium: this.utmParams.utm_medium || this.persistedAttribution.utm_medium || null,
@@ -5324,7 +4924,7 @@ var BlinkAnalyticsImpl = class {
     window.__blinkAnalyticsInstances?.add(this);
   }
   setupUnloadListener() {
-    if (!isWeb || !hasWindow()) return;
+    if (!isWeb) return;
     window.addEventListener("pagehide", () => {
       this.flush();
     });
@@ -5334,12 +4934,7 @@ var BlinkAnalyticsImpl = class {
   }
   captureUTMParams() {
     if (!isWeb) return;
-    const search = getLocationSearch();
-    if (!search) {
-      this.utmParams = {};
-      return;
-    }
-    const urlParams = new URLSearchParams(search);
+    const urlParams = new URLSearchParams(window.location.search);
     this.utmParams = {
       utm_source: urlParams.get("utm_source"),
       utm_medium: urlParams.get("utm_medium"),
@@ -5376,7 +4971,7 @@ var BlinkAnalyticsImpl = class {
     }
   }
   detectChannel() {
-    const referrer = getDocumentReferrer();
+    const referrer = document.referrer;
     const utmMedium = this.utmParams.utm_medium;
     this.utmParams.utm_source;
     if (utmMedium) {