@aippy/runtime 0.2.4 → 0.2.5-dev.1

package/README.md

@@ -87,12 +87,46 @@ button.onclick = async () => {
 };
 ```
 
+### AI (Backend Proxy Adapter)
+
+```typescript
+// Default base URL: https://api.aippy.dev/api/aisdk/v1
+
+import { streamText, experimental_generateImage as generateImage } from 'ai';
+import { aippy } from '@aippy/runtime/ai';
+
+// Create provider (reads from env vars automatically)
+const provider = aippy();
+
+// Or override with config
+// const provider = aippy({ baseUrl: '...', userToken: '...' });
+
+// Streaming text generation (uses Vercel AI SDK)
+const result = await streamText({
+  model: provider('gpt'),
+  prompt: 'Write a haiku about TypeScript.',
+});
+
+for await (const chunk of result.textStream) {
+  console.log(chunk);
+}
+
+// Image generation
+const image = await generateImage({
+  model: provider.image('dall-e-3'),
+  prompt: 'A sunset over mountains',
+});
+
+console.log(image.image?.base64);
+```
+
 ## Packages
 
 - `@aippy/runtime/core` - Core types and configuration
 - `@aippy/runtime/device` - Device APIs (camera, geolocation, sensors, file system)
 - `@aippy/runtime/utils` - Platform detection, performance monitoring, PWA utilities
 - `@aippy/runtime/audio` - iOS-compatible Web Audio API wrapper
+- `@aippy/runtime/ai` - AI SDK adapter wrapping `ai` package, routes through backend proxy
 
 ## Publishing
 

package/dist/ai/errors.d.ts

@@ -0,0 +1,21 @@
+import { AISDKError } from 'ai';
+/**
+ * Normalizes a backend error response into an AISDKError.
+ */
+export declare function normalizeError(response: Response, body?: unknown): AISDKError;
+/**
+ * Creates an error for missing user token.
+ */
+export declare function missingTokenError(): AISDKError;
+/**
+ * Creates an error for aborted requests.
+ */
+export declare function abortedError(): AISDKError;
+/**
+ * Creates an error for network failures.
+ */
+export declare function networkError(cause?: unknown): AISDKError;
+/**
+ * Creates an error for parse failures.
+ */
+export declare function parseError(message: string): AISDKError;

package/dist/ai/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @aippy/runtime/ai - AI module for Aippy Runtime SDK
+ *
+ * This module provides two integration paths with Vercel AI SDK:
+ *
+ * ## Path 1: OpenAI-Compatible Provider (AI SDK Core)
+ *
+ * Use `aippy()` provider with AI SDK Core functions:
+ * - generateText / streamText
+ * - generateObject / streamObject
+ * - embed / embedMany
+ * - generateImage
+ *
+ * ```ts
+ * import { streamText } from 'ai';
+ * import { aippy } from '@aippy/runtime/ai';
+ *
+ * const provider = aippy();
+ * const result = await streamText({
+ *   model: provider('gpt-5'),
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ *
+ * ## Path 2: Data Stream Protocol (AI SDK UI / @ai-sdk/react)
+ *
+ * Use config builders with @ai-sdk/react hooks:
+ * - useChat → aippyChatConfig()
+ * - useCompletion → aippyCompletionConfig()
+ * - useObject → aippyObjectConfig()
+ *
+ * ```tsx
+ * import { useChat } from '@ai-sdk/react';
+ * import { aippyChatConfig } from '@aippy/runtime/ai';
+ *
+ * const { messages, handleSubmit } = useChat(aippyChatConfig());
+ * ```
+ *
+ * @module
+ */
+export { aippy, type AippyProvider } from './openai';
+export type { AippyOpenAIConfig } from './openai';
+export { aippyChatConfig, aippyCompletionConfig, aippyObjectConfig, aippyObjectBaseConfig, type AippyObjectConfigOptions, type AippyUseChatOptions, type UseObjectOptions, type UseObjectConfigWithSchema, type AippyUIConfig, type AippyChatConfig, UI_CHAT_ENDPOINT, UI_COMPLETION_ENDPOINT, UI_OBJECT_ENDPOINT, } from './ui';
+export { DEFAULT_BASE_URL, DEFAULT_UI_BASE_URL, DEFAULT_CHAT_MODEL, DEFAULT_CHAT_SYSTEM, } from './shared';
+export { normalizeError, missingTokenError, abortedError, networkError, parseError, } from './errors';

package/dist/ai/index.js

@@ -0,0 +1,20 @@
+import { D as s, i as E, j as o, h as _, U as i, f as p, g as T, k as e, a as C, b as U, c as n, e as A, d as D, m as O, l as I, n as L, p as t } from "../errors-D29z-Qus.js";
+export {
+  s as DEFAULT_BASE_URL,
+  E as DEFAULT_CHAT_MODEL,
+  o as DEFAULT_CHAT_SYSTEM,
+  _ as DEFAULT_UI_BASE_URL,
+  i as UI_CHAT_ENDPOINT,
+  p as UI_COMPLETION_ENDPOINT,
+  T as UI_OBJECT_ENDPOINT,
+  e as abortedError,
+  C as aippy,
+  U as aippyChatConfig,
+  n as aippyCompletionConfig,
+  A as aippyObjectBaseConfig,
+  D as aippyObjectConfig,
+  O as missingTokenError,
+  I as networkError,
+  L as normalizeError,
+  t as parseError
+};

package/dist/ai/openai/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OpenAI-compatible module for Aippy AI SDK.
+ *
+ * Provides the `aippy()` provider factory for use with AI SDK Core functions:
+ * - generateText / streamText
+ * - generateObject / streamObject
+ * - embed / embedMany
+ * - generateImage
+ */
+export { aippy, type AippyProvider } from './provider';
+export type { AippyOpenAIConfig } from '../shared/config';

package/dist/ai/openai/provider.d.ts

@@ -0,0 +1,51 @@
+import { OpenAICompatibleProvider } from '@ai-sdk/openai-compatible';
+import { AippyOpenAIConfig } from '../shared/config';
+/**
+ * The Aippy provider type - an OpenAI-compatible provider.
+ */
+export type AippyProvider = OpenAICompatibleProvider<string, string, string, string>;
+/**
+ * Creates an Aippy AI provider that routes requests through the backend proxy.
+ *
+ * This provider is for use with AI SDK Core functions:
+ * - `generateText` / `streamText` - Text generation
+ * - `generateObject` / `streamObject` - Structured object generation
+ * - `embed` / `embedMany` - Text embeddings
+ * - `generateImage` - Image generation
+ *
+ * @param config - Optional configuration to override defaults
+ * @returns An AI SDK Core compatible provider
+ *
+ * @example
+ * ```ts
+ * import { generateText, streamText, embed, generateImage } from 'ai';
+ * import { aippy } from '@aippy/runtime/ai';
+ *
+ * const provider = aippy();
+ *
+ * // Text generation
+ * const text = await generateText({
+ *   model: provider('gpt-5'),
+ *   prompt: 'Hello!',
+ * });
+ *
+ * // Streaming
+ * const stream = await streamText({
+ *   model: provider('gpt-5'),
+ *   prompt: 'Tell me a story.',
+ * });
+ *
+ * // Embeddings
+ * const embedding = await embed({
+ *   model: provider.embedding('text-embedding-3-small'),
+ *   value: 'Hello world',
+ * });
+ *
+ * // Image generation
+ * const image = await generateImage({
+ *   model: provider.imageModel('gpt-image-1.5'),
+ *   prompt: 'A cat',
+ * });
+ * ```
+ */
+export declare function aippy(config?: AippyOpenAIConfig): AippyProvider;

package/dist/ai/shared/config.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared configuration for Aippy AI SDK.
+ * Used by both OpenAI-compatible (Core) and Data Stream Protocol (UI) paths.
+ */
+/** Default backend base URL for OpenAI-compatible endpoints */
+export declare const DEFAULT_BASE_URL: string;
+/** Default backend base URL for UI (Data Stream Protocol) endpoints */
+export declare const DEFAULT_UI_BASE_URL: string;
+/**
+ * Configuration for OpenAI-compatible provider (AI SDK Core).
+ */
+export interface AippyOpenAIConfig {
+    /** Backend proxy URL for OpenAI-compatible endpoints (defaults to DEFAULT_BASE_URL) */
+    baseUrl?: string;
+}
+/**
+ * Configuration for Data Stream Protocol endpoints (AI SDK UI).
+ */
+export interface AippyUIConfig {
+    /** Backend proxy URL for UI endpoints (defaults to DEFAULT_UI_BASE_URL) */
+    baseUrl?: string;
+}
+/**
+ * Configuration for useChat hook with model and system prompt.
+ */
+export interface AippyChatConfig extends AippyUIConfig {
+    /**
+     * Optional API endpoint override for useChat.
+     * Useful for local dev proxies (e.g. Vite) to avoid cross-origin streaming.
+     *
+     * If not provided, we use `${baseUrl}/chat`.
+     */
+    api?: string;
+    /** Model identifier (defaults to 'gpt-5') */
+    model?: string;
+    /** System prompt for the conversation (defaults to empty string) */
+    system?: string;
+}
+/** Default model for chat */
+export declare const DEFAULT_CHAT_MODEL = "gpt-5";
+/** Default system prompt for chat */
+export declare const DEFAULT_CHAT_SYSTEM = "";
+/**
+ * Resolves OpenAI-compatible configuration with defaults.
+ */
+export declare function resolveOpenAIConfig(config?: AippyOpenAIConfig): Required<AippyOpenAIConfig>;
+/**
+ * Resolves UI (Data Stream Protocol) configuration with defaults.
+ */
+export declare function resolveUIConfig(config?: AippyUIConfig): Required<AippyUIConfig>;

package/dist/ai/shared/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared utilities for Aippy AI SDK.
+ * Re-exports config utilities used by both protocol paths.
+ */
+export { DEFAULT_BASE_URL, DEFAULT_UI_BASE_URL, DEFAULT_CHAT_MODEL, DEFAULT_CHAT_SYSTEM, resolveOpenAIConfig, resolveUIConfig, type AippyOpenAIConfig, type AippyUIConfig, type AippyChatConfig, } from './config';

package/dist/ai/ui/config.d.ts

@@ -0,0 +1,81 @@
+import { AippyUIConfig, AippyChatConfig } from '../shared/config';
+import { UseCompletionOptions } from 'ai';
+import { AippyUseChatOptions, UseObjectOptions, UseObjectConfigWithSchema } from './types';
+/**
+ * Creates configuration for the useChat hook.
+ *
+ * @param config - Optional configuration to override defaults
+ * @returns Promise resolving to configuration object to spread into useChat()
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from '@ai-sdk/react';
+ * import { aippyChatConfig } from '@aippy/runtime/ai';
+ *
+ * const chatConfig = await aippyChatConfig();
+ * const { messages, input, handleSubmit } = useChat(chatConfig);
+ *
+ * // With custom model and system prompt
+ * const config = await aippyChatConfig({
+ *   model: 'claude-3',
+ *   system: 'You are a helpful assistant.',
+ * });
+ * const { messages } = useChat(config);
+ * ```
+ */
+export declare function aippyChatConfig(config?: AippyChatConfig): Promise<AippyUseChatOptions>;
+/**
+ * Creates configuration for the useCompletion hook.
+ *
+ * @param config - Optional configuration to override defaults
+ * @returns Promise resolving to configuration object to spread into useCompletion()
+ *
+ * @example
+ * ```tsx
+ * import { useCompletion } from '@ai-sdk/react';
+ * import { aippyCompletionConfig } from '@aippy/runtime/ai';
+ *
+ * const config = await aippyCompletionConfig();
+ * const { completion, input, handleSubmit } = useCompletion(config);
+ * ```
+ */
+export declare function aippyCompletionConfig(config?: AippyUIConfig): Promise<UseCompletionOptions>;
+/**
+ * Configuration options for aippyObjectConfig.
+ */
+export interface AippyObjectConfigOptions extends AippyUIConfig {
+    /**
+     * Schema identifier registered on the backend.
+     * Required for useObject to work with the Aippy backend.
+     */
+    schemaId: string;
+}
+/**
+ * Creates configuration for the useObject hook.
+ *
+ * Note: Unlike useChat/useCompletion, useObject requires a schema.
+ * With the Aippy backend, we use schemaId to reference a pre-registered
+ * schema on the server (instead of passing the schema directly).
+ *
+ * @param options - Configuration including required schemaId
+ * @returns Promise resolving to configuration object to spread into useObject()
+ *
+ * @example
+ * ```tsx
+ * import { useObject } from '@ai-sdk/react';
+ * import { aippyObjectConfig } from '@aippy/runtime/ai';
+ *
+ * // The schemaId must match a schema registered on your backend
+ * const config = await aippyObjectConfig({ schemaId: 'user-profile' });
+ * const { object, submit } = useObject(config);
+ * ```
+ */
+export declare function aippyObjectConfig(options: AippyObjectConfigOptions): Promise<UseObjectConfigWithSchema>;
+/**
+ * Creates base configuration for useObject without schemaId.
+ * Use this when you want to pass schemaId separately.
+ *
+ * @param config - Optional configuration to override defaults
+ * @returns Promise resolving to base configuration object (api + headers only)
+ */
+export declare function aippyObjectBaseConfig(config?: AippyUIConfig): Promise<UseObjectOptions>;

package/dist/ai/ui/endpoints.d.ts

@@ -0,0 +1,16 @@
+/**
+ * UI endpoint path constants for Data Stream Protocol.
+ *
+ * These endpoints are served by the Aippy backend and return
+ * responses in AI SDK Data Stream Protocol format.
+ *
+ * Required response headers from backend:
+ * - Content-Type: text/event-stream
+ * - x-vercel-ai-ui-message-stream: v1
+ */
+/** Endpoint for useChat hook */
+export declare const UI_CHAT_ENDPOINT = "/chat";
+/** Endpoint for useCompletion hook */
+export declare const UI_COMPLETION_ENDPOINT = "/completion";
+/** Endpoint for useObject hook */
+export declare const UI_OBJECT_ENDPOINT = "/object";

package/dist/ai/ui/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AI SDK UI module for Aippy AI SDK.
+ *
+ * Provides configuration builders for @ai-sdk/react hooks:
+ * - useChat → aippyChatConfig()
+ * - useCompletion → aippyCompletionConfig()
+ * - useObject → aippyObjectConfig()
+ *
+ * These hooks communicate with the Aippy backend using
+ * AI SDK Data Stream Protocol (SSE with x-vercel-ai-ui-message-stream: v1).
+ */
+export { aippyChatConfig, aippyCompletionConfig, aippyObjectConfig, aippyObjectBaseConfig, type AippyObjectConfigOptions, } from './config';
+export type { AippyUseChatOptions, UseObjectOptions, UseObjectConfigWithSchema, } from './types';
+export { UI_CHAT_ENDPOINT, UI_COMPLETION_ENDPOINT, UI_OBJECT_ENDPOINT, } from './endpoints';
+export type { AippyUIConfig, AippyChatConfig } from '../shared/config';

package/dist/ai/ui/types.d.ts

@@ -0,0 +1,46 @@
+import { ChatTransport, UIMessage } from 'ai';
+/**
+ * Body parameters for useChat requests (internal use).
+ */
+interface UseChatBody {
+    /** Model identifier (e.g., 'gpt-5', 'claude-3') */
+    model: string;
+    /** System prompt for the conversation */
+    system: string;
+}
+/**
+ * Configuration options for useChat hook with Aippy transport.
+ *
+ * This is a minimal wrapper around ChatTransport for type safety.
+ * Users can also directly use ChatTransport from 'ai' package.
+ */
+export interface AippyUseChatOptions<UI_MESSAGE extends UIMessage = UIMessage> {
+    /** Transport for custom API communication */
+    transport: ChatTransport<UI_MESSAGE>;
+}
+/**
+ * Base configuration for useObject hook.
+ *
+ * Similar to UseCompletionOptions but for useObject hook.
+ * We define this separately since useObject is from @ai-sdk/react, not 'ai'.
+ */
+export interface UseObjectOptions {
+    /** API endpoint URL */
+    api: string;
+    /** Headers to include in requests */
+    headers: Record<string, string>;
+}
+/**
+ * Extended configuration for useObject with schemaId.
+ *
+ * This is Aippy-specific: we use schemaId to reference a pre-registered
+ * schema on the backend instead of passing the schema directly.
+ */
+export interface UseObjectConfigWithSchema extends UseObjectOptions {
+    /**
+     * Schema identifier registered on the backend.
+     * This will be included in the request body.
+     */
+    schemaId: string;
+}
+export type { UseChatBody };

package/dist/ai.d.ts

@@ -0,0 +1,2 @@
+export * from './ai/index'
+export {}

package/dist/bridge-DdAH4txB.js

@@ -0,0 +1,222 @@
+import { a as K } from "./runtime-CmoG3v2m.js";
+import { h as y } from "./native-bridge-JAmH-zTN.js";
+const U = {
+  apiBaseUrl: "https://api.aippy.dev/api",
+  authToken: "",
+  // 默认为空，由 iOS 桥接填充
+  currentUserId: null,
+  // 默认为空，由 iOS 桥接填充
+  cacheTime: 300 * 1e3
+  // 5 minutes
+};
+let u = { ...U };
+function h(r) {
+  u = {
+    ...U,
+    ...r
+  };
+}
+function R() {
+  return u;
+}
+function w(r) {
+  u.authToken = r;
+}
+function B(r) {
+  u.currentUserId = r;
+}
+function P() {
+  return u.authToken;
+}
+const a = {
+  uid: "",
+  token: "",
+  apiBaseUrl: void 0
+}, D = 5e3;
+let d = !1, m = !1, l = null, o = null;
+function g() {
+  try {
+    return typeof window < "u" && window.parent !== window;
+  } catch {
+    return !0;
+  }
+}
+function k(r = D) {
+  return new Promise((e) => {
+    if (!g()) {
+      console.log("ℹ️ [UserSDK Bridge] Not in iframe, skipping parent request"), e(a);
+      return;
+    }
+    console.log("📤 [UserSDK Bridge] Requesting credentials from parent window");
+    const i = setTimeout(() => {
+      console.warn(`⚠️ [UserSDK Bridge] Parent request timeout (${r}ms)`), window.removeEventListener("message", n), e(a);
+    }, r), n = (t) => {
+      if (t.data && t.data.type === "user-credentials-response") {
+        console.log("📩 [UserSDK Bridge] Received credentials from parent:", t.data), clearTimeout(i), window.removeEventListener("message", n);
+        const s = f(t.data);
+        e(s || a);
+      }
+    };
+    window.addEventListener("message", n);
+    try {
+      window.parent.postMessage({
+        type: "user-credentials-request",
+        timestamp: Date.now()
+      }, "*");
+    } catch (t) {
+      console.error("❌ [UserSDK Bridge] Failed to send request to parent:", t), clearTimeout(i), window.removeEventListener("message", n), e(a);
+    }
+  });
+}
+function C() {
+  if (!g())
+    return null;
+  try {
+    const r = window.parent.localStorage.getItem("token"), e = window.parent.localStorage.getItem("user");
+    if (!r || !e)
+      return console.log("ℹ️ [UserSDK Bridge] Parent localStorage credentials not found"), null;
+    const i = JSON.parse(e), n = i.uid || i.userId || i.id || "";
+    if (!n)
+      return console.warn("⚠️ [UserSDK Bridge] Parent user data missing uid"), null;
+    const t = {
+      uid: String(n),
+      token: r,
+      apiBaseUrl: void 0
+    };
+    return B(t.uid), w(t.token), console.log("✅ [UserSDK Bridge] Got credentials from parent localStorage:", t.uid), l = t, d = !0, t;
+  } catch {
+    return console.log("ℹ️ [UserSDK Bridge] Cannot access parent localStorage (cross-origin), will use postMessage"), null;
+  }
+}
+function v(r = D) {
+  return d && l ? (console.log("✅ [UserSDK Bridge] Returning cached credentials"), Promise.resolve(l)) : m && !d ? (console.log("ℹ️ [UserSDK Bridge] Previous request failed, returning empty credentials"), Promise.resolve(a)) : o ? (console.log("⏳ [UserSDK Bridge] Request already pending, waiting..."), new Promise((e) => {
+    const i = o.resolve;
+    o.resolve = (n) => {
+      i(n), e(n);
+    };
+  })) : new Promise((e) => {
+    m = !0;
+    const i = window.webkit?.messageHandlers?.aippyListener;
+    if (!i) {
+      console.warn("⚠️ [UserSDK Bridge] Native bridge not available, returning empty credentials"), e(a);
+      return;
+    }
+    const n = setTimeout(() => {
+      console.warn(`⚠️ [UserSDK Bridge] Request timeout (${r}ms), returning empty credentials`), o = null, e(a);
+    }, r);
+    o = { resolve: e, reject: () => {
+    } };
+    const t = K.receiveChannel.once("user.credentials", (s) => {
+      console.log("📩 [UserSDK Bridge] Received credentials via receiveChannel:", s), clearTimeout(n);
+      const c = f(s);
+      c ? o?.resolve(c) : o?.resolve(a), o = null;
+    });
+    try {
+      const s = {
+        command: "user.getCredentials",
+        parameters: JSON.stringify({
+          timestamp: Date.now(),
+          endpoint: "user.credentials"
+          // Tell iOS which endpoint to respond to
+        })
+      };
+      console.log("📤 [UserSDK Bridge] Requesting credentials from iOS:", s), i.postMessage(s);
+    } catch (s) {
+      console.error("❌ [UserSDK Bridge] Failed to send request to iOS:", s), clearTimeout(n), t.cancel(), o = null, e(a);
+    }
+  });
+}
+function f(r) {
+  if (!r || typeof r != "object")
+    return console.warn("⚠️ [UserSDK Bridge] Invalid credentials data:", r), null;
+  let e = r;
+  if (e.credentials && typeof e.credentials == "object" && (console.log("📦 [UserSDK Bridge] Detected nested credentials format"), e = e.credentials), e.user && typeof e.user == "object" && e.token) {
+    console.log("📦 [UserSDK Bridge] Detected parent window format");
+    const c = e.user;
+    e = {
+      uid: c.uid || c.userId || c.id,
+      token: e.token,
+      apiBaseUrl: e.apiBaseUrl
+    };
+  }
+  const i = e.uid || e.userId || e.id || "", n = e.token || e.authToken || "", t = e.apiBaseUrl || e.baseUrl;
+  if (!i || !n)
+    return console.warn("⚠️ [UserSDK Bridge] Missing uid or token in credentials:", r), null;
+  const s = { uid: String(i), token: n, apiBaseUrl: t };
+  return B(s.uid), w(n), t && h({ apiBaseUrl: t }), console.log("✅ [UserSDK Bridge] Config updated with credentials:", s.uid), l = s, d = !0, s;
+}
+function S(r) {
+  console.log("📩 [UserSDK Bridge] processUserCredentials called with:", r);
+  const e = f(r);
+  e && o && (o.resolve(e), o = null);
+}
+function T() {
+  typeof window > "u" || (window.processUserCredentials = S, window.addEventListener("message", (r) => {
+    r.data && r.data.type === "user-credentials" && (console.log("📩 [UserSDK Bridge] Received credentials via postMessage:", r.data), S(r.data));
+  }), console.log("✅ [UserSDK Bridge] Bridge initialized"));
+}
+async function p() {
+  if (d && l) {
+    console.log("✅ [UserSDK Bridge] Already have cached credentials");
+    return;
+  }
+  if (y()) {
+    console.log("🔍 [UserSDK Bridge] Detected iOS environment, requesting from native");
+    try {
+      if (await v(), d) {
+        console.log("✅ [UserSDK Bridge] Got credentials from iOS");
+        return;
+      }
+    } catch (r) {
+      console.warn("⚠️ [UserSDK Bridge] iOS request failed:", r);
+    }
+  }
+  if (g()) {
+    if (console.log("🔍 [UserSDK Bridge] Detected iframe environment"), C()) {
+      console.log("✅ [UserSDK Bridge] Got credentials from parent localStorage");
+      return;
+    }
+    console.log("🔍 [UserSDK Bridge] Trying postMessage to parent");
+    try {
+      const e = await k();
+      if (e.uid && e.token) {
+        console.log("✅ [UserSDK Bridge] Got credentials from parent postMessage");
+        return;
+      }
+    } catch (e) {
+      console.warn("⚠️ [UserSDK Bridge] Parent postMessage request failed:", e);
+    }
+  }
+  console.log("ℹ️ [UserSDK Bridge] No credentials source available");
+}
+async function b() {
+  return await p(), l?.token || "";
+}
+async function E() {
+  return await p(), l?.uid || "";
+}
+function O() {
+  return d;
+}
+function A() {
+  return l;
+}
+T();
+p();
+export {
+  B as a,
+  P as b,
+  g as c,
+  k as d,
+  T as e,
+  p as f,
+  R as g,
+  b as h,
+  h as i,
+  E as j,
+  O as k,
+  A as l,
+  v as r,
+  w as s,
+  C as t
+};