@aippy/runtime 0.2.7-dev.3 → 0.2.7-dev.5

package/README.md

@@ -93,13 +93,13 @@ button.onclick = async () => {
 // Default base URL: https://api.aippy.dev/api/aisdk/v1
 
 import { streamText, experimental_generateImage as generateImage } from 'ai';
-import { aippy } from '@aippy/runtime/ai';
+import { aippyAIProvider } from '@aippy/runtime/ai';
 
 // Create provider (reads from env vars automatically)
-const provider = aippy();
+const provider = aippyAIProvider();
 
 // Or override with config
-// const provider = aippy({ baseUrl: '...', userToken: '...' });
+// const provider = aippyAIProvider({ baseUrl: '...', userToken: '...' });
 
 // Streaming text generation (uses Vercel AI SDK)
 const result = await streamText({

package/dist/ai/errors.d.ts

@@ -1,25 +1,6 @@
 import { AISDKError } from 'ai';
 /**
  * Normalizes a backend error response into an AISDKError.
- *
- * If the backend error response includes container message data (e.g., `appMessage` field),
- * it will be automatically sent to the app container for user-facing UI (e.g., payment dialog,
- * error popup, success notification).
+ * Extracts and sends appMessage to container if present in the error response.
  */
 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

@@ -38,9 +38,7 @@
  */
 export { aippyAIProvider, type AippyProvider } from './openai';
 export type { AippyOpenAIConfig } from './openai';
-/** @deprecated Use aippyAIProvider() instead */
-export { aippyAIProvider as aippy } from './openai';
 export { aippyChatConfig, type AippyUseChatOptions, type AippyUIConfig, type AippyChatConfig, UI_CHAT_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';
+export { normalizeError } from './errors';
 export { type AIConfig, type AIConfigValue, type AIConfigItem, type NumberAIConfigItem, type BooleanAIConfigItem, type TextAIConfigItem, type EnumAIConfigItem, type AIConfigError, type AIConfigValues, AIConfigValidationError, validateAIConfig, parseAIConfig, loadAIConfig, getAIConfigValue, sendAIConfigToContainer, createAIConfig, } from './config';

package/dist/ai/index.js

@@ -1,25 +1,20 @@
-import { A as i, D as A, d as n, e, c as E, U as C, f as p, a as g, a as t, b as I, j as T, i as _, l as f, m as U, g as d, n as D, h as L, p as l, s as m, v as F } from "../helper-CKiqfKle.js";
+import { A, D as r, d as n, e as C, c as e, U as E, a as I, b as _, f, g, l as T, n as p, p as t, s as U, v as D } from "../helper-BENVYOU-.js";
 import "react";
-import "../bridge-N9ELFpfV.js";
+import "../bridge-Ca3H2iN1.js";
 export {
-  i as AIConfigValidationError,
-  A as DEFAULT_BASE_URL,
+  A as AIConfigValidationError,
+  r as DEFAULT_BASE_URL,
   n as DEFAULT_CHAT_MODEL,
-  e as DEFAULT_CHAT_SYSTEM,
-  E as DEFAULT_UI_BASE_URL,
-  C as UI_CHAT_ENDPOINT,
-  p as abortedError,
-  g as aippy,
-  t as aippyAIProvider,
-  I as aippyChatConfig,
-  T as createAIConfig,
-  _ as getAIConfigValue,
-  f as loadAIConfig,
-  U as missingTokenError,
-  d as networkError,
-  D as normalizeError,
-  L as parseAIConfig,
-  l as parseError,
-  m as sendAIConfigToContainer,
-  F as validateAIConfig
+  C as DEFAULT_CHAT_SYSTEM,
+  e as DEFAULT_UI_BASE_URL,
+  E as UI_CHAT_ENDPOINT,
+  I as aippyAIProvider,
+  _ as aippyChatConfig,
+  f as createAIConfig,
+  g as getAIConfigValue,
+  T as loadAIConfig,
+  p as normalizeError,
+  t as parseAIConfig,
+  U as sendAIConfigToContainer,
+  D as validateAIConfig
 };

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

@@ -4,25 +4,12 @@
  */
 /**
  * Joins a base URL with a path segment.
- * Uses native URL API for reliable URL resolution.
- *
- * @param baseUrl - The base URL (e.g., 'https://api.aippy.dev/api/aisdk/v1/ui/')
- * @param path - The path segment to append (e.g., '/chat' or 'chat')
- * @returns The joined URL string
- *
- * @example
- * joinUrl('https://api.aippy.dev/api/aisdk/v1/ui/', '/chat')
- * // => 'https://api.aippy.dev/api/aisdk/v1/ui/chat'
  */
 export declare function joinUrl(baseUrl: string, path: string): string;
 /**
- * Creates a fetch wrapper that injects Authorization header with a fresh token.
- * Token is fetched asynchronously on every request to ensure it's always current.
+ * Creates a fetch wrapper that injects Authorization header and handles error responses.
+ * Error responses are intercepted and normalized errors are thrown immediately.
  *
  * @returns A fetch function compatible with globalThis.fetch signature
- *
- * @example
- * const authFetch = createAuthFetch();
- * const response = await authFetch('https://api.example.com/endpoint', { method: 'POST' });
  */
 export declare function createAuthFetch(): typeof globalThis.fetch;

package/dist/audio/index.d.ts

@@ -8,7 +8,7 @@
  */
 export { patchAudioContext } from './patchAudioContext';
 export type { AudioContextPatchOptions, AutoPauseOptions, MediaElementType, PatchedAudioContext, } from './types';
-export { createHiddenMediaElement, createHiddenVideoElement, isMediaStreamAudioSupported, } from './utils';
+export { createHiddenMediaElement, isMediaStreamAudioSupported, } from './utils';
 export { useAudioContext } from './useAudioContext';
 export type { UseAudioContextOptions, UseAudioContextReturn } from './useAudioContext';
 export { isIOSDevice } from './utils';

package/dist/audio/index.js

@@ -1,9 +1,8 @@
-import { c as i, a as t, b as d, i as o, p as s, u as n } from "../useAudioContext-CNQQSTab.js";
+import { c as i, a as t, i as d, p as o, u as s } from "../useAudioContext-D9F3x80Y.js";
 export {
   i as createHiddenMediaElement,
-  t as createHiddenVideoElement,
-  d as isIOSDevice,
-  o as isMediaStreamAudioSupported,
-  s as patchAudioContext,
-  n as useAudioContext
+  t as isIOSDevice,
+  d as isMediaStreamAudioSupported,
+  o as patchAudioContext,
+  s as useAudioContext
 };

package/dist/audio/utils.d.ts

@@ -15,10 +15,3 @@ export declare function isMediaStreamAudioSupported(): boolean;
  * @returns HTMLMediaElement (HTMLVideoElement or HTMLAudioElement)
  */
 export declare function createHiddenMediaElement(type?: 'video' | 'audio', debug?: boolean): HTMLVideoElement | HTMLAudioElement;
-/**
- * @deprecated Use createHiddenMediaElement instead
- * Creates a hidden video element for MediaStream playback
- * @param debug - If true, makes the video element visible for debugging
- * @returns HTMLVideoElement
- */
-export declare function createHiddenVideoElement(debug?: boolean): HTMLVideoElement;

package/dist/bridge-Ca3H2iN1.js

@@ -0,0 +1,197 @@
+import { a as y } from "./runtime-CmoG3v2m.js";
+import { p as T, s as v, i as f } from "./ui-y5N62DqC.js";
+const m = {
+  apiBaseUrl: "https://api.aippy.dev/api",
+  authToken: "",
+  currentUserId: null
+};
+function b(n) {
+  Object.assign(m, n);
+}
+function P(n) {
+  m.authToken = n;
+}
+function O(n) {
+  m.currentUserId = n;
+}
+const k = { iOS: "1.6.6", Android: "1.1.8" }, E = 3e3, S = 50, l = 500, a = { uid: "", token: "" };
+let d = null, _ = !1, u = null, w = !1, o = null;
+function g(n) {
+  if (!n || typeof n != "object") return null;
+  let e = n;
+  if (e.credentials && typeof e.credentials == "object" && (e = e.credentials), e.user && typeof e.user == "object" && e.token) {
+    const c = e.user;
+    e = { uid: c.uid || c.userId || c.id, token: e.token, apiBaseUrl: e.apiBaseUrl };
+  }
+  const s = e.uid || e.userId || e.id || "", t = e.token || e.authToken || "", r = e.apiBaseUrl;
+  if (!s || !t) return null;
+  const i = { uid: String(s), token: t, apiBaseUrl: r };
+  return O(i.uid), P(t), r && b({ apiBaseUrl: r }), d = i, _ = !0, i;
+}
+function h(n) {
+  if (!n || typeof n != "object") return null;
+  let e = n;
+  e.userInfo && typeof e.userInfo == "object" && (e = e.userInfo), e.user && typeof e.user == "object" && (e = e.user);
+  const s = e.uid || e.userId || e.id || "";
+  if (!s) return null;
+  const t = { uid: String(s), ...e };
+  return u = t, w = !0, t;
+}
+function p(n) {
+  throw console.warn(`[UserSDK] ${n}`), v("Your app version is outdated. Please upgrade to the latest version."), new Error("App version too old");
+}
+function L(n = l) {
+  return _ && d ? Promise.resolve(d) : new Promise((e) => {
+    const s = window.webkit?.messageHandlers?.aippyListener;
+    if (!s) {
+      e(a);
+      return;
+    }
+    const t = setTimeout(() => e(a), n);
+    y.receiveChannel.once("user.credentials", (r) => {
+      clearTimeout(t), e(g(r) || a);
+    });
+    try {
+      s.postMessage({
+        command: "user.getCredentials",
+        parameters: JSON.stringify({ timestamp: Date.now(), endpoint: "user.credentials" })
+      });
+    } catch {
+      clearTimeout(t), e(a);
+    }
+  });
+}
+function C(n = l) {
+  return new Promise((e) => {
+    if (!f()) {
+      e(a);
+      return;
+    }
+    const s = setTimeout(() => {
+      window.removeEventListener("message", t), e(a);
+    }, n), t = (r) => {
+      r.data?.type === "user-credentials-response" && (clearTimeout(s), window.removeEventListener("message", t), e(g(r.data) || a));
+    };
+    window.addEventListener("message", t);
+    try {
+      window.parent.postMessage({ type: "user-credentials-request", timestamp: Date.now() }, "*");
+    } catch {
+      clearTimeout(s), window.removeEventListener("message", t), e(a);
+    }
+  });
+}
+function D(n = !1, e = l) {
+  return w && u && !n ? Promise.resolve(u) : o ? new Promise((s) => {
+    const t = o.resolve;
+    o.resolve = (r) => {
+      t(r), s(r);
+    };
+  }) : new Promise((s) => {
+    const t = window.webkit?.messageHandlers?.aippyListener;
+    if (!t) {
+      s(null);
+      return;
+    }
+    const r = setTimeout(() => {
+      o = null, s(null);
+    }, e);
+    o = { resolve: (i) => {
+      clearTimeout(r), o = null, s(i);
+    } }, y.receiveChannel.once("user.info", (i) => {
+      console.log("[UserSDK] Received user.info via receiveChannel:", i), clearTimeout(r);
+      const c = h(i);
+      o && o.resolve(c);
+    });
+    try {
+      console.log("[UserSDK] Requesting user info from iOS"), t.postMessage({
+        command: "user.getUserInfo",
+        parameters: JSON.stringify({ timestamp: Date.now(), endpoint: "user.info" })
+      });
+    } catch {
+      clearTimeout(r), o = null, s(null);
+    }
+  });
+}
+function A(n = l) {
+  return new Promise((e) => {
+    if (!f()) {
+      e(null);
+      return;
+    }
+    const s = setTimeout(() => {
+      window.removeEventListener("message", t), e(null);
+    }, n), t = (r) => {
+      r.data?.type === "user-info-response" && (clearTimeout(s), window.removeEventListener("message", t), e(h(r.data)));
+    };
+    window.addEventListener("message", t);
+    try {
+      window.parent.postMessage({ type: "user-info-request", timestamp: Date.now() }, "*");
+    } catch {
+      clearTimeout(s), window.removeEventListener("message", t), e(null);
+    }
+  });
+}
+async function M() {
+  const n = T.checkAppEnvironment(k);
+  switch (n.type) {
+    case "new_app": {
+      n.isValid || p(n.message || "App version too old"), await L(E);
+      const e = d?.token || "";
+      if (!e) throw new Error("Token unavailable in app");
+      return e;
+    }
+    case "old_ios_app":
+    case "old_android_app":
+      throw p(n.message || "Old app version"), new Error("Token unavailable: Old app version not supported");
+    case "iframe": {
+      const e = await C(S);
+      if (e?.token) return e.token;
+      throw v("Please log in to use this feature."), new Error("Token unavailable: User needs to login");
+    }
+    default:
+      return "";
+  }
+}
+async function F(n = !1) {
+  if (w && u && !n) return u;
+  const e = T.checkAppEnvironment(k);
+  switch (e.type) {
+    case "new_app":
+      return e.isValid || p(e.message || "App version too old"), await D(n, E);
+    case "old_ios_app":
+    case "old_android_app":
+      return p(e.message || "Old app version"), u;
+    case "iframe":
+      return await A(S);
+    default:
+      return u;
+  }
+}
+async function B(n = l) {
+  return f() ? await A(n) : null;
+}
+function I(n) {
+  g(n);
+}
+function U(n) {
+  console.log("[UserSDK] processUserInfo called with:", n);
+  const e = h(n);
+  o && (o.resolve(e), o = null);
+}
+function j() {
+  typeof window > "u" || (window.processUserCredentials = I, window.processUserInfo = U, window.addEventListener("message", (n) => {
+    n.data?.type === "user-credentials" && I(n.data), n.data?.type === "user-info" && U(n.data);
+  }));
+}
+j();
+M().catch((n) => {
+  console.warn("[UserSDK] Auth check on load:", n.message);
+});
+export {
+  M as getAuthTokenAsync,
+  F as getUserInfoAsync,
+  B as getUserInfoFromParent,
+  f as isInIframe,
+  I as processUserCredentials,
+  U as processUserInfo
+};

package/dist/core/index.js

@@ -24,7 +24,7 @@ function p(e) {
     }
   };
 }
-const r = "0.2.7-dev.3", a = {
+const r = "0.2.7-dev.5", a = {
   version: r
 }, t = a.version, i = "@aippy/runtime";
 function c() {

package/dist/helper-BENVYOU-.js

@@ -0,0 +1,247 @@
+import { createOpenAICompatible as l } from "@ai-sdk/openai-compatible";
+import "react";
+import { getAuthTokenAsync as y } from "./bridge-Ca3H2iN1.js";
+import { AISDKError as u, DefaultChatTransport as d } from "ai";
+import { s as f } from "./container-message-DGrno17o.js";
+const c = "https://api.aippy.dev", h = `${c}/aisdk/v1/`, b = `${c}/aisdk/v1/ui/`, A = "gpt-5-nano", w = "";
+function v(n = {}) {
+  return {
+    baseUrl: n.baseUrl ?? h
+  };
+}
+function I(n = {}) {
+  return {
+    baseUrl: n.baseUrl ?? b
+  };
+}
+function C(n, e) {
+  const s = n.status;
+  if (e && typeof e == "object" && "error" in e) {
+    const t = e, o = t.error.code, r = o != null ? `AippyAIError_${o}` : `AippyAIError_${s}`, a = e;
+    return "appMessage" in a && a.appMessage !== void 0 && f(a.appMessage), new u({
+      name: r,
+      message: t.error.message,
+      cause: {
+        type: t.error.type ?? void 0,
+        param: t.error.param ?? void 0,
+        status: s
+      }
+    });
+  }
+  if (e && typeof e == "object" && e !== null) {
+    const t = e;
+    "appMessage" in t && t.appMessage !== void 0 && f(t.appMessage);
+  }
+  return new u({
+    name: `AippyAIError_${s}`,
+    message: `Request failed with status ${s}`,
+    cause: { status: s }
+  });
+}
+function E(n, e) {
+  const s = n.endsWith("/") ? n : `${n}/`, t = e.startsWith("/") ? e.slice(1) : e;
+  return new URL(t, s).href;
+}
+function m() {
+  return async (n, e) => {
+    const s = await y(), t = new Headers(e?.headers);
+    t.set("Aippy-Runtime-Authorization", `Bearer ${s}`);
+    const o = await globalThis.fetch(n, { ...e, headers: t });
+    if (!o.ok) {
+      const r = await o.text().catch(() => null);
+      let a = null;
+      if (r)
+        try {
+          a = JSON.parse(r);
+        } catch {
+          a = { message: r };
+        }
+      throw C(o, a);
+    }
+    return o;
+  };
+}
+const S = [
+  "gpt-image-1",
+  "gpt-image-1-mini",
+  "gpt-image-1.5"
+];
+function O(n) {
+  try {
+    const e = JSON.parse(n);
+    if (e.model && S.some((s) => e.model.startsWith(s))) {
+      const { response_format: s, ...t } = e;
+      return JSON.stringify(t);
+    }
+  } catch {
+  }
+  return n;
+}
+function N(n = {}) {
+  const { baseUrl: e } = v(n), s = m();
+  return l({
+    name: "aippy",
+    baseURL: e,
+    fetch: async (o, r) => o.toString().includes("/images/generations") && r?.method?.toUpperCase() === "POST" && r?.body ? s(o, {
+      ...r,
+      body: O(r.body)
+    }) : s(o, r),
+    // Enable structured outputs support (json_schema response format)
+    // This is required for Output.object() and Output.array() to work properly
+    supportsStructuredOutputs: !0
+  });
+}
+const _ = "/chat";
+function D(n = {}) {
+  const { baseUrl: e } = I(n), s = n.model ?? A, t = n.system ?? w, o = n.api ?? E(e, _), r = { model: s, system: t }, a = m();
+  return {
+    transport: new d({
+      api: o,
+      body: r,
+      // Ensure token is fetched fresh for every request
+      fetch: a
+    })
+  };
+}
+class p extends Error {
+  constructor(e, s) {
+    super(e), this.errors = s, this.name = "AIConfigValidationError";
+  }
+}
+function g(n) {
+  const e = [];
+  if (!n || typeof n != "object")
+    throw new p("AIConfig must be an object", []);
+  const s = n;
+  for (const [t, o] of Object.entries(s)) {
+    if (!o || typeof o != "object") {
+      e.push({ key: t, message: "Item must be an object" });
+      continue;
+    }
+    const r = o;
+    typeof r.index != "number" && e.push({ key: t, message: "index must be a number" }), typeof r.name != "string" && e.push({ key: t, message: "name must be a string" }), typeof r.description != "string" && e.push({ key: t, message: "description must be a string" });
+    const a = r.type;
+    if (!["number", "boolean", "text", "enum"].includes(a)) {
+      e.push({
+        key: t,
+        message: `type must be one of: number, boolean, text, enum (got: ${a})`
+      });
+      continue;
+    }
+    if (a === "number")
+      typeof r.value != "number" && e.push({ key: t, message: 'value must be a number for type "number"' }), r.min !== void 0 && typeof r.min != "number" && e.push({ key: t, message: "min must be a number" }), r.max !== void 0 && typeof r.max != "number" && e.push({ key: t, message: "max must be a number" }), r.step !== void 0 && typeof r.step != "number" && e.push({ key: t, message: "step must be a number" });
+    else if (a === "boolean")
+      typeof r.value != "boolean" && e.push({ key: t, message: 'value must be a boolean for type "boolean"' });
+    else if (a === "text")
+      typeof r.value != "string" && e.push({ key: t, message: 'value must be a string for type "text"' });
+    else if (a === "enum") {
+      if (!Array.isArray(r.options))
+        e.push({ key: t, message: 'options must be an array for type "enum"' });
+      else if (r.options.length === 0)
+        e.push({ key: t, message: 'options array cannot be empty for type "enum"' });
+      else
+        for (let i = 0; i < r.options.length; i++)
+          typeof r.options[i] != "string" && e.push({
+            key: t,
+            message: `options[${i}] must be a string`
+          });
+      typeof r.value != "string" ? e.push({ key: t, message: 'value must be a string for type "enum"' }) : Array.isArray(r.options) && !r.options.includes(r.value) && e.push({
+        key: t,
+        message: `value "${r.value}" is not in options: [${r.options.join(", ")}]`
+      });
+    }
+    r.group !== void 0 && typeof r.group != "string" && e.push({ key: t, message: "group must be a string" });
+  }
+  if (e.length > 0)
+    throw new p(
+      `AIConfig validation failed with ${e.length} error(s)`,
+      e
+    );
+}
+function R(n) {
+  let e;
+  try {
+    e = JSON.parse(n);
+  } catch (s) {
+    throw new p("Invalid JSON", [
+      {
+        key: "",
+        message: `JSON parse error: ${s instanceof Error ? s.message : String(s)}`
+      }
+    ]);
+  }
+  return g(e), e;
+}
+function U(n) {
+  return g(n), n;
+}
+function T(n, e) {
+  const s = n[e];
+  if (!s)
+    throw new Error(`AIConfig key "${e}" not found`);
+  return s.value;
+}
+function $(n) {
+  if (!(typeof window > "u"))
+    try {
+      const e = window.webkit?.messageHandlers?.aippyListener;
+      if (e)
+        try {
+          const s = {
+            command: "ai.initialize",
+            parameters: JSON.stringify(n)
+          };
+          e.postMessage(s);
+        } catch (s) {
+          console.warn("❌ [Aippy AI Config] Failed to send config to iOS app:", s);
+        }
+      if (window.parent && window.parent !== window)
+        try {
+          const s = {
+            type: "ai.initialize",
+            config: JSON.stringify(n)
+          };
+          window.parent.postMessage(s, "*");
+        } catch (s) {
+          console.warn("❌ [Aippy AI Config] Failed to send config to parent window:", s);
+        }
+    } catch (e) {
+      console.warn("⚠️ [Aippy AI Config] Failed to send config:", e);
+    }
+}
+function B(n) {
+  const e = U(n);
+  return $(e), new Proxy({}, {
+    get(s, t) {
+      if (typeof t == "string")
+        try {
+          return T(e, t);
+        } catch {
+          return;
+        }
+    },
+    has(s, t) {
+      return typeof t != "string" ? !1 : t in e;
+    },
+    ownKeys(s) {
+      return Object.keys(e);
+    }
+  });
+}
+export {
+  p as A,
+  h as D,
+  _ as U,
+  N as a,
+  D as b,
+  b as c,
+  A as d,
+  w as e,
+  B as f,
+  T as g,
+  U as l,
+  C as n,
+  R as p,
+  $ as s,
+  g as v
+};

package/dist/hooks-CE9cjXHP.js

@@ -0,0 +1,46 @@
+import { useState as l, useEffect as c } from "react";
+let n = null, r = null;
+function U() {
+  const [s, i] = l(n || {
+    avatar: "",
+    nickName: "用户",
+    username: "",
+    uid: ""
+  });
+  return c(() => {
+    let t = !0;
+    return (async () => {
+      try {
+        if (n) {
+          t && i(n);
+          return;
+        }
+        if (r) {
+          await r, t && n && i(n);
+          return;
+        }
+        r = (async () => {
+          const { getUserInfoAsync: a, getUserInfoFromParent: o, isInIframe: f } = await import("./bridge-Ca3H2iN1.js"), { hasNativeBridge: u } = await import("./native-bridge-BnvipFJc.js");
+          let e = null;
+          u() ? e = await a() : f() ? e = await o() : e = await a(), e && (n = {
+            avatar: String(e.avatar || e.photoUrl || ""),
+            nickName: String(e.nickName || e.displayName || "用户"),
+            username: String(e.username || ""),
+            uid: String(e.uid || "")
+          });
+        })(), await r, r = null, t && n && i(n);
+      } catch (a) {
+        console.error("[useUserInfo] Failed:", a), r = null;
+      }
+    })(), () => {
+      t = !1;
+    };
+  }, []), s;
+}
+function d() {
+  n = null, r = null;
+}
+export {
+  d as c,
+  U as u
+};