@sinas/sdk 0.4.0 → 0.7.0

package/dist/index.cjs

@@ -32,19 +32,30 @@ var src_exports = {};
 __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,
@@ -52,13 +63,17 @@ __export(src_exports, {
   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
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -96,16 +111,131 @@ var SinasTimeoutError = class extends SinasError {
   }
 };
 
+// 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: [],
@@ -122,12 +252,56 @@ var SinasClient = class {
   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() {
@@ -135,7 +309,8 @@ var SinasClient = class {
     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: {
@@ -143,15 +318,18 @@ var SinasClient = class {
         ...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);
   }
 };
 
@@ -208,6 +386,124 @@ async function executeFunction(client, ref, input = {}, timeout) {
     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) {
@@ -475,8 +771,14 @@ var import_react2 = __toESM(require("react"), 1);
 // 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() {
@@ -951,23 +1253,109 @@ function useSinas() {
     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 };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SinasAuthError,
   SinasClient,
+  SinasClientAuth,
   SinasError,
   SinasNotFoundError,
   SinasPermissionError,
   SinasProvider,
   SinasTimeoutError,
   approveToolCall,
+  cancelBatch,
+  checkPermissions,
   createChat,
+  enqueueFunction,
   executeFunction,
   executeQuery,
   generateFileUrl,
+  getBatch,
   getChat,
+  getInfo,
+  getMe,
+  listBatchExecutions,
   listCollections,
   listFiles,
+  login,
+  logout,
+  refresh,
   sendMessage,
   stateDelete,
   stateGet,
@@ -975,12 +1363,16 @@ function useSinas() {
   stateSet,
   streamFromChannel,
   streamMessage,
+  submitAgentBatch,
+  submitFunctionBatch,
   uploadFile,
+  useAuth,
   useChat,
   useClient,
   useExecute,
   useQuery,
   useSinas,
-  useStateStore
+  useStateStore,
+  verifyOTP
 });
 //# sourceMappingURL=index.cjs.map