@blinkdotnew/dev-sdk 2.1.6 → 2.1.8

package/dist/index.js

@@ -7,33 +7,6 @@ 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) {
@@ -119,9 +92,6 @@ var NoOpStorageAdapter = class {
   }
 };
 function getDefaultStorageAdapter() {
-  if (isDeno) {
-    return new NoOpStorageAdapter();
-  }
   if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
     try {
       localStorage.setItem("__test__", "test");
@@ -133,6 +103,28 @@ 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) {
@@ -396,44 +388,17 @@ function convertKeysToCamelCase(obj) {
   return converted;
 }
 var HttpClient = class {
-  authUrl = "https://blink.new";
-  coreUrl = "https://core.blink.new";
+  authUrl;
+  coreUrl;
   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;
-  }
-  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;
+    this.authUrl = config.auth?.authUrl ?? "https://blink.new";
+    this.coreUrl = config.auth?.coreUrl ?? "https://dev.core.blink.new";
   }
   /**
    * Make an authenticated request to the Blink API
@@ -441,23 +406,19 @@ 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
     };
-    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;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
     const requestInit = {
-      method,
+      method: options.method || "GET",
       headers,
       signal: options.signal
     };
-    if (options.body && method !== "GET") {
+    if (options.body && options.method !== "GET") {
       requestInit.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
     }
     try {
@@ -611,12 +572,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 = {};
-    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;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
     try {
       if (typeof XMLHttpRequest !== "undefined" && options.onProgress) {
@@ -717,7 +678,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`);
@@ -725,8 +686,9 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    const auth = this.getAuthorizationHeader(url, token);
-    if (auth) headers.Authorization = auth;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
     const body = {
       prompt,
       stream: true,
@@ -746,7 +708,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;
@@ -771,7 +733,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`);
@@ -779,8 +741,9 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    const auth = this.getAuthorizationHeader(url, token);
-    if (auth) headers.Authorization = auth;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
     const body = {
       prompt,
       stream: true,
@@ -800,35 +763,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;
@@ -885,17 +820,6 @@ 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
    */
@@ -937,38 +861,6 @@ 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
    */
@@ -1034,94 +926,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;
@@ -1289,13 +1180,13 @@ var BlinkAuth = class {
       mode: "managed",
       // Default mode
       authUrl: "https://blink.new",
-      coreUrl: "https://core.blink.new",
+      coreUrl: "https://dev.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";
+    this.coreUrl = this.authConfig.coreUrl || "https://dev.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.");
@@ -1469,7 +1360,6 @@ var BlinkAuth = class {
     if (this.config.projectId) {
       authUrl.searchParams.set("project_id", this.config.projectId);
     }
-    authUrl.searchParams.set("prompt", "select_account");
     window.location.href = authUrl.toString();
   }
   /**
@@ -3049,11 +2939,6 @@ 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()}`);
 }
@@ -3272,7 +3157,6 @@ 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;
   }
@@ -3321,7 +3205,6 @@ 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;
   }
@@ -3329,7 +3212,6 @@ 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;
   }
@@ -3392,6 +3274,7 @@ var BlinkStorageImpl = class {
         correctedPath,
         // Use corrected path with proper extension
         {
+          upsert: options.upsert,
           onProgress: options.onProgress,
           contentType: detectedContentType
           // Pass detected content type
@@ -3411,7 +3294,7 @@ var BlinkStorageImpl = class {
       if (error instanceof Error && "status" in error) {
         const status = error.status;
         if (status === 409) {
-          throw new BlinkStorageError("File already exists.", 409);
+          throw new BlinkStorageError("File already exists. Set upsert: true to overwrite.", 409);
         }
         if (status === 400) {
           throw new BlinkStorageError("Invalid request parameters", 400);
@@ -3456,6 +3339,7 @@ var BlinkStorageImpl = class {
         detectedContentType
       };
     } catch (error) {
+      console.warn("File type detection failed, using original path:", error);
       return {
         correctedPath: originalPath,
         detectedContentType: "application/octet-stream"
@@ -3845,7 +3729,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;
@@ -3914,14 +3804,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) {
@@ -4000,7 +3885,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;
@@ -4062,7 +3953,8 @@ var BlinkAIImpl = class {
       return {
         object: result.object || {},
         finishReason: "stop",
-        usage: result.usage
+        usage: result.usage,
+        ...result
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -4323,131 +4215,6 @@ 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.
    * 
@@ -5037,7 +4804,7 @@ var BlinkRealtimeChannel = class {
     return new Promise((resolve, reject) => {
       try {
         const httpClient = this.httpClient;
-        const coreUrl = httpClient.coreUrl || "https://core.blink.new";
+        const coreUrl = httpClient.coreUrl || "https://dev.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}`);
@@ -5506,6 +5273,7 @@ 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);
@@ -5696,64 +5464,6 @@ 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;
@@ -5764,13 +5474,8 @@ 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,
@@ -5784,12 +5489,6 @@ 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);
@@ -5811,7 +5510,6 @@ function createClient(config) {
 exports.AsyncStorageAdapter = AsyncStorageAdapter;
 exports.BlinkAIImpl = BlinkAIImpl;
 exports.BlinkAnalyticsImpl = BlinkAnalyticsImpl;
-exports.BlinkConnectorsImpl = BlinkConnectorsImpl;
 exports.BlinkDataImpl = BlinkDataImpl;
 exports.BlinkDatabase = BlinkDatabase;
 exports.BlinkRealtimeChannel = BlinkRealtimeChannel;
@@ -5823,10 +5521,8 @@ exports.WebStorageAdapter = WebStorageAdapter;
 exports.createClient = createClient;
 exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
 exports.isBrowser = isBrowser;
-exports.isDeno = isDeno;
 exports.isNode = isNode;
 exports.isReactNative = isReactNative;
-exports.isServer = isServer;
 exports.isWeb = isWeb;
 exports.platform = platform;
 //# sourceMappingURL=index.js.map