@aippy/runtime 0.2.7-dev.2 → 0.2.7-dev.4

package/dist/ai/errors.d.ts

@@ -5,6 +5,43 @@ import { AISDKError } from 'ai';
  * 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).
+ *
+ * @example appMessage structure:
+ * ```ts
+ * interface AppMessage {
+ *   // Message type determines UI behavior
+ *   type: 'error' | 'success' | 'warning' | 'info';
+ *
+ *   // Required: User-facing title and message
+ *   title: string;
+ *   message: string;
+ *
+ *   // Optional: Action to trigger in the container
+ *   action?: string; // e.g., 'showPaymentDialog', 'showUpgradeDialog', 'redirect'
+ *
+ *   // Optional: URL for redirect actions
+ *   redirectUrl?: string;
+ *
+ *   // Optional: Custom button text for action dialogs
+ *   buttonText?: string;
+ *
+ *   // Optional: Auto-dismiss duration in milliseconds (for success/info messages)
+ *   duration?: number;
+ *
+ *   // Optional: Additional metadata for container processing
+ *   metadata?: Record<string, unknown>;
+ * }
+ *
+ * // Example error message with payment action:
+ * {
+ *   type: 'error',
+ *   title: 'Insufficient Balance',
+ *   message: 'Your account balance is insufficient. Please top up to continue.',
+ *   action: 'showPaymentDialog',
+ *   redirectUrl: '/payment',
+ *   buttonText: 'Top Up Now'
+ * }
+ * ```
  */
 export declare function normalizeError(response: Response, body?: unknown): AISDKError;
 /**

package/dist/ai/index.js

@@ -1,6 +1,6 @@
-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-CsFko67T.js";
+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-CIt1_T-j.js";
 import "react";
-import "../bridge-N9ELFpfV.js";
+import "../bridge-Ca3H2iN1.js";
 export {
   i as AIConfigValidationError,
   A as DEFAULT_BASE_URL,

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

@@ -19,6 +19,12 @@ 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.
  *
+ * This wrapper also automatically handles error responses by:
+ * 1. Detecting error responses (!response.ok)
+ * 2. Parsing error body and calling normalizeError() to extract appMessage
+ * 3. Sending appMessage to container if present
+ * 4. Returning the original response for downstream error handling
+ *
  * @returns A fetch function compatible with globalThis.fetch signature
  *
  * @example

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.2", a = {
+const r = "0.2.7-dev.4", a = {
   version: r
 }, t = a.version, i = "@aippy/runtime";
 function c() {

package/dist/helper-CIt1_T-j.js

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