@sinas/sdk 0.4.0 → 0.7.0

package/dist/sinas-sdk.umd.js

@@ -44,19 +44,30 @@ var SinasSDK = (() => {
   __export(src_exports, {
     SinasAuthError: () => SinasAuthError,
     SinasClient: () => SinasClient,
+    SinasClientAuth: () => SinasClientAuth,
     SinasError: () => SinasError,
     SinasNotFoundError: () => SinasNotFoundError,
     SinasPermissionError: () => SinasPermissionError,
     SinasProvider: () => SinasProvider,
     SinasTimeoutError: () => SinasTimeoutError,
     approveToolCall: () => approveToolCall,
+    cancelBatch: () => cancelBatch,
+    checkPermissions: () => checkPermissions,
     createChat: () => createChat,
+    enqueueFunction: () => enqueueFunction,
     executeFunction: () => executeFunction,
     executeQuery: () => executeQuery,
     generateFileUrl: () => generateFileUrl,
+    getBatch: () => getBatch,
     getChat: () => getChat,
+    getInfo: () => getInfo,
+    getMe: () => getMe,
+    listBatchExecutions: () => listBatchExecutions,
     listCollections: () => listCollections,
     listFiles: () => listFiles,
+    login: () => login,
+    logout: () => logout,
+    refresh: () => refresh,
     sendMessage: () => sendMessage,
     stateDelete: () => stateDelete,
     stateGet: () => stateGet,
@@ -64,13 +75,17 @@ var SinasSDK = (() => {
     stateSet: () => stateSet,
     streamFromChannel: () => streamFromChannel,
     streamMessage: () => streamMessage,
+    submitAgentBatch: () => submitAgentBatch,
+    submitFunctionBatch: () => submitFunctionBatch,
     uploadFile: () => uploadFile,
+    useAuth: () => useAuth,
     useChat: () => useChat,
     useClient: () => useClient,
     useExecute: () => useExecute,
     useQuery: () => useQuery,
     useSinas: () => useSinas,
-    useStateStore: () => useStateStore
+    useStateStore: () => useStateStore,
+    verifyOTP: () => verifyOTP
   });
 
   // src/client/errors.ts
@@ -107,16 +122,131 @@ var SinasSDK = (() => {
     }
   };
 
+  // src/client/auth.ts
+  function trimBase(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+  }
+  async function authFetch(baseUrl, path, init = {}, accessToken) {
+    const headers = new Headers(init.headers);
+    if (!headers.has("Content-Type") && init.body !== void 0) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (accessToken) headers.set("Authorization", `Bearer ${accessToken}`);
+    const res = await fetch(`${trimBase(baseUrl)}${path}`, { ...init, headers });
+    if (res.ok || res.status === 204) return res;
+    let detail = res.statusText;
+    try {
+      const body = await res.clone().json();
+      detail = body.detail || body.message || detail;
+    } catch {
+    }
+    if (res.status === 401) throw new SinasAuthError(detail);
+    if (res.status === 403) throw new SinasPermissionError(detail);
+    if (res.status === 404) throw new SinasNotFoundError(detail);
+    throw new SinasError(detail, res.status, detail);
+  }
+  async function getInfo(baseUrl) {
+    const res = await authFetch(baseUrl, "/info");
+    return await res.json();
+  }
+  async function login(baseUrl, request) {
+    const res = await authFetch(baseUrl, "/auth/login", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    return await res.json();
+  }
+  async function verifyOTP(baseUrl, request) {
+    const res = await authFetch(baseUrl, "/auth/verify-otp", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    return await res.json();
+  }
+  async function refresh(baseUrl, refreshToken) {
+    const res = await authFetch(baseUrl, "/auth/refresh", {
+      method: "POST",
+      body: JSON.stringify({ refresh_token: refreshToken })
+    });
+    return await res.json();
+  }
+  async function logout(baseUrl, refreshToken) {
+    try {
+      await authFetch(baseUrl, "/auth/logout", {
+        method: "POST",
+        body: JSON.stringify({ refresh_token: refreshToken })
+      });
+    } catch (e) {
+      if (e instanceof SinasNotFoundError) return;
+      throw e;
+    }
+  }
+  async function getMe(baseUrl, accessToken) {
+    const res = await authFetch(baseUrl, "/auth/me", { method: "GET" }, accessToken);
+    return await res.json();
+  }
+  async function checkPermissions(baseUrl, accessToken, request) {
+    const res = await authFetch(
+      baseUrl,
+      "/auth/check-permissions",
+      {
+        method: "POST",
+        body: JSON.stringify({ logic: "AND", ...request })
+      },
+      accessToken
+    );
+    return await res.json();
+  }
+
   // src/client/SinasClient.ts
+  function hasWindow() {
+    return typeof window !== "undefined";
+  }
+  function trim(url) {
+    return url.replace(/\/+$/, "");
+  }
+  var SinasClientAuth = class {
+    constructor(client) {
+      this.client = client;
+    }
+    getInfo() {
+      return getInfo(this.client.requireBaseUrl());
+    }
+    login(request) {
+      return login(this.client.requireBaseUrl(), request);
+    }
+    verifyOTP(request) {
+      return verifyOTP(this.client.requireBaseUrl(), request);
+    }
+    refresh(refreshToken) {
+      return refresh(this.client.requireBaseUrl(), refreshToken);
+    }
+    logout(refreshToken) {
+      return logout(this.client.requireBaseUrl(), refreshToken);
+    }
+    getMe() {
+      const token = this.client.getAccessToken();
+      if (!token) throw new SinasAuthError("No access token available");
+      return getMe(this.client.requireBaseUrl(), token);
+    }
+    checkPermissions(request) {
+      const token = this.client.getAccessToken();
+      if (!token) throw new SinasAuthError("No access token available");
+      return checkPermissions(this.client.requireBaseUrl(), token, request);
+    }
+  };
   var SinasClient = class {
-    constructor(config) {
-      this.configOverride = config;
+    constructor(options = {}) {
+      this.refreshInFlight = null;
+      this.options = options;
+      this.auth = new SinasClientAuth(this);
     }
+    // ─── Config / base URL ───
     getConfig() {
-      const config = this.configOverride || window.__SINAS_CONFIG__;
+      const config = this.options.config || (hasWindow() ? window.__SINAS_CONFIG__ : void 0);
       if (!config) {
         return {
-          apiBase: "",
+          apiBase: this.options.baseUrl ? `${trim(this.options.baseUrl)}/api/v1` : "",
           component: { namespace: "", name: "", version: "" },
           resources: {
             enabledAgents: [],
@@ -133,12 +263,56 @@ var SinasSDK = (() => {
     getInput() {
       return this.getConfig().input || {};
     }
+    /** Workspace base URL (root of the Sinas instance). Throws if unset. */
+    requireBaseUrl() {
+      const url = this.getBaseUrl();
+      if (!url) {
+        throw new SinasError(
+          "No baseUrl configured. Construct with `new SinasClient({ baseUrl })` for standalone use.",
+          0
+        );
+      }
+      return url;
+    }
+    getBaseUrl() {
+      if (this.options.baseUrl) return trim(this.options.baseUrl);
+      const apiBase = this.getConfig().apiBase;
+      if (!apiBase) return null;
+      return trim(apiBase).replace(/\/api\/v1$/, "");
+    }
+    // ─── Tokens ───
+    getAccessToken() {
+      if (this.options.getAccessToken) return this.options.getAccessToken();
+      if (hasWindow()) return window.__SINAS_AUTH_TOKEN__ ?? null;
+      return null;
+    }
+    getRefreshToken() {
+      return this.options.getRefreshToken ? this.options.getRefreshToken() : null;
+    }
+    async tryRefresh() {
+      const refreshToken = this.getRefreshToken();
+      if (!refreshToken) return null;
+      if (this.refreshInFlight) return this.refreshInFlight;
+      const baseUrl = this.getBaseUrl();
+      if (!baseUrl) return null;
+      this.refreshInFlight = (async () => {
+        try {
+          const resp = await refresh(baseUrl, refreshToken);
+          this.options.onTokenRefresh?.(resp.access_token);
+          return resp.access_token;
+        } catch {
+          return null;
+        } finally {
+          this.refreshInFlight = null;
+        }
+      })();
+      return this.refreshInFlight;
+    }
+    // ─── Headers / proxy ───
     getAuthHeaders() {
-      const token = window.__SINAS_AUTH_TOKEN__;
+      const token = this.getAccessToken();
       const headers = { "Content-Type": "application/json" };
-      if (token) {
-        headers["Authorization"] = `Bearer ${token}`;
-      }
+      if (token) headers["Authorization"] = `Bearer ${token}`;
       return headers;
     }
     getProxyBase() {
@@ -146,7 +320,8 @@ var SinasSDK = (() => {
       const comp = config.component;
       return `${config.apiBase}/components/${comp.namespace}/${comp.name}/proxy`;
     }
-    async fetch(url, options = {}) {
+    // ─── Fetch with refresh-on-401 ───
+    async fetch(url, options = {}, _retried = false) {
       const res = await fetch(url, {
         ...options,
         headers: {
@@ -154,15 +329,18 @@ var SinasSDK = (() => {
           ...options.headers || {}
         }
       });
-      if (!res.ok) {
-        const body = await res.json().catch(() => ({ detail: res.statusText }));
-        const message = body.detail || body.message || res.statusText;
-        if (res.status === 401) throw new SinasAuthError(message);
-        if (res.status === 403) throw new SinasPermissionError(message);
-        if (res.status === 404) throw new SinasNotFoundError(message);
-        throw new SinasError(message, res.status);
+      if (res.ok || res.status === 204) return res;
+      if (res.status === 401 && !_retried) {
+        const newToken = await this.tryRefresh();
+        if (newToken) return this.fetch(url, options, true);
+        this.options.onUnauthenticated?.();
       }
-      return res;
+      const body = await res.json().catch(() => ({ detail: res.statusText }));
+      const message = body.detail || body.message || res.statusText;
+      if (res.status === 401) throw new SinasAuthError(message);
+      if (res.status === 403) throw new SinasPermissionError(message);
+      if (res.status === 404) throw new SinasNotFoundError(message);
+      throw new SinasError(message, res.status);
     }
   };
 
@@ -219,6 +397,124 @@ var SinasSDK = (() => {
       error: data.error
     };
   }
+  async function enqueueFunction(client, ref, input = {}, options = {}) {
+    const [ns, name] = parseRef2(ref);
+    const baseUrl = client.requireBaseUrl();
+    const body = { input };
+    if (options.triggerId !== void 0) body.trigger_id = options.triggerId;
+    if (options.delaySeconds !== void 0) body.delay_seconds = options.delaySeconds;
+    if (options.callbackUrl !== void 0) body.callback_url = options.callbackUrl;
+    const res = await client.fetch(`${baseUrl}/functions/${ns}/${name}/execute/async`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const data = await res.json();
+    return {
+      executionId: data.execution_id,
+      status: data.status
+    };
+  }
+  async function submitFunctionBatch(client, ref, inputs, options = {}) {
+    const [ns, name] = parseRef2(ref);
+    const baseUrl = client.requireBaseUrl();
+    const body = { inputs };
+    if (options.triggerIdPrefix !== void 0) body.trigger_id_prefix = options.triggerIdPrefix;
+    if (options.delaySeconds !== void 0) body.delay_seconds = options.delaySeconds;
+    if (options.callbackUrl !== void 0) body.callback_url = options.callbackUrl;
+    if (options.batchCallbackUrl !== void 0) body.batch_callback_url = options.batchCallbackUrl;
+    const res = await client.fetch(`${baseUrl}/functions/${ns}/${name}/execute/batch`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const data = await res.json();
+    return {
+      batchId: data.batch_id,
+      executionIds: data.execution_ids,
+      total: data.total,
+      status: data.status
+    };
+  }
+  async function submitAgentBatch(client, ref, inputs, options = {}) {
+    const [ns, name] = parseRef2(ref);
+    const baseUrl = client.requireBaseUrl();
+    const body = {
+      inputs: inputs.map((item) => ({
+        input_variables: item.inputVariables || {},
+        message: item.message
+      }))
+    };
+    if (options.triggerIdPrefix !== void 0) body.trigger_id_prefix = options.triggerIdPrefix;
+    if (options.callbackUrl !== void 0) body.callback_url = options.callbackUrl;
+    if (options.batchCallbackUrl !== void 0) body.batch_callback_url = options.batchCallbackUrl;
+    const res = await client.fetch(`${baseUrl}/agents/${ns}/${name}/chats/batch`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const data = await res.json();
+    return {
+      batchId: data.batch_id,
+      executionIds: data.execution_ids,
+      chatIds: data.chat_ids,
+      total: data.total,
+      status: data.status
+    };
+  }
+  async function getBatch(client, batchId) {
+    const baseUrl = client.requireBaseUrl();
+    const res = await client.fetch(`${baseUrl}/batches/${batchId}`);
+    const data = await res.json();
+    return {
+      batchId: data.batch_id,
+      kind: data.kind,
+      target: data.target,
+      userId: data.user_id,
+      total: data.total,
+      completed: data.completed,
+      failed: data.failed,
+      cancelled: data.cancelled,
+      running: data.running,
+      queued: data.queued,
+      status: data.status,
+      startedAt: data.started_at,
+      finishedAt: data.finished_at,
+      triggerIdPrefix: data.trigger_id_prefix
+    };
+  }
+  async function listBatchExecutions(client, batchId, options = {}) {
+    const baseUrl = client.requireBaseUrl();
+    const params = new URLSearchParams();
+    if (options.status) params.set("status", options.status);
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.offset !== void 0) params.set("offset", String(options.offset));
+    const q = params.toString();
+    const res = await client.fetch(
+      `${baseUrl}/batches/${batchId}/executions${q ? "?" + q : ""}`
+    );
+    const data = await res.json();
+    return (data.executions || []).map((row) => ({
+      executionId: row.execution_id,
+      status: row.status,
+      functionName: row.function_name,
+      chatId: row.chat_id ?? null,
+      triggerId: row.trigger_id,
+      startedAt: row.started_at ?? null,
+      completedAt: row.completed_at ?? null,
+      durationMs: row.duration_ms ?? null,
+      error: row.error ?? null
+    }));
+  }
+  async function cancelBatch(client, batchId) {
+    const baseUrl = client.requireBaseUrl();
+    const res = await client.fetch(`${baseUrl}/batches/${batchId}/cancel`, {
+      method: "POST"
+    });
+    const data = await res.json();
+    return {
+      batchId: data.batch_id,
+      status: data.status,
+      cancelledChildren: data.cancelled_children
+    };
+  }
 
   // src/client/states.ts
   async function stateGet(client, ns, key) {
@@ -486,8 +782,14 @@ var SinasSDK = (() => {
   // src/hooks/context.ts
   var import_react = __toESM(require_react(), 1);
   var SinasContext = import_react.default.createContext(null);
-  function SinasProvider({ client, children }) {
-    const value = import_react.default.useMemo(() => client || new SinasClient(), [client]);
+  function SinasProvider({ client, options, children }) {
+    const value = import_react.default.useMemo(
+      () => client || new SinasClient(options),
+      // We intentionally only re-create when `client` reference changes; `options`
+      // is expected to be a stable object (callbacks reading from localStorage).
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [client]
+    );
     return import_react.default.createElement(SinasContext.Provider, { value }, children);
   }
   function useClient() {
@@ -962,6 +1264,81 @@ var SinasSDK = (() => {
       useChat
     };
   }
+
+  // src/hooks/useAuth.ts
+  var import_react6 = __toESM(require_react(), 1);
+  function useAuth(options = {}) {
+    const { autoRefresh = true } = options;
+    const client = useClient();
+    const [status, setStatus] = import_react6.default.useState("loading");
+    const [user, setUser] = import_react6.default.useState(null);
+    const [info, setInfo] = import_react6.default.useState(null);
+    const [error, setError] = import_react6.default.useState(null);
+    const refresh2 = import_react6.default.useCallback(async () => {
+      setError(null);
+      try {
+        const [infoResp, meResp] = await Promise.all([
+          client.auth.getInfo().catch(() => null),
+          client.getAccessToken() ? client.auth.getMe().catch(() => null) : Promise.resolve(null)
+        ]);
+        if (infoResp) setInfo(infoResp);
+        if (meResp) {
+          setUser(meResp);
+          setStatus("authenticated");
+        } else {
+          setUser(null);
+          setStatus("unauthenticated");
+        }
+      } catch (e) {
+        setError(e instanceof Error ? e.message : String(e));
+        setStatus("unauthenticated");
+      }
+    }, [client]);
+    import_react6.default.useEffect(() => {
+      if (autoRefresh) void refresh2();
+    }, [autoRefresh, refresh2]);
+    const login2 = import_react6.default.useCallback(
+      async (email, password) => {
+        setError(null);
+        try {
+          return await client.auth.login({ email, password });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          setError(msg);
+          throw e;
+        }
+      },
+      [client]
+    );
+    const verifyOTP2 = import_react6.default.useCallback(
+      async (sessionId, otpCode) => {
+        setError(null);
+        try {
+          return await client.auth.verifyOTP({ session_id: sessionId, otp_code: otpCode });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          setError(msg);
+          throw e;
+        }
+      },
+      [client]
+    );
+    const logout2 = import_react6.default.useCallback(
+      async (refreshToken) => {
+        if (refreshToken) {
+          try {
+            await client.auth.logout(refreshToken);
+          } catch (e) {
+            if (!(e instanceof SinasAuthError)) throw e;
+          }
+        }
+        setUser(null);
+        setStatus("unauthenticated");
+      },
+      [client]
+    );
+    return { status, user, info, error, refresh: refresh2, login: login2, verifyOTP: verifyOTP2, logout: logout2 };
+  }
   return __toCommonJS(src_exports);
 })();
 //# sourceMappingURL=sinas-sdk.umd.js.map