@omnikit-ai/sdk 2.0.3

package/dist/index.js

@@ -0,0 +1,2096 @@
+'use strict';
+
+// src/auth-utils.ts
+var ACCESS_TOKEN_KEY = "access_token";
+var TOKEN_URL_PARAM = "token";
+function setAccessTokenKey(appId) {
+  ACCESS_TOKEN_KEY = `omnikit_token_${appId}`;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+function getTokenFromUrl() {
+  if (!isBrowser()) return null;
+  try {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(TOKEN_URL_PARAM);
+  } catch (error) {
+    console.warn("Failed to get token from URL:", error);
+    return null;
+  }
+}
+function getTokenFromStorage() {
+  if (!isBrowser()) return null;
+  try {
+    return localStorage.getItem(ACCESS_TOKEN_KEY);
+  } catch (error) {
+    console.warn("Failed to get token from localStorage:", error);
+    return null;
+  }
+}
+function isTokenInUrl() {
+  return getTokenFromUrl() !== null;
+}
+function cleanTokenFromUrl() {
+  if (!isBrowser()) return;
+  try {
+    const url = new URL(window.location.href);
+    if (url.searchParams.has(TOKEN_URL_PARAM)) {
+      url.searchParams.delete(TOKEN_URL_PARAM);
+      window.history.replaceState({}, "", url.toString());
+    }
+  } catch (error) {
+    console.warn("Failed to clean token from URL:", error);
+  }
+}
+function getTokenFromHash() {
+  if (!isBrowser()) return null;
+  const hash = window.location.hash;
+  if (!hash) return null;
+  try {
+    const params = new URLSearchParams(hash.substring(1));
+    return params.get("_auth_token");
+  } catch (error) {
+    console.warn("Failed to get token from hash:", error);
+    return null;
+  }
+}
+function cleanTokenFromHash() {
+  if (!isBrowser()) return;
+  try {
+    window.history.replaceState(
+      null,
+      "",
+      window.location.pathname + window.location.search
+    );
+  } catch (error) {
+    console.warn("Failed to clean token from hash:", error);
+  }
+}
+function saveAccessToken(token) {
+  if (!isBrowser()) {
+    console.warn("Cannot save token: not in browser environment");
+    return;
+  }
+  try {
+    localStorage.setItem(ACCESS_TOKEN_KEY, token);
+  } catch (error) {
+    console.error("Failed to save token to localStorage:", error);
+  }
+}
+function removeAccessToken() {
+  if (!isBrowser()) return;
+  try {
+    localStorage.removeItem(ACCESS_TOKEN_KEY);
+  } catch (error) {
+    console.warn("Failed to remove token from localStorage:", error);
+  }
+}
+function getAccessToken() {
+  const hashToken = getTokenFromHash();
+  if (hashToken) {
+    saveAccessToken(hashToken);
+    cleanTokenFromHash();
+    console.log("\u2705 OAuth token captured from URL hash");
+    if (isBrowser()) {
+      window.dispatchEvent(new CustomEvent("omnikit:auth-change"));
+    }
+    return hashToken;
+  }
+  const urlToken = getTokenFromUrl();
+  if (urlToken) {
+    saveAccessToken(urlToken);
+    cleanTokenFromUrl();
+    if (isBrowser()) {
+      window.dispatchEvent(new CustomEvent("omnikit:auth-change"));
+    }
+    return urlToken;
+  }
+  return getTokenFromStorage();
+}
+function setAccessToken(token) {
+  saveAccessToken(token);
+}
+
+// src/live-voice.ts
+var INPUT_SAMPLE_RATE = 16e3;
+var OUTPUT_SAMPLE_RATE = 24e3;
+var CHUNK_SIZE = 4096;
+var LiveVoiceSessionImpl = class {
+  constructor(baseUrl, appId, token, config) {
+    this.config = config;
+    this.ws = null;
+    this.audioContext = null;
+    this.mediaStream = null;
+    this.scriptProcessor = null;
+    this.sourceNode = null;
+    this.gainNode = null;
+    // Audio playback queue
+    this.playbackQueue = [];
+    this.isPlaying = false;
+    // Session state
+    this._isActive = false;
+    this._status = "idle";
+    this._sessionId = null;
+    this.baseUrl = baseUrl;
+    this.appId = appId;
+    this.token = token;
+  }
+  get isActive() {
+    return this._isActive;
+  }
+  get status() {
+    return this._status;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Start the voice session
+   */
+  async start() {
+    if (this._isActive) {
+      throw new OmnikitError("Session already active", 400, "SESSION_ACTIVE");
+    }
+    this.setStatus("connecting");
+    try {
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          sampleRate: INPUT_SAMPLE_RATE,
+          channelCount: 1,
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+      this.audioContext = new AudioContext({ sampleRate: OUTPUT_SAMPLE_RATE });
+      const wsUrl = this.buildWebSocketUrl();
+      await this.connectWebSocket(wsUrl);
+      await this.setupAudioCapture();
+      this._isActive = true;
+    } catch (error) {
+      this.setStatus("error");
+      this.config?.onError?.(error);
+      await this.cleanup();
+      throw error;
+    }
+  }
+  /**
+   * Stop the voice session
+   */
+  async stop() {
+    if (!this._isActive) return;
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "end" }));
+    }
+    await this.cleanup();
+  }
+  /**
+   * Interrupt the AI while speaking
+   */
+  interrupt() {
+    if (!this._isActive || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    this.playbackQueue = [];
+    this.ws.send(JSON.stringify({ type: "interrupt" }));
+  }
+  /**
+   * Build WebSocket URL with auth and config
+   */
+  buildWebSocketUrl() {
+    const wsProtocol = this.baseUrl.startsWith("https") ? "wss" : "ws";
+    const wsBase = this.baseUrl.replace(/^https?/, wsProtocol);
+    const params = new URLSearchParams();
+    if (this.token) {
+      params.set("token", this.token);
+    }
+    if (this.config?.systemInstruction) {
+      params.set("system_instruction", this.config.systemInstruction);
+    }
+    if (this.config?.voice) {
+      params.set("voice", this.config.voice);
+    }
+    return `${wsBase}/apps/${this.appId}/live-voice?${params.toString()}`;
+  }
+  /**
+   * Connect to WebSocket server
+   */
+  connectWebSocket(url) {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(url);
+      this.ws.binaryType = "arraybuffer";
+      const timeoutId = setTimeout(() => {
+        reject(new OmnikitError("WebSocket connection timeout", 408, "CONNECT_TIMEOUT"));
+      }, 1e4);
+      this.ws.onopen = () => {
+        clearTimeout(timeoutId);
+      };
+      this.ws.onmessage = (event) => {
+        this.handleMessage(event);
+        if (this._sessionId && this._status === "listening") {
+          resolve();
+        }
+      };
+      this.ws.onerror = (event) => {
+        clearTimeout(timeoutId);
+        const error = new OmnikitError("WebSocket connection error", 500, "WS_ERROR");
+        reject(error);
+      };
+      this.ws.onclose = (event) => {
+        clearTimeout(timeoutId);
+        if (this._isActive) {
+          this.setStatus("disconnected");
+          this.config?.onError?.(new OmnikitError(
+            `Connection closed: ${event.reason || "Unknown reason"}`,
+            event.code,
+            "CONNECTION_CLOSED"
+          ));
+          this.cleanup();
+        }
+      };
+    });
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(event) {
+    if (event.data instanceof ArrayBuffer) {
+      this.handleAudioData(event.data);
+      return;
+    }
+    try {
+      const message = JSON.parse(event.data);
+      switch (message.type) {
+        case "session_started":
+          this._sessionId = message.session_id || null;
+          this.setStatus("listening");
+          this.config?.onSessionStarted?.(this._sessionId);
+          break;
+        case "session_ended":
+          this.config?.onSessionEnded?.(message.duration_seconds || 0);
+          this.cleanup();
+          break;
+        case "transcript":
+          if (message.text && message.role) {
+            this.config?.onTranscript?.(message.text, message.role);
+          }
+          break;
+        case "status":
+          if (message.status) {
+            this.setStatus(message.status);
+          }
+          break;
+        case "error":
+          const error = new OmnikitError(
+            message.message || "Unknown error",
+            500,
+            message.code
+          );
+          this.config?.onError?.(error);
+          break;
+      }
+    } catch (e) {
+      console.warn("[LiveVoice] Failed to parse message:", e);
+    }
+  }
+  /**
+   * Handle incoming audio data from Gemini
+   */
+  handleAudioData(arrayBuffer) {
+    if (!this.audioContext) return;
+    if (this._status !== "speaking") {
+      this.setStatus("speaking");
+    }
+    const pcmData = new Int16Array(arrayBuffer);
+    const floatData = new Float32Array(pcmData.length);
+    for (let i = 0; i < pcmData.length; i++) {
+      floatData[i] = pcmData[i] / 32768;
+    }
+    this.playbackQueue.push(floatData);
+    if (!this.isPlaying) {
+      this.playNextChunk();
+    }
+  }
+  /**
+   * Play next audio chunk from queue
+   */
+  playNextChunk() {
+    if (!this.audioContext || this.playbackQueue.length === 0) {
+      this.isPlaying = false;
+      if (this._status === "speaking") {
+        this.setStatus("listening");
+      }
+      return;
+    }
+    this.isPlaying = true;
+    const floatData = this.playbackQueue.shift();
+    const audioBuffer = this.audioContext.createBuffer(
+      1,
+      // mono
+      floatData.length,
+      OUTPUT_SAMPLE_RATE
+    );
+    audioBuffer.getChannelData(0).set(floatData);
+    const source = this.audioContext.createBufferSource();
+    source.buffer = audioBuffer;
+    source.connect(this.audioContext.destination);
+    source.onended = () => {
+      this.playNextChunk();
+    };
+    source.start();
+  }
+  /**
+   * Set up audio capture from microphone
+   */
+  async setupAudioCapture() {
+    if (!this.audioContext || !this.mediaStream) return;
+    this.sourceNode = this.audioContext.createMediaStreamSource(this.mediaStream);
+    this.scriptProcessor = this.audioContext.createScriptProcessor(CHUNK_SIZE, 1, 1);
+    const inputSampleRate = this.audioContext.sampleRate;
+    this.scriptProcessor.onaudioprocess = (event) => {
+      if (!this._isActive || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      const inputData = event.inputBuffer.getChannelData(0);
+      const resampledData = this.resample(inputData, inputSampleRate, INPUT_SAMPLE_RATE);
+      const pcmData = new Int16Array(resampledData.length);
+      for (let i = 0; i < resampledData.length; i++) {
+        const sample = Math.max(-1, Math.min(1, resampledData[i]));
+        pcmData[i] = sample < 0 ? sample * 32768 : sample * 32767;
+      }
+      this.ws.send(pcmData.buffer);
+    };
+    this.sourceNode.connect(this.scriptProcessor);
+    this.scriptProcessor.connect(this.audioContext.destination);
+    this.gainNode = this.audioContext.createGain();
+    this.gainNode.gain.value = 0;
+    this.scriptProcessor.disconnect();
+    this.scriptProcessor.connect(this.gainNode);
+    this.gainNode.connect(this.audioContext.destination);
+  }
+  /**
+   * Simple linear resampling
+   */
+  resample(inputData, inputRate, outputRate) {
+    if (inputRate === outputRate) {
+      return inputData;
+    }
+    const ratio = inputRate / outputRate;
+    const outputLength = Math.floor(inputData.length / ratio);
+    const output = new Float32Array(outputLength);
+    for (let i = 0; i < outputLength; i++) {
+      const srcIndex = i * ratio;
+      const srcIndexFloor = Math.floor(srcIndex);
+      const srcIndexCeil = Math.min(srcIndexFloor + 1, inputData.length - 1);
+      const fraction = srcIndex - srcIndexFloor;
+      output[i] = inputData[srcIndexFloor] * (1 - fraction) + inputData[srcIndexCeil] * fraction;
+    }
+    return output;
+  }
+  /**
+   * Update status and notify callback
+   */
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.config?.onStatusChange?.(status);
+    }
+  }
+  /**
+   * Clean up all resources
+   */
+  async cleanup() {
+    this._isActive = false;
+    this.playbackQueue = [];
+    this.isPlaying = false;
+    if (this.scriptProcessor) {
+      this.scriptProcessor.disconnect();
+      this.scriptProcessor = null;
+    }
+    if (this.sourceNode) {
+      this.sourceNode.disconnect();
+      this.sourceNode = null;
+    }
+    if (this.gainNode) {
+      this.gainNode.disconnect();
+      this.gainNode = null;
+    }
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach((track) => track.stop());
+      this.mediaStream = null;
+    }
+    if (this.audioContext && this.audioContext.state !== "closed") {
+      await this.audioContext.close();
+      this.audioContext = null;
+    }
+    if (this.ws) {
+      if (this.ws.readyState === WebSocket.OPEN) {
+        this.ws.close(1e3, "Session ended");
+      }
+      this.ws = null;
+    }
+    this._sessionId = null;
+    this.setStatus("idle");
+  }
+};
+
+// src/client.ts
+var LLM_MODEL_MAP = {
+  "gemini-flash": "vertex_ai/gemini-2.5-flash",
+  "gemini-pro": "vertex_ai/gemini-2.5-pro"
+};
+function mapLLMModel(model) {
+  if (!model) return void 0;
+  return LLM_MODEL_MAP[model] || model;
+}
+function makeArrayForgiving(arr) {
+  if (!Array.isArray(arr)) return arr;
+  Object.defineProperty(arr, "items", {
+    get() {
+      return this;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return arr;
+}
+var OmnikitError = class _OmnikitError extends Error {
+  constructor(message, status, code, data) {
+    super(message);
+    this.name = "OmnikitError";
+    this.status = status;
+    this.code = code;
+    this.data = data;
+    this.isAuthError = status === 401 || status === 403;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _OmnikitError);
+    }
+  }
+  isNotFound() {
+    return this.status === 404;
+  }
+  isForbidden() {
+    return this.status === 403;
+  }
+  isUnauthorized() {
+    return this.status === 401;
+  }
+  isBadRequest() {
+    return this.status === 400;
+  }
+  isServerError() {
+    return this.status !== void 0 && this.status >= 500;
+  }
+};
+var getMetadataCacheKey = (appId) => `omnikit_metadata_${appId}`;
+var APIClient = class {
+  constructor(config) {
+    this.userToken = null;
+    this._serviceToken = null;
+    this._apiKey = null;
+    this.initialized = false;
+    this.initPromise = null;
+    this._collections = {};
+    this._services = {};
+    // New flat services
+    this._integrations = {};
+    // Callbacks for metadata updates (for React re-render triggers)
+    this._metadataListeners = /* @__PURE__ */ new Set();
+    // Callbacks for user state changes (for React auth state sync)
+    this._userListeners = /* @__PURE__ */ new Set();
+    this.appId = config.appId;
+    this.baseUrl = config.serverUrl || config.baseUrl || "http://localhost:8001/api";
+    this._serviceToken = config.serviceToken || null;
+    this._apiKey = config.apiKey || null;
+    const isBrowser2 = typeof window !== "undefined" && typeof localStorage !== "undefined";
+    this._metadata = this.loadCachedMetadata(config.initialMetadata);
+    if (isBrowser2) {
+      setAccessTokenKey(this.appId);
+    }
+    const autoInitAuth = config.autoInitAuth !== false;
+    if (config.token) {
+      this.userToken = config.token;
+      if (isBrowser2) {
+        saveAccessToken(config.token);
+      }
+    } else if (autoInitAuth && isBrowser2) {
+      const detectedToken = getAccessToken();
+      if (detectedToken) {
+        this.userToken = detectedToken;
+      }
+    }
+    this.ensureInitialized().catch((err) => {
+      console.warn("[Omnikit SDK] Background initialization failed:", err);
+    });
+  }
+  /**
+   * Load metadata from localStorage cache, falling back to initial config
+   * Guards localStorage access for Deno/Node compatibility
+   */
+  loadCachedMetadata(initialMetadata) {
+    if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+      try {
+        const cached = localStorage.getItem(getMetadataCacheKey(this.appId));
+        if (cached) {
+          const parsed = JSON.parse(cached);
+          return {
+            id: this.appId,
+            name: parsed.name || "",
+            logoUrl: parsed.logoUrl || "",
+            thumbnailUrl: parsed.thumbnailUrl || "",
+            visibility: parsed.visibility || "private",
+            platformAuthProviders: parsed.platformAuthProviders || ["google"]
+          };
+        }
+      } catch (e) {
+      }
+    }
+    return {
+      id: this.appId,
+      name: initialMetadata?.name || "",
+      logoUrl: initialMetadata?.logoUrl || "",
+      thumbnailUrl: initialMetadata?.thumbnailUrl || "",
+      visibility: "private",
+      // Default to private, updated after fetch
+      platformAuthProviders: ["google"]
+      // Default to Google only
+    };
+  }
+  /**
+   * Update metadata cache in localStorage
+   * IMPORTANT: Mutate in place to preserve object reference for exports
+   */
+  updateMetadataCache(data) {
+    this._metadata.name = data.name || this._metadata.name;
+    this._metadata.logoUrl = data.logoUrl || this._metadata.logoUrl;
+    this._metadata.thumbnailUrl = data.thumbnailUrl || this._metadata.thumbnailUrl;
+    this._metadata.visibility = data.visibility || this._metadata.visibility || "private";
+    this._metadata.platformAuthProviders = data.platformAuthProviders || this._metadata.platformAuthProviders || ["google"];
+    if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+      try {
+        localStorage.setItem(getMetadataCacheKey(this.appId), JSON.stringify(this._metadata));
+      } catch (e) {
+      }
+    }
+    this._metadataListeners.forEach((callback) => callback());
+  }
+  /**
+   * App metadata - available instantly without API call (no flicker!)
+   */
+  get metadata() {
+    return this._metadata;
+  }
+  /**
+   * Subscribe to metadata updates (for React components to trigger re-render)
+   * @returns Unsubscribe function
+   */
+  onMetadataChange(callback) {
+    this._metadataListeners.add(callback);
+    return () => this._metadataListeners.delete(callback);
+  }
+  /**
+   * Subscribe to user state changes (for React auth state sync)
+   * Called when user logs in, logs out, or updates profile
+   * @returns Unsubscribe function
+   */
+  onUserChange(callback) {
+    this._userListeners.add(callback);
+    return () => this._userListeners.delete(callback);
+  }
+  /**
+   * Emit user change event to all listeners
+   */
+  emitUserChange(user) {
+    this._userListeners.forEach((cb) => {
+      try {
+        cb(user);
+      } catch (e) {
+        console.error("[Omnikit SDK] User listener error:", e);
+      }
+    });
+  }
+  /**
+   * Lazy getter for collections - auto-initializes on first access
+   */
+  get collections() {
+    return this.createCollectionsProxy(false);
+  }
+  /**
+   * @deprecated Use collections instead. This alias exists for backward compatibility.
+   */
+  get entities() {
+    return this.collections;
+  }
+  /**
+   * Lazy getter for services (new flat structure) - auto-initializes on first access
+   * Usage: omnikit.services.SendEmail({ to, subject, body })
+   */
+  get services() {
+    return this.createServicesProxy(false);
+  }
+  /**
+   * @deprecated Use services instead for flat access
+   * Lazy getter for integrations - auto-initializes on first access
+   */
+  get integrations() {
+    return this.createIntegrationsProxy(false);
+  }
+  /**
+   * Lazy getter for auth - auto-initializes on first access
+   */
+  get auth() {
+    return this.createAuthProxy();
+  }
+  /**
+   * Lazy getter for service role operations
+   * Only available when serviceToken is provided
+   */
+  get asServiceRole() {
+    if (!this._serviceToken) {
+      throw new OmnikitError(
+        "Service token is required to use asServiceRole. Provide serviceToken in config.",
+        403,
+        "SERVICE_TOKEN_REQUIRED"
+      );
+    }
+    if (this._asServiceRole) {
+      return this._asServiceRole;
+    }
+    this._asServiceRole = {
+      collections: this.createCollectionsProxy(true),
+      // Service role collections
+      services: this.createServicesProxy(true),
+      // Service role services (new flat structure)
+      integrations: this.createIntegrationsProxy(true)
+      // Service role integrations (legacy)
+      // Note: auth not available in service role for security
+    };
+    return this._asServiceRole;
+  }
+  /**
+   * Create auth proxy that auto-initializes
+   */
+  createAuthProxy() {
+    const client = this;
+    const authHandler = {
+      async isAuthenticated() {
+        await client.ensureInitialized();
+        try {
+          const response = await client.makeRequest(
+            `${client.baseUrl}/auth/is-authenticated?app_id=${client.appId}`,
+            "GET"
+          );
+          return response?.authenticated === true;
+        } catch (error) {
+          return false;
+        }
+      },
+      async me() {
+        await client.ensureInitialized();
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/user/me`,
+          "GET"
+        );
+        client.emitUserChange(response);
+        return response;
+      },
+      login(returnUrl) {
+        const fullReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+        const encodedReturnUrl = encodeURIComponent(fullReturnUrl);
+        if (typeof window !== "undefined") {
+          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) {
+        return await client.makeRequest(
+          `${client.baseUrl}/auth/email/request-code`,
+          "POST",
+          { email, return_url: returnUrl }
+        );
+      },
+      /**
+       * Verify the login code and set the session token
+       */
+      async verifyLoginCode(email, code) {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/auth/email/verify-code`,
+          "POST",
+          { email, code }
+        );
+        if (response.access_token) {
+          client.setAuthToken(response.access_token);
+          try {
+            const user = await this.me();
+            client.emitUserChange(user);
+          } catch (e) {
+            client.emitUserChange(null);
+          }
+        }
+        return response;
+      },
+      /**
+       * Get available OAuth providers for this app
+       * Returns both platform providers (zero-config) and custom SSO providers
+       */
+      async getAvailableProviders() {
+        await client.ensureInitialized();
+        try {
+          const response = await client.makeRequest(
+            `${client.baseUrl}/apps/${client.appId}/auth/providers`,
+            "GET"
+          );
+          return response;
+        } catch (error) {
+          throw new OmnikitError(
+            "Failed to fetch available OAuth providers",
+            error.status || 500,
+            "PROVIDERS_FETCH_FAILED"
+          );
+        }
+      },
+      /**
+       * Initiate OAuth login with any provider
+       * 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();
+                  window.location.reload();
+                  return;
+                }
+                if (popup.closed) {
+                  clearInterval(checkTimer);
+                  const finalToken = getAccessToken();
+                  if (finalToken) {
+                    window.location.reload();
+                  }
+                }
+              }, 1e3);
+              return;
+            }
+          }
+          window.location.href = redirectUrl;
+        } else {
+          throw new OmnikitError("loginWithProvider() can only be called in browser environment", 400, "NOT_BROWSER");
+        }
+      },
+      /**
+       * Initiate Google OAuth Login
+       * @deprecated Use loginWithProvider("google", returnUrl) instead
+       * Redirects to the backend OAuth endpoint
+       */
+      loginWithGoogle(returnUrl) {
+        console.warn('loginWithGoogle() is deprecated. Use loginWithProvider("google", returnUrl) instead.');
+        this.loginWithProvider("google", returnUrl);
+      },
+      async logout() {
+        await client.makeRequest(
+          `${client.baseUrl}/auth/logout`,
+          "POST"
+        );
+        client.clearAuthToken();
+        client.emitUserChange(null);
+      },
+      async refreshToken() {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/auth/refresh`,
+          "POST"
+        );
+        if (response.access_token || response.token) {
+          const newToken = response.access_token || response.token;
+          client.setAuthToken(newToken);
+        }
+        return response;
+      },
+      async updateMe(data) {
+        await client.ensureInitialized();
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/user/me`,
+          "PUT",
+          data
+        );
+        client.emitUserChange(response);
+        return response;
+      },
+      // Alias for updateMe with clearer naming
+      async updateProfile(data) {
+        return this.updateMe(data);
+      },
+      // Backward compatibility
+      async getCurrentUser() {
+        return this.me();
+      },
+      // Subscribe to user state changes (for React auth state sync)
+      onUserChange(callback) {
+        return client.onUserChange(callback);
+      }
+    };
+    return authHandler;
+  }
+  /**
+   * Convert PascalCase to snake_case
+   * Example: PdfDocument -> pdf_document, UserProfile -> user_profile
+   */
+  toSnakeCase(str) {
+    return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  }
+  /**
+   * Create collections proxy that auto-initializes
+   * @param useServiceToken - Whether to use service token for requests
+   */
+  createCollectionsProxy(useServiceToken) {
+    const client = this;
+    return new Proxy({}, {
+      get(target, collectionName) {
+        if (typeof collectionName === "string" && !collectionName.startsWith("_")) {
+          return new Proxy({}, {
+            get(obj, method) {
+              if (typeof method === "string") {
+                return async function(...args) {
+                  await client.ensureInitialized();
+                  const normalizedCollectionName = client.toSnakeCase(collectionName);
+                  const collection = client._collections[normalizedCollectionName];
+                  if (!collection) {
+                    throw new OmnikitError(
+                      `Collection '${collectionName}' not found in app schema`,
+                      404,
+                      "COLLECTION_NOT_FOUND"
+                    );
+                  }
+                  if (typeof collection[method] !== "function") {
+                    const availableMethods = [
+                      "get(id)",
+                      "list(options?)",
+                      "filter(filters?)",
+                      "findOne(filters?)",
+                      "create(data)",
+                      "update(id, data)",
+                      "delete(id)",
+                      "count(filters?)",
+                      "bulkCreate(items)",
+                      "bulkDelete(ids)",
+                      "import(file, format)",
+                      "deleteAll(confirm)"
+                    ];
+                    throw new OmnikitError(
+                      `Method '${method}()' does not exist on collection '${collectionName}'.
+
+Available methods:
+${availableMethods.map((m) => `  - ${m}`).join("\n")}
+
+Common mistake: There is NO 'read()' method. Use 'list()' instead.
+Example: await ${collectionName}.list({ limit: 100, sort: '-created_at' })`,
+                      400,
+                      "METHOD_NOT_FOUND"
+                    );
+                  }
+                  if (useServiceToken) {
+                    const originalGetToken = client.getAuthToken.bind(client);
+                    client.getAuthToken = () => client._serviceToken;
+                    try {
+                      const result = await collection[method](...args);
+                      client.getAuthToken = originalGetToken;
+                      return result;
+                    } catch (error) {
+                      client.getAuthToken = originalGetToken;
+                      throw error;
+                    }
+                  } else {
+                    return collection[method](...args);
+                  }
+                };
+              }
+              return void 0;
+            }
+          });
+        }
+        return target[collectionName];
+      }
+    });
+  }
+  /**
+   * Poll for job completion with progress callbacks
+   * @param jobId - Job ID to poll
+   * @param options - Async options (onStatusChange, pollInterval, timeout)
+   * @returns Final job result
+   */
+  async pollJobUntilComplete(jobId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 3e5;
+    const startTime = Date.now();
+    while (true) {
+      const status = await this.makeRequest(
+        `${this.baseUrl}/apps/${this.appId}/jobs/${jobId}`,
+        "GET"
+      );
+      if (options?.onStatusChange) {
+        options.onStatusChange(status.status, status.status_message);
+      }
+      if (status.status === "completed") {
+        return status.result;
+      }
+      if (status.status === "failed") {
+        throw new OmnikitError(
+          status.error || "Job failed",
+          500,
+          "JOB_FAILED",
+          { job_id: jobId, status }
+        );
+      }
+      if (status.status === "cancelled") {
+        throw new OmnikitError(
+          "Job was cancelled",
+          400,
+          "JOB_CANCELLED",
+          { job_id: jobId }
+        );
+      }
+      if (Date.now() - startTime > timeout) {
+        throw new OmnikitError(
+          `Job timed out after ${timeout / 1e3} seconds`,
+          408,
+          "JOB_TIMEOUT",
+          { job_id: jobId }
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+  /**
+   * Stream LLM response token by token via SSE
+   * @param params - LLM request parameters with streaming callbacks
+   * @returns Promise that resolves to the complete response string
+   */
+  async streamLLMResponse(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 = {
+      ...params,
+      stream: true,
+      // Map friendly model names to full model names
+      model: mapLLMModel(params.model),
+      // Remove callback functions from request body
+      onToken: void 0,
+      onComplete: void 0,
+      onError: void 0
+    };
+    Object.keys(requestBody).forEach((key) => {
+      if (requestBody[key] === void 0) {
+        delete requestBody[key];
+      }
+    });
+    const response = await fetch(
+      `${this.baseUrl}/apps/${this.appId}/services/llm`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = `LLM streaming 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, "STREAM_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 = "";
+    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 === "done") {
+                params.onComplete?.({
+                  result: event.result || fullResponse,
+                  model_used: event.model_used || "",
+                  usage: event.usage
+                });
+              } else if (event.type === "error") {
+                const err = new OmnikitError(
+                  event.message || "Stream error",
+                  500,
+                  "STREAM_ERROR"
+                );
+                params.onError?.(err);
+                throw err;
+              }
+            } catch (parseError) {
+              if (parseError instanceof OmnikitError) {
+                throw parseError;
+              }
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return fullResponse;
+  }
+  /**
+   * Create services proxy that auto-initializes (new flat structure)
+   * @param useServiceToken - Whether to use service token for requests
+   */
+  createServicesProxy(useServiceToken) {
+    const client = this;
+    return new Proxy({}, {
+      get(target, serviceName) {
+        if (typeof serviceName === "string" && !serviceName.startsWith("_")) {
+          if (serviceName === "CheckJobStatus") {
+            return async function(params) {
+              await client.ensureInitialized();
+              if (!params?.job_id) {
+                throw new OmnikitError(
+                  "job_id is required for CheckJobStatus",
+                  400,
+                  "MISSING_JOB_ID"
+                );
+              }
+              return client.makeRequest(
+                `${client.baseUrl}/apps/${client.appId}/jobs/${params.job_id}`,
+                "GET"
+              );
+            };
+          }
+          if (serviceName === "DownloadPrivateFile") {
+            return async function(params) {
+              await client.ensureInitialized();
+              if (!params?.file_uri) {
+                throw new OmnikitError(
+                  "file_uri is required for DownloadPrivateFile",
+                  400,
+                  "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 token = client.getAuthToken();
+              if (token) {
+                downloadUrl.searchParams.set("token", token);
+              }
+              window.open(downloadUrl.toString(), "_blank");
+            };
+          }
+          return async function(params, asyncOptions) {
+            await client.ensureInitialized();
+            if (serviceName === "InvokeLLM") {
+              if (params?.model) {
+                params = { ...params, model: mapLLMModel(params.model) };
+              }
+              if (params?.stream) {
+                return client.streamLLMResponse(params);
+              }
+            }
+            const method = client._services[serviceName];
+            if (!method) {
+              throw new OmnikitError(
+                `Service '${serviceName}' not found. Available services: ${Object.keys(client._services).join(", ")}`,
+                404,
+                "SERVICE_NOT_FOUND"
+              );
+            }
+            const response = await method(params, useServiceToken);
+            if (response && response.async && response.job_id) {
+              if (asyncOptions?.returnJobId) {
+                return response;
+              }
+              return client.pollJobUntilComplete(response.job_id, asyncOptions);
+            }
+            return response;
+          };
+        }
+        return target[serviceName];
+      }
+    });
+  }
+  /**
+   * @deprecated Use createServicesProxy instead
+   * Create integrations proxy that auto-initializes
+   * @param useServiceToken - Whether to use service token for requests
+   */
+  createIntegrationsProxy(useServiceToken) {
+    const client = this;
+    return new Proxy({}, {
+      get(target, packageName) {
+        if (typeof packageName === "string" && !packageName.startsWith("_")) {
+          return new Proxy({}, {
+            get(obj, methodName) {
+              if (typeof methodName === "string") {
+                if (methodName === "CheckJobStatus") {
+                  return async function(params) {
+                    await client.ensureInitialized();
+                    if (!params?.job_id) {
+                      throw new OmnikitError(
+                        "job_id is required for CheckJobStatus",
+                        400,
+                        "MISSING_JOB_ID"
+                      );
+                    }
+                    return client.makeRequest(
+                      `${client.baseUrl}/apps/${client.appId}/jobs/${params.job_id}`,
+                      "GET"
+                    );
+                  };
+                }
+                return async function(params, asyncOptions) {
+                  await client.ensureInitialized();
+                  if (methodName === "InvokeLLM") {
+                    if (params?.model) {
+                      params = { ...params, model: mapLLMModel(params.model) };
+                    }
+                  }
+                  const integrationPackage = client._integrations[packageName];
+                  if (!integrationPackage) {
+                    throw new OmnikitError(
+                      `Integration package '${packageName}' not found`,
+                      404,
+                      "INTEGRATION_NOT_FOUND"
+                    );
+                  }
+                  const method = integrationPackage[methodName];
+                  if (!method) {
+                    throw new OmnikitError(
+                      `Integration method '${methodName}' not found in package '${packageName}'`,
+                      404,
+                      "INTEGRATION_METHOD_NOT_FOUND"
+                    );
+                  }
+                  const response = await method(params, useServiceToken);
+                  if (response && response.async && response.job_id) {
+                    if (asyncOptions?.returnJobId) {
+                      return response;
+                    }
+                    return client.pollJobUntilComplete(response.job_id, asyncOptions);
+                  }
+                  return response;
+                };
+              }
+              return void 0;
+            }
+          });
+        }
+        return target[packageName];
+      }
+    });
+  }
+  /**
+   * Ensure SDK is initialized (auto-initializes once on first call)
+   */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.initialize();
+    await this.initPromise;
+    this.initPromise = null;
+  }
+  /**
+   * Initialize SDK by fetching app schema and integration endpoints
+   * This happens automatically on first use - no need to call explicitly
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      const [appSchema, integrationSchema] = await Promise.all([
+        this.fetchAppSchema(),
+        this.fetchIntegrationSchema()
+      ]);
+      if (appSchema.app) {
+        this.updateMetadataCache({
+          name: appSchema.app.name,
+          logoUrl: appSchema.app.logo_url,
+          thumbnailUrl: appSchema.app.thumbnail_url,
+          visibility: appSchema.app.visibility,
+          platformAuthProviders: appSchema.app.platform_auth_providers
+        });
+      }
+      if (appSchema.entities) {
+        this.createCollections(appSchema.entities);
+      }
+      if (integrationSchema && "services" in integrationSchema) {
+        this.createServicesFromSchema(integrationSchema);
+      } else if (integrationSchema && "installed_packages" in integrationSchema) {
+        this.createIntegrationsFromSchema(integrationSchema);
+      }
+      this.initialized = true;
+    } catch (error) {
+      console.error("Failed to initialize Omnikit SDK:", error);
+      throw new OmnikitError(
+        `SDK initialization failed: ${error.message}`,
+        500,
+        "INIT_FAILED",
+        error
+      );
+    }
+  }
+  /**
+   * Fetch app schema from backend
+   */
+  async fetchAppSchema() {
+    const response = await fetch(`${this.baseUrl}/apps/${this.appId}`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch app schema: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Fetch integration schema from backend
+   * Returns ServicesSchema (new flat format) or IntegrationSchema (legacy)
+   */
+  async fetchIntegrationSchema() {
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/apps/${this.appId}/services`
+      );
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Create collection classes from schema
+   */
+  createCollections(collectionsData) {
+    const collections = Array.isArray(collectionsData) ? collectionsData.reduce((acc, collection) => ({ ...acc, [collection.name]: collection }), {}) : collectionsData;
+    Object.entries(collections).forEach(([collectionName, collectionDef]) => {
+      this._collections[collectionName.toLowerCase()] = this.createCollectionClass(collectionName, collectionDef);
+    });
+  }
+  /**
+   * Create a single collection class with all CRUD operations
+   * Automatically enhances User collection with convenience methods
+   */
+  createCollectionClass(collectionName, collectionDef) {
+    const client = this;
+    const isUserCollection = collectionName.toLowerCase() === "user";
+    const baseCollection = {
+      // Get single record by ID
+      async get(id) {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/${id}`,
+          "GET"
+        );
+        return response;
+      },
+      // List all records with MongoDB/Mongoose-style filtering
+      async list(...args) {
+        const queryParams = new URLSearchParams();
+        let filter;
+        let options;
+        if (args.length === 0) {
+          filter = void 0;
+          options = void 0;
+        } else if (args.length === 1) {
+          const arg = args[0];
+          if (arg && (arg.q !== void 0 || arg.sort !== void 0 || arg.limit !== void 0 || arg.offset !== void 0 || arg._count !== void 0)) {
+            Object.entries(arg).forEach(([key, value]) => {
+              if (value !== void 0 && value !== null) {
+                queryParams.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+              }
+            });
+          } else {
+            filter = arg;
+            options = void 0;
+          }
+        } else if (args.length === 2) {
+          [filter, options] = args;
+        }
+        if (filter !== void 0 || options !== void 0) {
+          if (filter && Object.keys(filter).length > 0) {
+            queryParams.append("q", JSON.stringify(filter));
+          }
+          if (options) {
+            if (options.sort !== void 0) {
+              let sortString;
+              if (typeof options.sort === "object") {
+                const sortField = Object.keys(options.sort)[0];
+                const sortOrder = options.sort[sortField];
+                sortString = sortOrder === -1 ? `-${sortField}` : sortField;
+              } else {
+                sortString = options.sort;
+              }
+              queryParams.append("sort", sortString);
+            }
+            if (options.limit !== void 0) {
+              queryParams.append("limit", String(options.limit));
+            }
+            if (options.offset !== void 0) {
+              queryParams.append("offset", String(options.offset));
+            }
+          }
+        }
+        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 : []);
+      },
+      // Filter records by query (alias for list)
+      async filter(...args) {
+        return this.list(...args);
+      },
+      // Find single record matching query
+      async findOne(...args) {
+        if (args.length === 0) {
+          const results = await this.list({}, { limit: 1 });
+          return results[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;
+          } else {
+            const results = await this.list(arg, { limit: 1 });
+            return results[0] || null;
+          }
+        } else {
+          const [filter, options] = args;
+          const results = await this.list(filter, { ...options, limit: 1 });
+          return results[0] || null;
+        }
+      },
+      // Create new record
+      async create(data) {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}`,
+          "POST",
+          data
+        );
+        return response;
+      },
+      // Update existing record (overridden for User collection)
+      async update(...args) {
+        if (isUserCollection) {
+          if (args.length === 1) {
+            const response = await client.makeRequest(
+              `${client.baseUrl}/apps/${client.appId}/collections/user/me`,
+              "PUT",
+              args[0]
+            );
+            return response;
+          } else if (args.length === 2) {
+            const [id, data] = args;
+            const response = await client.makeRequest(
+              `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/${id}`,
+              "PATCH",
+              data
+            );
+            return response;
+          } else {
+            throw new OmnikitError(
+              "User.update() expects 1 argument (current user data) or 2 arguments (id, data)",
+              400,
+              "INVALID_ARGUMENTS"
+            );
+          }
+        } else {
+          const [id, data] = args;
+          const response = await client.makeRequest(
+            `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/${id}`,
+            "PATCH",
+            data
+          );
+          return response;
+        }
+      },
+      // Delete record by ID
+      async delete(id) {
+        await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/${id}`,
+          "DELETE"
+        );
+        return true;
+      },
+      // Count records matching query
+      async count(...args) {
+        const queryParams = new URLSearchParams();
+        if (args.length === 0) {
+          queryParams.append("_count", "true");
+        } else if (args.length === 1) {
+          const arg = args[0];
+          if (arg && (arg.q !== void 0 || arg.sort !== void 0)) {
+            Object.entries(arg).forEach(([key, value]) => {
+              if (value !== void 0 && value !== null) {
+                queryParams.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+              }
+            });
+          } else {
+            if (arg && Object.keys(arg).length > 0) {
+              queryParams.append("q", JSON.stringify(arg));
+            }
+          }
+          queryParams.append("_count", "true");
+        } else if (args.length === 2) {
+          const [filter] = args;
+          if (filter && Object.keys(filter).length > 0) {
+            queryParams.append("q", JSON.stringify(filter));
+          }
+          queryParams.append("_count", "true");
+        }
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}?${queryParams}`,
+          "GET"
+        );
+        return response.total || response.count || 0;
+      },
+      // Bulk create multiple records
+      async bulkCreate(items) {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/bulk`,
+          "POST",
+          { items }
+        );
+        return response;
+      },
+      // Bulk delete multiple records by ID
+      async bulkDelete(ids) {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/bulk-delete`,
+          "POST",
+          ids
+        );
+        return response;
+      },
+      // Import records from CSV or JSON file
+      async import(file, format) {
+        const formData = new FormData();
+        formData.append("file", file);
+        formData.append("format", format);
+        const response = await client.makeRequestWithFormData(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}/import`,
+          formData
+        );
+        return response;
+      },
+      // Delete all records (requires explicit confirmation)
+      async deleteAll(confirm) {
+        if (!confirm) {
+          throw new OmnikitError(
+            "deleteAll requires explicit confirmation. Pass true to confirm.",
+            400,
+            "CONFIRMATION_REQUIRED"
+          );
+        }
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/${collectionName}?confirm=true`,
+          "DELETE"
+        );
+        return response;
+      },
+      // Backward compatibility: findById → get
+      async findById(id) {
+        console.warn("findById() is deprecated. Use get() instead.");
+        return this.get(id);
+      }
+    };
+    if (isUserCollection) {
+      baseCollection.me = async () => {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/user/me`,
+          "GET"
+        );
+        return response;
+      };
+      baseCollection.updateMe = async (data) => {
+        const response = await client.makeRequest(
+          `${client.baseUrl}/apps/${client.appId}/collections/user/me`,
+          "PUT",
+          data
+        );
+        return response;
+      };
+    }
+    return baseCollection;
+  }
+  /**
+   * Create services from new flat schema (recommended)
+   * Services are exposed as omnikit.services.ServiceName
+   */
+  createServicesFromSchema(schema) {
+    schema.services.forEach((service) => {
+      this._services[service.name] = this.createServiceMethod(service);
+    });
+    this._integrations["BuiltIn"] = {};
+    schema.services.forEach((service) => {
+      this._integrations["BuiltIn"][service.name] = this._services[service.name];
+    });
+  }
+  /**
+   * Create a service method from ServiceDefinition
+   */
+  createServiceMethod(service) {
+    const client = this;
+    const { path, method = "POST", path_params } = service;
+    return async (params, useServiceToken) => {
+      let normalizedParams = params;
+      if (params instanceof File) {
+        console.warn("[Omnikit SDK] UploadFile called with File directly. Auto-wrapping to { file }. Please use UploadFile({ file }) for best practice.");
+        normalizedParams = { file: params };
+      }
+      let finalPath = path;
+      const remainingParams = { ...normalizedParams };
+      if (path_params && path_params.length > 0 && normalizedParams) {
+        path_params.forEach((paramName) => {
+          if (normalizedParams[paramName] !== void 0) {
+            finalPath = finalPath.replace(`{${paramName}}`, String(normalizedParams[paramName]));
+            delete remainingParams[paramName];
+          }
+        });
+      }
+      const fullUrl = `${client.baseUrl}/apps/${client.appId}${finalPath}`;
+      if (remainingParams && remainingParams.file instanceof File) {
+        return client.handleFileUpload(remainingParams.file, path, useServiceToken);
+      }
+      const response = await client.makeRequest(
+        fullUrl,
+        method,
+        method === "GET" ? void 0 : remainingParams,
+        {
+          useServiceToken,
+          queryParams: method === "GET" ? remainingParams : void 0
+        }
+      );
+      return client.normalizeIntegrationResponse(response, path);
+    };
+  }
+  /**
+   * Handle file upload via presigned URL flow
+   * Supports both public and private file uploads based on path
+   */
+  async handleFileUpload(file, path, useServiceToken) {
+    const isPrivate = path.includes("/files/private");
+    const initEndpoint = isPrivate ? "/services/files/private/init" : "/services/files/init";
+    const completeEndpoint = isPrivate ? "/services/files/private/complete" : "/services/files/complete";
+    const initResponse = await this.makeRequest(
+      `${this.baseUrl}/apps/${this.appId}${initEndpoint}`,
+      "POST",
+      {
+        filename: file.name,
+        content_type: file.type || "application/octet-stream",
+        size: file.size
+      },
+      { useServiceToken }
+    );
+    const { file_id, upload_url } = initResponse;
+    const uploadResponse = await fetch(upload_url, {
+      method: "PUT",
+      body: file,
+      headers: {
+        "Content-Type": file.type || "application/octet-stream"
+      }
+    });
+    if (!uploadResponse.ok) {
+      throw new OmnikitError(
+        `Failed to upload file to storage: ${uploadResponse.statusText}`,
+        uploadResponse.status,
+        "UPLOAD_FAILED"
+      );
+    }
+    const completeResponse = await this.makeRequest(
+      `${this.baseUrl}/apps/${this.appId}${completeEndpoint}/${file_id}`,
+      "POST",
+      null,
+      { useServiceToken }
+    );
+    if (isPrivate) {
+      return completeResponse;
+    }
+    return this.normalizeIntegrationResponse(completeResponse, path);
+  }
+  /**
+   * @deprecated Use createServicesFromSchema instead
+   * Create integration methods from legacy backend schema
+   */
+  createIntegrationsFromSchema(schema) {
+    schema.installed_packages.forEach((pkg) => {
+      const packageName = pkg.package_name;
+      this._integrations[packageName] = {};
+      pkg.endpoints.forEach((endpoint) => {
+        const methodName = this.formatMethodName(endpoint.name);
+        this._integrations[packageName][methodName] = this.createIntegrationMethod(endpoint);
+        this._services[methodName] = this._integrations[packageName][methodName];
+      });
+    });
+  }
+  /**
+   * @deprecated Backend now returns final method names
+   * Format endpoint name to PascalCase method name (legacy)
+   */
+  formatMethodName(name) {
+    const methodMap = {
+      "email": "SendEmail",
+      "llm": "InvokeLLM",
+      "files": "UploadFile",
+      "files/private": "UploadPrivateFile",
+      "files/signed-url": "CreateFileSignedUrl",
+      "images": "GenerateImage",
+      "speech": "GenerateSpeech",
+      "video": "GenerateVideo",
+      "video_status": "CheckVideoStatus",
+      "extract-text": "ExtractData",
+      "extract-text_status": "CheckExtractStatus",
+      "sms": "SendSMS"
+    };
+    return methodMap[name] || name.charAt(0).toUpperCase() + name.slice(1);
+  }
+  /**
+   * Create integration method that calls backend endpoint
+   */
+  createIntegrationMethod(endpoint) {
+    const client = this;
+    const { path, method = "POST", path_params = [] } = endpoint;
+    return async (params, useServiceToken) => {
+      let normalizedParams = params;
+      if (params instanceof File) {
+        console.warn("[Omnikit SDK] UploadFile called with File directly. Auto-wrapping to { file }. Please use UploadFile({ file }) for best practice.");
+        normalizedParams = { file: params };
+      }
+      let finalPath = path;
+      const remainingParams = { ...normalizedParams };
+      if (path_params && path_params.length > 0 && normalizedParams) {
+        path_params.forEach((paramName) => {
+          if (normalizedParams[paramName] !== void 0) {
+            finalPath = finalPath.replace(`{${paramName}}`, String(normalizedParams[paramName]));
+            delete remainingParams[paramName];
+          }
+        });
+      }
+      const fullUrl = `${client.baseUrl}/apps/${client.appId}${finalPath}`;
+      if (path.includes("/services/files/private") && remainingParams && remainingParams.file instanceof File) {
+        const file = remainingParams.file;
+        try {
+          const initResponse = await client.makeRequest(
+            `${client.baseUrl}/apps/${client.appId}/services/files/private/init`,
+            "POST",
+            {
+              filename: file.name,
+              content_type: file.type || "application/octet-stream",
+              size: file.size
+            },
+            { useServiceToken }
+          );
+          const { file_id, upload_url, file_uri } = initResponse;
+          const uploadResponse = await fetch(upload_url, {
+            method: "PUT",
+            body: file,
+            headers: {
+              "Content-Type": file.type || "application/octet-stream"
+            }
+          });
+          if (!uploadResponse.ok) {
+            throw new OmnikitError(
+              `Failed to upload private file to storage: ${uploadResponse.statusText}`,
+              uploadResponse.status,
+              "UPLOAD_FAILED"
+            );
+          }
+          const completeResponse = await client.makeRequest(
+            `${client.baseUrl}/apps/${client.appId}/services/files/private/complete/${file_id}`,
+            "POST",
+            null,
+            { useServiceToken }
+          );
+          return completeResponse;
+        } catch (error) {
+          if (error instanceof OmnikitError) {
+            throw error;
+          }
+          throw new OmnikitError(
+            `Private file upload failed: ${error.message}`,
+            500,
+            "UPLOAD_ERROR",
+            error
+          );
+        }
+      }
+      if (remainingParams && remainingParams.file instanceof File) {
+        const file = remainingParams.file;
+        try {
+          const initResponse = await client.makeRequest(
+            `${client.baseUrl}/apps/${client.appId}/services/files/init`,
+            "POST",
+            {
+              filename: file.name,
+              content_type: file.type || "application/octet-stream",
+              size: file.size
+            },
+            { useServiceToken }
+          );
+          const { file_id, upload_url, public_url } = initResponse;
+          const uploadResponse = await fetch(upload_url, {
+            method: "PUT",
+            body: file,
+            headers: {
+              "Content-Type": file.type || "application/octet-stream"
+            }
+          });
+          if (!uploadResponse.ok) {
+            throw new OmnikitError(
+              `Failed to upload file to storage: ${uploadResponse.statusText}`,
+              uploadResponse.status,
+              "UPLOAD_FAILED"
+            );
+          }
+          const completeResponse = await client.makeRequest(
+            `${client.baseUrl}/apps/${client.appId}/services/files/complete/${file_id}`,
+            "POST",
+            null,
+            { useServiceToken }
+          );
+          return client.normalizeIntegrationResponse(completeResponse, path);
+        } catch (error) {
+          if (error instanceof OmnikitError) {
+            throw error;
+          }
+          throw new OmnikitError(
+            `File upload failed: ${error.message}`,
+            500,
+            "UPLOAD_ERROR",
+            error
+          );
+        }
+      }
+      const response = await client.makeRequest(
+        fullUrl,
+        method,
+        method === "GET" ? null : remainingParams,
+        { useServiceToken }
+      );
+      return client.normalizeIntegrationResponse(response, path);
+    };
+  }
+  /**
+   * Normalize integration response to add common aliases for bulletproof access
+   * Prevents runtime errors from AI-generated code using wrong property names
+   */
+  normalizeIntegrationResponse(response, path) {
+    if (!response || typeof response !== "object") {
+      return response;
+    }
+    const normalized = { ...response };
+    if (path.includes("/services/llm") && "result" in normalized && !("content" in normalized)) {
+      Object.defineProperty(normalized, "content", {
+        get() {
+          return this.result;
+        },
+        enumerable: false
+        // Don't show in JSON.stringify or Object.keys
+      });
+    }
+    if (path.includes("/services/files") && "file_url" in normalized && !("url" in normalized)) {
+      Object.defineProperty(normalized, "url", {
+        get() {
+          return this.file_url;
+        },
+        enumerable: false
+      });
+    }
+    if (path.includes("/services/speech") && "url" in normalized && !("audio_url" in normalized)) {
+      Object.defineProperty(normalized, "audio_url", {
+        get() {
+          return this.url;
+        },
+        enumerable: false
+      });
+    }
+    if (path.includes("/services/extract") && "results" in normalized && Array.isArray(normalized.results)) {
+      if (!("text" in normalized)) {
+        Object.defineProperty(normalized, "text", {
+          get() {
+            const firstSuccess = this.results?.find((r) => r.success);
+            return firstSuccess?.text || "";
+          },
+          enumerable: false
+        });
+      }
+    }
+    return normalized;
+  }
+  /**
+   * HTTP request helper with JSON
+   */
+  async makeRequest(url, method = "GET", data = null, options) {
+    let finalUrl = url;
+    if (options?.queryParams && Object.keys(options.queryParams).length > 0) {
+      const searchParams = new URLSearchParams();
+      Object.entries(options.queryParams).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+    const fetchOptions = {
+      method,
+      headers: {
+        "Content-Type": "application/json"
+      }
+      // Removed credentials: 'include' to prevent sending cookies (switching to pure Bearer token)
+    };
+    const userToken = this.getAuthToken();
+    if (userToken) {
+      fetchOptions.headers.Authorization = `Bearer ${userToken}`;
+    }
+    if (this._serviceToken) {
+      fetchOptions.headers["X-Service-Token"] = this._serviceToken;
+    }
+    if (this._apiKey) {
+      fetchOptions.headers["X-API-Key"] = this._apiKey;
+    }
+    if (options?.headers) {
+      Object.assign(fetchOptions.headers, options.headers);
+    }
+    if (data && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      fetchOptions.body = JSON.stringify(data);
+    }
+    const response = await fetch(finalUrl, fetchOptions);
+    if (response.status === 401) {
+      this.clearAuthToken();
+      throw new OmnikitError(
+        "Authentication required or token expired",
+        401,
+        "UNAUTHORIZED"
+      );
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new OmnikitError(
+        error.detail || error.message || `HTTP ${response.status}: ${response.statusText}`,
+        response.status,
+        error.code || "HTTP_ERROR",
+        error
+      );
+    }
+    if (response.status === 204 || method === "DELETE") {
+      return null;
+    }
+    return await response.json();
+  }
+  /**
+   * HTTP request helper with FormData (for file uploads)
+   */
+  async makeRequestWithFormData(url, formData, useServiceToken) {
+    const fetchOptions = {
+      method: "POST",
+      body: formData,
+      headers: {}
+      // Removed credentials: 'include'
+    };
+    const userToken = this.getAuthToken();
+    if (userToken) {
+      fetchOptions.headers.Authorization = `Bearer ${userToken}`;
+    }
+    if (this._serviceToken) {
+      fetchOptions.headers["X-Service-Token"] = this._serviceToken;
+    }
+    if (this._apiKey) {
+      fetchOptions.headers["X-API-Key"] = this._apiKey;
+    }
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new OmnikitError(
+        error.detail || error.message || `HTTP ${response.status}: ${response.statusText}`,
+        response.status,
+        error.code || "HTTP_ERROR",
+        error
+      );
+    }
+    return await response.json();
+  }
+  /**
+   * Get app metadata (for internal use)
+   */
+  async getAppMetadata() {
+    const response = await this.makeRequest(
+      `${this.baseUrl}/apps/${this.appId}`,
+      "GET"
+    );
+    if (response?.app || response?.name) {
+      const app = response.app || response;
+      this.updateMetadataCache({
+        name: app.name,
+        logoUrl: app.logo_url,
+        thumbnailUrl: app.thumbnail_url
+      });
+    }
+    return response;
+  }
+  /**
+   * Set auth token
+   */
+  setAuthToken(token) {
+    this.userToken = token;
+    saveAccessToken(token);
+  }
+  /**
+   * Get current auth token
+   */
+  getAuthToken() {
+    return this.userToken;
+  }
+  /**
+   * Clear auth token
+   */
+  clearAuthToken() {
+    this.userToken = null;
+    removeAccessToken();
+  }
+  /**
+   * Create a live voice session for real-time voice conversation with AI.
+   *
+   * The session manages WebSocket communication, microphone capture, and audio playback.
+   *
+   * @example
+   * ```typescript
+   * const session = omnikit.createLiveVoiceSession({
+   *   systemInstruction: 'You are a helpful assistant.',
+   *   voice: 'Puck',
+   *   onTranscript: (text, role) => console.log(`${role}: ${text}`),
+   *   onStatusChange: (status) => console.log(`Status: ${status}`),
+   *   onError: (error) => console.error(error),
+   * });
+   *
+   * await session.start();
+   * // ... user speaks, AI responds ...
+   * await session.stop();
+   * ```
+   *
+   * @param config - Optional configuration for the voice session
+   * @returns A LiveVoiceSession object to control the session
+   */
+  createLiveVoiceSession(config) {
+    return new LiveVoiceSessionImpl(
+      this.baseUrl,
+      this.appId,
+      this.getAuthToken(),
+      config
+    );
+  }
+  /**
+   * Invoke a backend function by name.
+   *
+   * Backend functions are deployed to Supabase Edge Functions and can be invoked
+   * from the frontend using this method.
+   *
+   * @example
+   * ```typescript
+   * // Invoke a function
+   * const result = await omnikit.invokeFunction('processPayment', {
+   *   amount: 100,
+   *   userId: 'abc123'
+   * });
+   * console.log(result.transactionId); // Direct access to function response
+   * ```
+   *
+   * @param functionName - Name of the function to invoke (matches filename without .js)
+   * @param body - Optional request body to send to the function
+   * @returns Response data from the function (unwrapped)
+   * @throws Error if the function invocation fails
+   */
+  async invokeFunction(functionName, body) {
+    await this.ensureInitialized();
+    const response = await this.makeRequest(
+      `${this.baseUrl}/apps/${this.appId}/functions/invoke/${functionName}`,
+      "POST",
+      { body }
+    );
+    if (response && typeof response === "object") {
+      if (response.success === false && response.error) {
+        throw new Error(response.error);
+      }
+      if ("data" in response) {
+        return response.data;
+      }
+    }
+    return response;
+  }
+};
+function createClient(config) {
+  return new APIClient(config);
+}
+
+exports.APIClient = APIClient;
+exports.LiveVoiceSessionImpl = LiveVoiceSessionImpl;
+exports.OmnikitError = OmnikitError;
+exports.cleanTokenFromUrl = cleanTokenFromUrl;
+exports.createClient = createClient;
+exports.getAccessToken = getAccessToken;
+exports.isTokenInUrl = isTokenInUrl;
+exports.removeAccessToken = removeAccessToken;
+exports.saveAccessToken = saveAccessToken;
+exports.setAccessToken = setAccessToken;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map