@blinkdotnew/dev-sdk 2.1.2 → 2.1.4

package/dist/index.mjs

@@ -5,6 +5,33 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// ../core/src/platform.ts
+function detectPlatform() {
+  if (typeof Deno !== "undefined") {
+    return "deno";
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+      return "react-native";
+    }
+    return "node";
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return "react-native";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "web";
+  }
+  return "node";
+}
+var platform = detectPlatform();
+var isWeb = platform === "web";
+var isReactNative = platform === "react-native";
+var isNode = platform === "node";
+var isDeno = platform === "deno";
+var isBrowser = isWeb || isReactNative;
+var isServer = isNode || isDeno;
+
 // ../core/src/storage-adapter.ts
 var WebStorageAdapter = class {
   getItem(key) {
@@ -90,6 +117,9 @@ var NoOpStorageAdapter = class {
   }
 };
 function getDefaultStorageAdapter() {
+  if (isDeno) {
+    return new NoOpStorageAdapter();
+  }
   if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
     try {
       localStorage.setItem("__test__", "test");
@@ -101,28 +131,6 @@ function getDefaultStorageAdapter() {
   return new NoOpStorageAdapter();
 }
 
-// ../core/src/platform.ts
-function detectPlatform() {
-  if (typeof process !== "undefined" && process.versions?.node) {
-    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-      return "react-native";
-    }
-    return "node";
-  }
-  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-    return "react-native";
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "web";
-  }
-  return "node";
-}
-var platform = detectPlatform();
-var isWeb = platform === "web";
-var isReactNative = platform === "react-native";
-var isNode = platform === "node";
-var isBrowser = isWeb || isReactNative;
-
 // ../core/src/types.ts
 var BlinkError = class extends Error {
   constructor(message, code, status, details) {
@@ -386,17 +394,44 @@ function convertKeysToCamelCase(obj) {
   return converted;
 }
 var HttpClient = class {
-  authUrl;
-  coreUrl;
+  authUrl = "https://blink.new";
+  coreUrl = "https://core.blink.new";
   projectId;
+  publishableKey;
+  secretKey;
+  // Permanent, non-expiring key (like Stripe's sk_live_...)
   getToken;
   getValidToken;
   constructor(config, getToken, getValidToken) {
     this.projectId = config.projectId;
+    this.publishableKey = config.publishableKey;
+    this.secretKey = config.secretKey || config.serviceToken;
     this.getToken = getToken;
     this.getValidToken = getValidToken;
-    this.authUrl = config.auth?.authUrl ?? "https://blink.new";
-    this.coreUrl = config.auth?.coreUrl ?? "https://dev.core.blink.new";
+  }
+  shouldAttachPublishableKey(path, method) {
+    if (method !== "GET" && method !== "POST") return false;
+    if (path.includes("/api/analytics/")) return true;
+    if (path.includes("/api/storage/")) return true;
+    if (path.includes("/api/db/") && path.includes("/rest/v1/")) return method === "GET";
+    return false;
+  }
+  shouldSkipSecretKey(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname.endsWith(".functions.blink.new");
+    } catch {
+      return false;
+    }
+  }
+  getAuthorizationHeader(url, token) {
+    if (this.secretKey && !this.shouldSkipSecretKey(url)) {
+      return `Bearer ${this.secretKey}`;
+    }
+    if (token) {
+      return `Bearer ${token}`;
+    }
+    return null;
   }
   /**
    * Make an authenticated request to the Blink API
@@ -404,19 +439,23 @@ var HttpClient = class {
   async request(path, options = {}) {
     const url = this.buildUrl(path, options.searchParams);
     const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const method = options.method || "GET";
     const headers = {
       "Content-Type": "application/json",
       ...options.headers
     };
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) {
+      headers.Authorization = auth;
+    } else if (this.publishableKey && !headers["x-blink-publishable-key"] && this.shouldAttachPublishableKey(path, method)) {
+      headers["x-blink-publishable-key"] = this.publishableKey;
     }
     const requestInit = {
-      method: options.method || "GET",
+      method,
       headers,
       signal: options.signal
     };
-    if (options.body && options.method !== "GET") {
+    if (options.body && method !== "GET") {
       requestInit.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
     }
     try {
@@ -570,12 +609,12 @@ var HttpClient = class {
       throw new BlinkValidationError("Unsupported file type");
     }
     formData.append("path", filePath);
-    if (options.upsert !== void 0) {
-      formData.append("options", JSON.stringify({ upsert: options.upsert }));
-    }
     const headers = {};
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) {
+      headers.Authorization = auth;
+    } else if (this.publishableKey && path.includes("/api/storage/") && !headers["x-blink-publishable-key"]) {
+      headers["x-blink-publishable-key"] = this.publishableKey;
     }
     try {
       if (typeof XMLHttpRequest !== "undefined" && options.onProgress) {
@@ -676,7 +715,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`);
@@ -684,9 +723,8 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
-    }
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) headers.Authorization = auth;
     const body = {
       prompt,
       stream: true,
@@ -706,7 +744,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;
@@ -731,7 +769,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`);
@@ -739,9 +777,8 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
-    }
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) headers.Authorization = auth;
     const body = {
       prompt,
       stream: true,
@@ -761,7 +798,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;
@@ -818,6 +883,17 @@ var HttpClient = class {
       signal
     });
   }
+  async aiVideo(prompt, options = {}) {
+    const { signal, ...body } = options;
+    return this.request(`/api/ai/${this.projectId}/video`, {
+      method: "POST",
+      body: {
+        prompt,
+        ...body
+      },
+      signal
+    });
+  }
   /**
    * Data-specific requests
    */
@@ -859,6 +935,38 @@ var HttpClient = class {
   async dataSearch(projectId, request) {
     return this.post(`/api/data/${projectId}/search`, request);
   }
+  /**
+   * Connector requests
+   */
+  formatProviderForPath(provider) {
+    return provider.replace("_", "-");
+  }
+  async connectorStatus(provider) {
+    return this.request(`/api/connectors/${this.formatProviderForPath(provider)}/${this.projectId}/status`, {
+      method: "GET"
+    });
+  }
+  async connectorExecute(provider, request) {
+    const path = request.method.startsWith("/") ? request.method : `/${request.method}`;
+    const url = `/api/connectors/${this.formatProviderForPath(provider)}/${this.projectId}${path}`;
+    const method = (request.http_method || "GET").toUpperCase();
+    if (method === "GET") {
+      return this.request(url, {
+        method: "GET",
+        searchParams: request.params
+      });
+    }
+    return this.request(url, {
+      method,
+      body: request.params || {}
+    });
+  }
+  async connectorSaveApiKey(provider, request) {
+    return this.request(`/api/connectors/${this.formatProviderForPath(provider)}/${this.projectId}/api-key`, {
+      method: "POST",
+      body: request
+    });
+  }
   /**
    * Realtime-specific requests
    */
@@ -924,93 +1032,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;
@@ -1178,13 +1287,13 @@ var BlinkAuth = class {
       mode: "managed",
       // Default mode
       authUrl: "https://blink.new",
-      coreUrl: "https://dev.core.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://dev.core.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")) {
       console.warn("\u26A0\uFE0F Using default authUrl in development. Set auth.authUrl to your app origin for headless auth endpoints to work.");
@@ -1855,6 +1964,67 @@ var BlinkAuth = class {
       throw pollError;
     }
   }
+  /**
+   * OAuth flow via parent window (for iframe context)
+   * Delegates OAuth to parent window since OAuth providers block flows inside iframes
+   */
+  signInWithProviderViaParent(provider, options) {
+    return new Promise((resolve, reject) => {
+      const state = this.generateState();
+      const redirectUrl = options?.redirectUrl || getLocationOrigin() || "";
+      let timeoutId;
+      let cleanedUp = false;
+      const cleanup = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        clearTimeout(timeoutId);
+        window.removeEventListener("message", messageListener);
+      };
+      const messageListener = (event) => {
+        const { type, access_token, refresh_token, expires_in, refresh_expires_in, issued_at, projectId, error } = event.data || {};
+        if (type === "BLINK_AUTH_TOKENS") {
+          if (projectId && projectId !== this.config.projectId) {
+            return;
+          }
+          console.log("\u{1F4E5} Received auth tokens from parent window");
+          this.setTokens({
+            access_token,
+            refresh_token,
+            token_type: "Bearer",
+            expires_in: expires_in || 3600,
+            refresh_expires_in,
+            issued_at: issued_at || Math.floor(Date.now() / 1e3)
+          }, true).then(() => {
+            cleanup();
+            resolve(this.authState.user);
+          }).catch((err) => {
+            cleanup();
+            reject(err);
+          });
+        } else if (type === "BLINK_AUTH_ERROR") {
+          cleanup();
+          reject(new BlinkAuthError(
+            "POPUP_CANCELED" /* POPUP_CANCELED */,
+            error || "Authentication failed"
+          ));
+        }
+      };
+      window.addEventListener("message", messageListener);
+      timeoutId = setTimeout(() => {
+        cleanup();
+        reject(new BlinkAuthError("AUTH_TIMEOUT" /* AUTH_TIMEOUT */, "Authentication timed out"));
+      }, 3e5);
+      console.log("\u{1F4E4} Sending OAuth request to parent window");
+      window.parent.postMessage({
+        type: "BLINK_AUTH_OAUTH_REQUEST",
+        provider,
+        projectId: this.config.projectId,
+        redirectUrl,
+        state,
+        authUrl: this.authUrl
+      }, "*");
+    });
+  }
   /**
    * Generic provider sign-in method (headless mode)
    * 
@@ -1901,7 +2071,10 @@ var BlinkAuth = class {
     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;
+    if (isWeb && this.isIframe && hasWindow() && window.parent !== window) {
+      console.log("\u{1F5BC}\uFE0F In iframe, delegating OAuth to parent window");
+      return this.signInWithProviderViaParent(provider, options);
+    }
     const state = this.generateState();
     try {
       const sessionStorage = getSessionStorage();
@@ -1921,6 +2094,7 @@ var BlinkAuth = class {
       url.searchParams.set("opener_origin", getLocationOrigin() || "");
       return url;
     };
+    const shouldPreferRedirect = typeof window !== "undefined" && window.crossOriginIsolated === true;
     if (shouldPreferRedirect) {
       window.location.href = buildAuthUrl("redirect").toString();
       return new Promise(() => {
@@ -2937,6 +3111,11 @@ var BlinkAuth = class {
 };
 
 // src/database.ts
+function assertServerOnly(methodName) {
+  if (typeof window !== "undefined") {
+    throw new Error(`${methodName} is server-only. Use Blink CRUD methods (blink.db.<table>.*) instead.`);
+  }
+}
 function camelToSnake3(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
@@ -3155,6 +3334,7 @@ var BlinkTable = class {
    * Raw SQL query on this table (for advanced use cases)
    */
   async sql(query, params) {
+    assertServerOnly("blink.db.<table>.sql");
     const response = await this.httpClient.dbSql(query, params);
     return response.data;
   }
@@ -3203,6 +3383,7 @@ var BlinkDatabase = class {
    * Execute raw SQL query
    */
   async sql(query, params) {
+    assertServerOnly("blink.db.sql");
     const response = await this.httpClient.dbSql(query, params);
     return response.data;
   }
@@ -3210,6 +3391,7 @@ var BlinkDatabase = class {
    * Execute batch SQL operations
    */
   async batch(statements, mode = "write") {
+    assertServerOnly("blink.db.batch");
     const response = await this.httpClient.dbBatch(statements, mode);
     return response.data;
   }
@@ -3272,7 +3454,6 @@ var BlinkStorageImpl = class {
         correctedPath,
         // Use corrected path with proper extension
         {
-          upsert: options.upsert,
           onProgress: options.onProgress,
           contentType: detectedContentType
           // Pass detected content type
@@ -3292,7 +3473,7 @@ var BlinkStorageImpl = class {
       if (error instanceof Error && "status" in error) {
         const status = error.status;
         if (status === 409) {
-          throw new BlinkStorageError("File already exists. Set upsert: true to overwrite.", 409);
+          throw new BlinkStorageError("File already exists.", 409);
         }
         if (status === 400) {
           throw new BlinkStorageError("Invalid request parameters", 400);
@@ -3337,7 +3518,6 @@ var BlinkStorageImpl = class {
         detectedContentType
       };
     } catch (error) {
-      console.warn("File type detection failed, using original path:", error);
       return {
         correctedPath: originalPath,
         detectedContentType: "application/octet-stream"
@@ -3727,13 +3907,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;
@@ -3802,9 +3976,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) {
@@ -3883,13 +4062,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;
@@ -3951,8 +4124,7 @@ var BlinkAIImpl = class {
       return {
         object: result.object || {},
         finishReason: "stop",
-        usage: result.usage,
-        ...result
+        usage: result.usage
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -4213,6 +4385,131 @@ var BlinkAIImpl = class {
       );
     }
   }
+  /**
+   * Generates videos from text prompts or images using AI video generation models.
+   * 
+   * @param options - Object containing:
+   *   - `prompt`: Text description of the video to generate (required)
+   *   - `model`: Video model to use (optional). Available models:
+   *       **Text-to-Video Models:**
+   *       - `"fal-ai/veo3.1"` - Google Veo 3.1 (best quality)
+   *       - `"fal-ai/veo3.1/fast"` (default) - Veo 3.1 fast mode (faster, cheaper)
+   *       - `"fal-ai/sora-2/text-to-video/pro"` - OpenAI Sora 2
+   *       - `"fal-ai/kling-video/v2.6/pro/text-to-video"` - Kling 2.6
+   *       **Image-to-Video Models:**
+   *       - `"fal-ai/veo3.1/image-to-video"` - Veo 3.1 I2V
+   *       - `"fal-ai/veo3.1/fast/image-to-video"` - Veo 3.1 fast I2V
+   *       - `"fal-ai/sora-2/image-to-video/pro"` - Sora 2 I2V
+   *       - `"fal-ai/kling-video/v2.6/pro/image-to-video"` - Kling 2.6 I2V
+   *   - `image_url`: Source image URL for image-to-video (required for I2V models)
+   *   - `duration`: Video duration ("4s", "5s", "6s", "8s", "10s", "12s")
+   *   - `aspect_ratio`: Aspect ratio ("16:9", "9:16", "1:1")
+   *   - `resolution`: Resolution ("720p", "1080p") - Veo/Sora only
+   *   - `negative_prompt`: What to avoid in generation - Veo/Kling only
+   *   - `generate_audio`: Generate audio with video (default: true)
+   *   - `seed`: For reproducibility - Veo only
+   *   - `cfg_scale`: Guidance scale (0-1) - Kling only
+   *   - Plus optional signal parameter
+   * 
+   * @example
+   * ```ts
+   * // Basic text-to-video generation (uses default fast model)
+   * const { result } = await blink.ai.generateVideo({
+   *   prompt: "A serene sunset over the ocean with gentle waves"
+   * });
+   * console.log("Video URL:", result.video.url);
+   * 
+   * // High quality with Veo 3.1
+   * const { result } = await blink.ai.generateVideo({
+   *   prompt: "A cinematic shot of a futuristic city at night",
+   *   model: "fal-ai/veo3.1",
+   *   resolution: "1080p",
+   *   aspect_ratio: "16:9"
+   * });
+   * 
+   * // Image-to-video animation
+   * const { result } = await blink.ai.generateVideo({
+   *   prompt: "Animate this image with gentle camera movement",
+   *   model: "fal-ai/veo3.1/fast/image-to-video",
+   *   image_url: "https://example.com/my-image.jpg",
+   *   duration: "5s"
+   * });
+   * 
+   * // Using Sora 2 for creative videos
+   * const { result } = await blink.ai.generateVideo({
+   *   prompt: "A magical forest with glowing fireflies",
+   *   model: "fal-ai/sora-2/text-to-video/pro",
+   *   duration: "8s"
+   * });
+   * 
+   * // Using Kling for detailed videos
+   * const { result, usage } = await blink.ai.generateVideo({
+   *   prompt: "A professional cooking tutorial scene",
+   *   model: "fal-ai/kling-video/v2.6/pro/text-to-video",
+   *   negative_prompt: "blur, distort, low quality",
+   *   cfg_scale: 0.7
+   * });
+   * console.log("Credits charged:", usage?.creditsCharged);
+   * ```
+   * 
+   * @returns Promise<VideoGenerationResponse> - Object containing:
+   *   - `result.video.url`: URL to the generated video
+   *   - `result.video.content_type`: MIME type (video/mp4)
+   *   - `result.video.file_name`: Generated filename
+   *   - `result.video.file_size`: File size in bytes
+   *   - `metadata`: Generation metadata (projectId, timestamp, model)
+   *   - `usage`: Credits charged and cost information
+   */
+  async generateVideo(options) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      const i2vModels = [
+        "fal-ai/veo3.1/image-to-video",
+        "fal-ai/veo3.1/fast/image-to-video",
+        "fal-ai/sora-2/image-to-video/pro",
+        "fal-ai/kling-video/v2.6/pro/image-to-video"
+      ];
+      if (options.model && i2vModels.includes(options.model) && !options.image_url) {
+        throw new BlinkAIError("image_url is required for image-to-video models");
+      }
+      if (options.image_url) {
+        const validation = this.validateImageUrl(options.image_url);
+        if (!validation.isValid) {
+          throw new BlinkAIError(`Invalid image_url: ${validation.error}`);
+        }
+      }
+      const response = await this.httpClient.aiVideo(
+        options.prompt,
+        {
+          model: options.model,
+          image_url: options.image_url,
+          duration: options.duration,
+          aspect_ratio: options.aspect_ratio,
+          resolution: options.resolution,
+          negative_prompt: options.negative_prompt,
+          generate_audio: options.generate_audio,
+          seed: options.seed,
+          cfg_scale: options.cfg_scale,
+          signal: options.signal
+        }
+      );
+      if (!response.data?.result?.video?.url) {
+        throw new BlinkAIError("Invalid response format: missing video URL");
+      }
+      return response.data;
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Video generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Converts text to speech using AI voice synthesis models.
    * 
@@ -4802,7 +5099,7 @@ var BlinkRealtimeChannel = class {
     return new Promise((resolve, reject) => {
       try {
         const httpClient = this.httpClient;
-        const coreUrl = httpClient.coreUrl || "https://dev.core.blink.new";
+        const coreUrl = httpClient.coreUrl || "https://core.blink.new";
         const baseUrl = coreUrl.replace("https://", "wss://").replace("http://", "ws://");
         const wsUrl = `${baseUrl}?project_id=${this.projectId}`;
         console.log(`\u{1F517} Attempting WebSocket connection to: ${wsUrl}`);
@@ -5271,7 +5568,6 @@ var BlinkAnalyticsImpl = class {
     } catch (error) {
       this.queue = [...events, ...this.queue];
       this.persistQueue();
-      console.error("Failed to send analytics events:", error);
     }
     if (this.queue.length > 0) {
       this.timer = setTimeout(() => this.flush(), BATCH_TIMEOUT);
@@ -5462,6 +5758,64 @@ var BlinkAnalyticsImpl = class {
   }
 };
 
+// src/connectors.ts
+var BlinkConnectorsImpl = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async status(provider, options) {
+    const response = await this.httpClient.connectorStatus(provider);
+    return response.data;
+  }
+  async execute(provider, request) {
+    const response = await this.httpClient.connectorExecute(provider, request);
+    return response.data;
+  }
+  async saveApiKey(provider, request) {
+    const response = await this.httpClient.connectorSaveApiKey(provider, request);
+    return response.data;
+  }
+};
+
+// src/functions.ts
+var BlinkFunctionsImpl = class {
+  httpClient;
+  projectId;
+  constructor(httpClient, projectId, _getToken) {
+    this.httpClient = httpClient;
+    this.projectId = projectId;
+  }
+  /**
+   * Get the project suffix from the full project ID.
+   * Project IDs are formatted as: prj_xxxxx
+   * The suffix is the last 8 characters used in function URLs.
+   */
+  getProjectSuffix() {
+    return this.projectId.slice(-8);
+  }
+  /**
+   * Build the full function URL
+   */
+  buildFunctionUrl(functionSlug, searchParams) {
+    const suffix = this.getProjectSuffix();
+    const baseUrl = `https://${suffix}--${functionSlug}.functions.blink.new`;
+    if (!searchParams || Object.keys(searchParams).length === 0) {
+      return baseUrl;
+    }
+    const url = new URL(baseUrl);
+    Object.entries(searchParams).forEach(([key, value]) => {
+      url.searchParams.set(key, value);
+    });
+    return url.toString();
+  }
+  async invoke(functionSlug, options = {}) {
+    const { method = "POST", body, headers = {}, searchParams } = options;
+    const url = this.buildFunctionUrl(functionSlug, searchParams);
+    const res = await this.httpClient.request(url, { method, body, headers });
+    return { data: res.data, status: res.status, headers: res.headers };
+  }
+};
+
 // src/client.ts
 var BlinkClientImpl = class {
   auth;
@@ -5472,8 +5826,13 @@ var BlinkClientImpl = class {
   realtime;
   notifications;
   analytics;
+  connectors;
+  functions;
   httpClient;
   constructor(config) {
+    if ((config.secretKey || config.serviceToken) && isBrowser) {
+      throw new Error("secretKey/serviceToken is server-only. Do not provide it in browser/React Native clients.");
+    }
     this.auth = new BlinkAuth(config);
     this.httpClient = new HttpClient(
       config,
@@ -5487,6 +5846,12 @@ var BlinkClientImpl = class {
     this.realtime = new BlinkRealtimeImpl(this.httpClient, config.projectId);
     this.notifications = new BlinkNotificationsImpl(this.httpClient);
     this.analytics = new BlinkAnalyticsImpl(this.httpClient, config.projectId);
+    this.connectors = new BlinkConnectorsImpl(this.httpClient);
+    this.functions = new BlinkFunctionsImpl(
+      this.httpClient,
+      config.projectId,
+      () => this.auth.getValidToken()
+    );
     this.auth.onAuthStateChanged((state) => {
       if (state.isAuthenticated && state.user) {
         this.analytics.setUserId(state.user.id);
@@ -5505,6 +5870,6 @@ function createClient(config) {
   return new BlinkClientImpl(config);
 }
 
-export { AsyncStorageAdapter, BlinkAIImpl, BlinkAnalyticsImpl, BlinkDataImpl, BlinkDatabase, BlinkRealtimeChannel, BlinkRealtimeImpl, BlinkStorageImpl, BlinkTable, NoOpStorageAdapter, WebStorageAdapter, createClient, getDefaultStorageAdapter, isBrowser, isNode, isReactNative, isWeb, platform };
+export { AsyncStorageAdapter, BlinkAIImpl, BlinkAnalyticsImpl, BlinkConnectorsImpl, BlinkDataImpl, BlinkDatabase, BlinkRealtimeChannel, BlinkRealtimeImpl, BlinkStorageImpl, BlinkTable, NoOpStorageAdapter, WebStorageAdapter, createClient, getDefaultStorageAdapter, isBrowser, isDeno, isNode, isReactNative, isServer, isWeb, platform };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map