@omnikit-ai/sdk 2.2.0 → 2.2.2

package/dist/index.js

@@ -660,6 +660,20 @@ var APIClient = class {
         description: "Create a signed URL for a private file",
         method: "POST",
         params: { file_uri: "string" }
+      },
+      {
+        name: "DownloadPrivateFile",
+        path: "/services/files/private/download",
+        description: "Download a private file via backend proxy (solves CORS issues)",
+        method: "POST",
+        params: { file_uri: "string" }
+      },
+      {
+        name: "DownloadFile",
+        path: "/services/files/{file_id}/download",
+        description: "Download a public file via backend proxy (like Supabase ?download)",
+        method: "GET",
+        params: { file_id: "string", download: "boolean", filename: "string" }
       }
     ];
     builtInServices.forEach((service) => {
@@ -869,6 +883,25 @@ var APIClient = class {
     }
     return this._connectors;
   }
+  /**
+   * Resolve a return URL to an absolute URL.
+   * Handles relative paths like "/profile" by combining with current location.
+   * This fixes the OAuth redirect bug where relative URLs like "/profile" become
+   * "https://omnikit.ai/profile" instead of "https://omnikit.ai/app-builder/{id}/preview/profile"
+   */
+  _resolveReturnUrl(returnUrl) {
+    if (typeof window === "undefined") return returnUrl || "/";
+    if (!returnUrl) return window.location.href;
+    if (returnUrl.startsWith("http://") || returnUrl.startsWith("https://")) {
+      return returnUrl;
+    }
+    if (returnUrl.startsWith("/")) {
+      const basePath = window.location.pathname.endsWith("/") ? window.location.pathname.slice(0, -1) : window.location.pathname;
+      return window.location.origin + basePath + returnUrl;
+    }
+    const base = window.location.origin + window.location.pathname;
+    return base.endsWith("/") ? base + returnUrl : base + "/" + returnUrl;
+  }
   /**
    * Create auth proxy that auto-initializes
    */
@@ -896,31 +929,42 @@ var APIClient = class {
         client.emitUserChange(response);
         return response;
       },
-      login(returnUrl) {
-        const fullReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
-        if (typeof window !== "undefined") {
-          if (window.__omnikit_openLoginModal) {
-            window.__omnikit_openLoginModal(fullReturnUrl);
-            return;
-          }
-          const encodedReturnUrl = encodeURIComponent(fullReturnUrl);
-          const currentPath = window.location.pathname;
-          const apiSitesMatch = currentPath.match(/^\/api\/sites\/([^\/]+)/);
-          if (apiSitesMatch) {
-            window.location.href = `/api/sites/${client.appId}/login?return_url=${encodedReturnUrl}`;
-          } else {
-            window.location.href = `/login?return_url=${encodedReturnUrl}`;
+      async login(returnUrl) {
+        if (typeof window === "undefined") return;
+        const fullReturnUrl = client._resolveReturnUrl(returnUrl);
+        const token = getAccessToken();
+        if (token) {
+          try {
+            const isAuth = await this.isAuthenticated();
+            if (isAuth && returnUrl) {
+              window.location.href = fullReturnUrl;
+              return;
+            }
+          } catch {
           }
         }
+        if (window.__omnikit_openLoginModal) {
+          window.__omnikit_openLoginModal(fullReturnUrl);
+          return;
+        }
+        const encodedReturnUrl = encodeURIComponent(fullReturnUrl);
+        const currentPath = window.location.pathname;
+        const apiSitesMatch = currentPath.match(/^\/api\/sites\/([^\/]+)/);
+        if (apiSitesMatch) {
+          window.location.href = `/api/sites/${client.appId}/login?return_url=${encodedReturnUrl}`;
+        } else {
+          window.location.href = `/login?return_url=${encodedReturnUrl}`;
+        }
       },
       /**
        * Request a passwordless login code to email
        */
       async requestLoginCode(email, returnUrl) {
+        const fullReturnUrl = returnUrl ? client._resolveReturnUrl(returnUrl) : void 0;
         return await client.makeRequest(
           `${client.baseUrl}/auth/email/request-code`,
           "POST",
-          { email, return_url: returnUrl }
+          { email, return_url: fullReturnUrl }
         );
       },
       /**
@@ -968,44 +1012,43 @@ var APIClient = class {
        * Redirects to the backend OAuth endpoint for the specified provider
        */
       loginWithProvider(providerId, returnUrl) {
-        const currentUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
-        const redirectUrl = `${client.baseUrl}/auth/${providerId}?redirect_url=${encodeURIComponent(currentUrl)}`;
-        if (typeof window !== "undefined") {
-          const inIframe = window.self !== window.top;
-          if (inIframe) {
-            const width = 600;
-            const height = 700;
-            const left = window.screen.width / 2 - width / 2;
-            const top = window.screen.height / 2 - height / 2;
-            const popup = window.open(
-              redirectUrl,
-              "oauth_popup",
-              `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`
-            );
-            if (popup) {
-              const checkTimer = setInterval(() => {
-                const token = getAccessToken();
-                if (token) {
-                  clearInterval(checkTimer);
-                  popup.close();
+        if (typeof window === "undefined") {
+          throw new OmnikitError("loginWithProvider() can only be called in browser environment", 400, "NOT_BROWSER");
+        }
+        const fullReturnUrl = client._resolveReturnUrl(returnUrl);
+        const redirectUrl = `${client.baseUrl}/auth/${providerId}?redirect_url=${encodeURIComponent(fullReturnUrl)}`;
+        const inIframe = window.self !== window.top;
+        if (inIframe) {
+          const width = 600;
+          const height = 700;
+          const left = window.screen.width / 2 - width / 2;
+          const top = window.screen.height / 2 - height / 2;
+          const popup = window.open(
+            redirectUrl,
+            "oauth_popup",
+            `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`
+          );
+          if (popup) {
+            const checkTimer = setInterval(() => {
+              const token = getAccessToken();
+              if (token) {
+                clearInterval(checkTimer);
+                popup.close();
+                window.location.reload();
+                return;
+              }
+              if (popup.closed) {
+                clearInterval(checkTimer);
+                const finalToken = getAccessToken();
+                if (finalToken) {
                   window.location.reload();
-                  return;
                 }
-                if (popup.closed) {
-                  clearInterval(checkTimer);
-                  const finalToken = getAccessToken();
-                  if (finalToken) {
-                    window.location.reload();
-                  }
-                }
-              }, 1e3);
-              return;
-            }
+              }
+            }, 1e3);
+            return;
           }
-          window.location.href = redirectUrl;
-        } else {
-          throw new OmnikitError("loginWithProvider() can only be called in browser environment", 400, "NOT_BROWSER");
         }
+        window.location.href = redirectUrl;
       },
       /**
        * Initiate Google OAuth Login
@@ -1217,7 +1260,8 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
       // Remove callback functions from request body
       onToken: void 0,
       onComplete: void 0,
-      onError: void 0
+      onError: void 0,
+      onToolCall: void 0
     };
     Object.keys(requestBody).forEach((key) => {
       if (requestBody[key] === void 0) {
@@ -1268,6 +1312,14 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
               if (event.type === "token" && event.content) {
                 fullResponse += event.content;
                 params.onToken?.(event.content);
+              } else if (event.type === "tool_call") {
+                if (params.onToolCall && event.id && event.name) {
+                  params.onToolCall({
+                    id: event.id,
+                    name: event.name,
+                    arguments: event.arguments || {}
+                  });
+                }
               } else if (event.type === "done") {
                 params.onComplete?.({
                   result: event.result || fullResponse,
@@ -1326,6 +1378,56 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
               );
             };
           }
+          if (normalizedName === "DownloadFile") {
+            return async function(params) {
+              await client.ensureInitialized();
+              if (!params?.file_id) {
+                throw new OmnikitError(
+                  "file_id is required for DownloadFile",
+                  400,
+                  "MISSING_FILE_ID"
+                );
+              }
+              const downloadUrl = new URL(`${client.baseUrl}/apps/${client.appId}/services/files/${params.file_id}/download`);
+              if (params.download !== void 0) {
+                downloadUrl.searchParams.set("download", String(params.download));
+              }
+              if (params.filename) {
+                downloadUrl.searchParams.set("filename", params.filename);
+              }
+              const response = await fetch(downloadUrl.toString(), {
+                method: "GET"
+              });
+              if (!response.ok) {
+                const error = await response.json().catch(() => ({ detail: "Download failed" }));
+                throw new OmnikitError(
+                  error.detail || "Download failed",
+                  response.status,
+                  "DOWNLOAD_FAILED"
+                );
+              }
+              const blob = await response.blob();
+              const blobUrl = URL.createObjectURL(blob);
+              let filename = params.filename;
+              if (!filename) {
+                const contentDisposition = response.headers.get("Content-Disposition");
+                if (contentDisposition) {
+                  const match = contentDisposition.match(/filename="?([^"]+)"?/);
+                  if (match) filename = match[1];
+                }
+              }
+              if (!filename) {
+                filename = `file-${params.file_id}`;
+              }
+              const link = document.createElement("a");
+              link.href = blobUrl;
+              link.download = filename;
+              document.body.appendChild(link);
+              link.click();
+              document.body.removeChild(link);
+              URL.revokeObjectURL(blobUrl);
+            };
+          }
           if (normalizedName === "DownloadPrivateFile") {
             return async function(params) {
               await client.ensureInitialized();
@@ -1336,16 +1438,47 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
                   "MISSING_FILE_URI"
                 );
               }
-              const downloadUrl = new URL(`${client.baseUrl}/apps/${client.appId}/services/files/download`);
-              downloadUrl.searchParams.set("file_uri", params.file_uri);
-              if (params.filename) {
-                downloadUrl.searchParams.set("filename", params.filename);
-              }
+              const downloadUrl = `${client.baseUrl}/apps/${client.appId}/services/files/private/download`;
               const token = client.getAuthToken();
-              if (token) {
-                downloadUrl.searchParams.set("token", token);
+              const response = await fetch(downloadUrl, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  ...token ? { "Authorization": `Bearer ${token}` } : {}
+                },
+                body: JSON.stringify({ file_uri: params.file_uri })
+              });
+              if (!response.ok) {
+                const error = await response.json().catch(() => ({ detail: "Download failed" }));
+                throw new OmnikitError(
+                  error.detail || "Download failed",
+                  response.status,
+                  "DOWNLOAD_FAILED"
+                );
+              }
+              const blob = await response.blob();
+              const blobUrl = URL.createObjectURL(blob);
+              let filename = params.filename;
+              if (!filename) {
+                const contentDisposition = response.headers.get("Content-Disposition");
+                if (contentDisposition) {
+                  const match = contentDisposition.match(/filename="?([^"]+)"?/);
+                  if (match) filename = match[1];
+                }
               }
-              window.open(downloadUrl.toString(), "_blank");
+              if (!filename) {
+                const uriParts = params.file_uri.split("/");
+                const lastPart = uriParts[uriParts.length - 1];
+                const underscoreIdx = lastPart.indexOf("_");
+                filename = underscoreIdx > 0 ? lastPart.slice(underscoreIdx + 1) : lastPart;
+              }
+              const link = document.createElement("a");
+              link.href = blobUrl;
+              link.download = filename;
+              document.body.appendChild(link);
+              link.click();
+              document.body.removeChild(link);
+              URL.revokeObjectURL(blobUrl);
             };
           }
           return async function(params, asyncOptions) {
@@ -1364,7 +1497,7 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
               response = await method(params, useServiceToken);
             } else {
               throw new OmnikitError(
-                `Service '${serviceName}' not found. Known services: SendEmail, InvokeLLM, GenerateImage, GenerateSpeech, GenerateVideo, ExtractData, SendSMS, UploadFile, UploadPrivateFile, CreateFileSignedUrl (camelCase also supported)`,
+                `Service '${serviceName}' not found. Known services: SendEmail, InvokeLLM, GenerateImage, GenerateSpeech, GenerateVideo, ExtractData, SendSMS, UploadFile, UploadPrivateFile, CreateFileSignedUrl, DownloadFile, DownloadPrivateFile (camelCase also supported)`,
                 404,
                 "SERVICE_NOT_FOUND"
               );
@@ -1417,6 +1550,18 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
                     if (params?.model) {
                       params = { ...params, model: mapLLMModel(params.model) };
                     }
+                    if (params?.saveResult) {
+                      params = {
+                        ...params,
+                        save_result: {
+                          collection: params.saveResult.collection,
+                          document_id: params.saveResult.documentId,
+                          field: params.saveResult.field,
+                          additional_fields: params.saveResult.additionalFields
+                        }
+                      };
+                      delete params.saveResult;
+                    }
                   }
                   const integrationPackage = client._integrations[packageName];
                   if (!integrationPackage) {
@@ -1531,7 +1676,7 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
         );
         return response;
       },
-      // List all records with MongoDB/Mongoose-style filtering
+      // List all records with MongoDB/Mongoose-style filtering and cursor pagination
       async list(...args) {
         const queryParams = new URLSearchParams();
         let filter;
@@ -1576,11 +1721,25 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
             if (options.offset !== void 0) {
               queryParams.append("offset", String(options.offset));
             }
+            if (options.after !== void 0) {
+              queryParams.append("after", options.after);
+            }
           }
         }
         const url = queryParams.toString() ? `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}?${queryParams}` : `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}`;
         const response = await client.makeRequest(url, "GET");
-        return makeArrayForgiving(Array.isArray(response) ? response : []);
+        if (response && typeof response === "object" && "data" in response && "hasMore" in response) {
+          return {
+            data: makeArrayForgiving(response.data),
+            hasMore: response.hasMore,
+            nextCursor: response.nextCursor
+          };
+        }
+        return {
+          data: makeArrayForgiving(Array.isArray(response) ? response : []),
+          hasMore: false,
+          nextCursor: null
+        };
       },
       // Filter records by query (alias for list)
       async filter(...args) {
@@ -1589,21 +1748,21 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
       // Find single record matching query
       async findOne(...args) {
         if (args.length === 0) {
-          const results = await this.list({}, { limit: 1 });
-          return results[0] || null;
+          const result = await this.list({}, { limit: 1 });
+          return result.data[0] || null;
         } else if (args.length === 1) {
           const arg = args[0];
           if (arg && (arg.q !== void 0 || arg._count !== void 0)) {
-            const results = await this.list({ ...arg, limit: 1 });
-            return results[0] || null;
+            const result = await this.list({ ...arg, limit: 1 });
+            return result.data[0] || null;
           } else {
-            const results = await this.list(arg, { limit: 1 });
-            return results[0] || null;
+            const result = await this.list(arg, { limit: 1 });
+            return result.data[0] || null;
           }
         } else {
           const [filter, options] = args;
-          const results = await this.list(filter, { ...options, limit: 1 });
-          return results[0] || null;
+          const result = await this.list(filter, { ...options, limit: 1 });
+          return result.data[0] || null;
         }
       },
       // Create new record
@@ -1880,6 +2039,8 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
       "files": "UploadFile",
       "files/private": "UploadPrivateFile",
       "files/signed-url": "CreateFileSignedUrl",
+      "files/private/download": "DownloadPrivateFile",
+      "files/download": "DownloadFile",
       "images": "GenerateImage",
       "speech": "GenerateSpeech",
       "video": "GenerateVideo",
@@ -2227,6 +2388,266 @@ Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
       config
     );
   }
+  /**
+   * Run an assistant with streaming response.
+   *
+   * Assistants are server-side AI agents with custom instructions and built-in actions.
+   * They can create/update/delete records, send emails, make HTTP requests, etc.
+   *
+   * @example
+   * ```typescript
+   * const result = await omnikit.runAssistant('customer_support', {
+   *   messages: [{ role: 'user', content: 'Help me track my order #12345' }],
+   *   onToken: (token) => setResponse(prev => prev + token),
+   *   onActionStart: (action) => console.log(`Starting: ${action.name}`),
+   *   onActionComplete: (action) => console.log(`Completed: ${action.name}`),
+   * });
+   *
+   * // Continue the conversation
+   * await omnikit.runAssistant('customer_support', {
+   *   messages: [{ role: 'user', content: 'When will it arrive?' }],
+   *   threadId: result.threadId,
+   *   onToken: (token) => setResponse(prev => prev + token),
+   * });
+   * ```
+   *
+   * @param assistantName - Name of the assistant to run
+   * @param params - Run parameters including messages and callbacks
+   * @returns Promise resolving to the run result with threadId
+   */
+  async runAssistant(assistantName, params) {
+    await this.ensureInitialized();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const token = this.getAuthToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (this._serviceToken) {
+      headers["X-Service-Token"] = this._serviceToken;
+    }
+    if (this._apiKey) {
+      headers["X-API-Key"] = this._apiKey;
+    }
+    const requestBody = {
+      messages: params.messages,
+      thread_id: params.threadId,
+      stream: true
+    };
+    const response = await fetch(
+      `${this.baseUrl}/apps/${this.appId}/assistants/${assistantName}/runs`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = `Assistant run failed: ${response.statusText}`;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.detail || errorJson.message || errorMessage;
+      } catch {
+        errorMessage = errorText || errorMessage;
+      }
+      const err = new OmnikitError(errorMessage, response.status, "ASSISTANT_ERROR");
+      params.onError?.(err);
+      throw err;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      const err = new OmnikitError("No response body", 500, "NO_BODY");
+      params.onError?.(err);
+      throw err;
+    }
+    const decoder = new TextDecoder();
+    let fullResponse = "";
+    let buffer = "";
+    let threadId = params.threadId || "";
+    let messageCount = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              if (event.type === "token" && event.content) {
+                fullResponse += event.content;
+                params.onToken?.(event.content);
+              } else if (event.type === "action_start") {
+                params.onActionStart?.({
+                  id: event.id || "",
+                  name: event.name || "",
+                  arguments: event.arguments || {}
+                });
+              } else if (event.type === "action_complete") {
+                params.onActionComplete?.({
+                  id: event.id || "",
+                  name: event.name || "",
+                  output: event.output
+                });
+              } else if (event.type === "action_failed") {
+                params.onActionFailed?.({
+                  id: event.id || "",
+                  name: event.name || "",
+                  error: event.error || "Action failed"
+                });
+              } else if (event.type === "done") {
+                threadId = event.thread_id || threadId;
+                messageCount = event.message_count || 0;
+                const result = {
+                  threadId,
+                  messageCount,
+                  response: fullResponse
+                };
+                params.onComplete?.(result);
+              } else if (event.type === "error") {
+                const err = new OmnikitError(
+                  event.message || "Assistant error",
+                  500,
+                  "ASSISTANT_ERROR"
+                );
+                params.onError?.(err);
+                throw err;
+              }
+            } catch (parseError) {
+              if (parseError instanceof OmnikitError) {
+                throw parseError;
+              }
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return {
+      threadId,
+      messageCount,
+      response: fullResponse
+    };
+  }
+  /**
+   * Subscribe to a thread via WebSocket for real-time updates.
+   *
+   * Use this to watch a thread without triggering a run. Useful for:
+   * - Showing live updates when another client runs the assistant
+   * - Reconnecting after page navigation
+   * - Observing thread activity in real-time
+   *
+   * @example
+   * ```typescript
+   * // Subscribe to a thread
+   * const unsubscribe = omnikit.subscribeToThread(threadId, {
+   *   onConnected: (info) => console.log(`Connected to ${info.assistantName}`),
+   *   onToken: (token) => setResponse(prev => prev + token),
+   *   onActionStart: (action) => console.log(`Action: ${action.name}`),
+   *   onActionComplete: (action) => console.log(`Result: ${JSON.stringify(action.output)}`),
+   *   onRunComplete: (result) => console.log(`Run complete, ${result.messageCount} messages`),
+   *   onError: (error) => console.error(error),
+   * });
+   *
+   * // Later: disconnect
+   * unsubscribe();
+   * ```
+   *
+   * @param threadId - Thread ID to subscribe to
+   * @param callbacks - Event callbacks for real-time updates
+   * @returns Unsubscribe function to close the WebSocket
+   */
+  subscribeToThread(threadId, callbacks) {
+    const wsProtocol = this.baseUrl.startsWith("https") ? "wss" : "ws";
+    const wsBaseUrl = this.baseUrl.replace(/^https?:\/\//, "");
+    let wsUrl = `${wsProtocol}://${wsBaseUrl}/apps/${this.appId}/threads/${threadId}/subscribe`;
+    const token = this.getAuthToken();
+    if (token) {
+      wsUrl += `?token=${encodeURIComponent(token)}`;
+    }
+    const ws = new WebSocket(wsUrl);
+    let pingInterval = null;
+    ws.onopen = () => {
+      pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, 3e4);
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "connected":
+            callbacks.onConnected?.({
+              threadId: data.thread_id,
+              assistantName: data.assistant_name,
+              messageCount: data.message_count
+            });
+            break;
+          case "token":
+            callbacks.onToken?.(data.content || "");
+            break;
+          case "action_start":
+            callbacks.onActionStart?.({
+              id: data.id || "",
+              name: data.name || "",
+              arguments: data.arguments || {}
+            });
+            break;
+          case "action_complete":
+            callbacks.onActionComplete?.({
+              id: data.id || "",
+              name: data.name || "",
+              output: data.output
+            });
+            break;
+          case "action_failed":
+            callbacks.onActionFailed?.({
+              id: data.id || "",
+              name: data.name || "",
+              error: data.error || "Action failed"
+            });
+            break;
+          case "run_complete":
+          case "done":
+            callbacks.onRunComplete?.({
+              threadId: data.thread_id || threadId,
+              messageCount: data.message_count || 0
+            });
+            break;
+          case "error":
+            callbacks.onError?.(new Error(data.message || "WebSocket error"));
+            break;
+          case "pong":
+            break;
+        }
+      } catch (parseError) {
+      }
+    };
+    ws.onerror = (event) => {
+      callbacks.onError?.(new Error("WebSocket connection error"));
+    };
+    ws.onclose = () => {
+      if (pingInterval) {
+        clearInterval(pingInterval);
+      }
+      callbacks.onDisconnect?.();
+    };
+    return () => {
+      if (pingInterval) {
+        clearInterval(pingInterval);
+      }
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+    };
+  }
   /**
    * Invoke a backend function by name.
    *