@sinas/sdk 0.2.3 → 0.5.0

package/dist/sinas-sdk.umd.js

@@ -44,19 +44,26 @@ var SinasSDK = (() => {
   __export(src_exports, {
     SinasAuthError: () => SinasAuthError,
     SinasClient: () => SinasClient,
+    SinasClientAuth: () => SinasClientAuth,
     SinasError: () => SinasError,
     SinasNotFoundError: () => SinasNotFoundError,
     SinasPermissionError: () => SinasPermissionError,
     SinasProvider: () => SinasProvider,
     SinasTimeoutError: () => SinasTimeoutError,
     approveToolCall: () => approveToolCall,
+    checkPermissions: () => checkPermissions,
     createChat: () => createChat,
     executeFunction: () => executeFunction,
     executeQuery: () => executeQuery,
     generateFileUrl: () => generateFileUrl,
     getChat: () => getChat,
+    getInfo: () => getInfo,
+    getMe: () => getMe,
     listCollections: () => listCollections,
     listFiles: () => listFiles,
+    login: () => login,
+    logout: () => logout,
+    refresh: () => refresh,
     sendMessage: () => sendMessage,
     stateDelete: () => stateDelete,
     stateGet: () => stateGet,
@@ -65,12 +72,14 @@ var SinasSDK = (() => {
     streamFromChannel: () => streamFromChannel,
     streamMessage: () => streamMessage,
     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 +116,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 +257,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 +314,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 +323,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);
     }
   };
 
@@ -486,8 +658,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() {
@@ -667,8 +845,6 @@ var SinasSDK = (() => {
     const abortRef = import_react5.default.useRef(null);
     const chatIdRef = import_react5.default.useRef(chatId);
     chatIdRef.current = chatId;
-    const activeAssistantIdRef = import_react5.default.useRef("");
-    const activeToolCallMsgIdRef = import_react5.default.useRef("");
     import_react5.default.useEffect(() => {
       if (!options?.chatId) return;
       let cancelled = false;
@@ -698,24 +874,34 @@ var SinasSDK = (() => {
     const handleStreamChunks = import_react5.default.useCallback(
       (chunk) => {
         if (chunk.event === "message") {
-          try {
-            const parsed = JSON.parse(chunk.data);
-            if (parsed.content) {
-              const targetId = activeAssistantIdRef.current;
-              setMessages(
-                (prev) => prev.map(
-                  (m) => m.id === targetId ? { ...m, content: (m.content || "") + parsed.content } : m
-                )
-              );
+          const newContent = (() => {
+            try {
+              const parsed = JSON.parse(chunk.data);
+              return parsed.content || "";
+            } catch {
+              return chunk.data;
             }
-          } catch {
-            const targetId = activeAssistantIdRef.current;
-            setMessages(
-              (prev) => prev.map(
-                (m) => m.id === targetId ? { ...m, content: (m.content || "") + chunk.data } : m
-              )
-            );
-          }
+          })();
+          if (!newContent) return;
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            if (last && last.role === "assistant" && !last.toolCalls && last.streaming) {
+              const next = [...prev];
+              next[next.length - 1] = { ...last, content: (last.content || "") + newContent };
+              return next;
+            }
+            return [...prev, {
+              id: `tmp-text-${Date.now()}`,
+              chatId: chatIdRef.current || "",
+              role: "assistant",
+              content: newContent,
+              toolCalls: null,
+              toolCallId: null,
+              name: null,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              streaming: true
+            }];
+          });
         } else if (chunk.event === "tool_start") {
           try {
             const parsed = JSON.parse(chunk.data);
@@ -723,35 +909,29 @@ var SinasSDK = (() => {
               ...prev,
               { toolCallId: parsed.tool_call_id, name: parsed.name, description: parsed.description, status: "running" }
             ]);
-            const placeholderId = activeAssistantIdRef.current;
-            const toolCallMsg = {
-              id: `tmp-tc-${parsed.tool_call_id}`,
-              chatId: chatIdRef.current || "",
-              role: "assistant",
-              content: null,
-              toolCalls: [{
-                id: parsed.tool_call_id,
-                type: "function",
-                function: { name: parsed.name, arguments: parsed.arguments || "{}" },
-                description: parsed.description
-              }],
-              toolCallId: null,
-              name: null,
-              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-              streaming: true
-            };
             setMessages((prev) => {
-              const alreadyExists = prev.some(
-                (m) => m.toolCalls?.some((tc) => tc.id === parsed.tool_call_id)
-              );
-              if (alreadyExists) return prev;
-              const idx = prev.findIndex((m) => m.id === placeholderId);
-              if (idx >= 0) {
-                const next = [...prev];
-                next.splice(idx, 0, toolCallMsg);
-                return next;
+              if (prev.some((m) => m.toolCalls?.some((tc) => tc.id === parsed.tool_call_id))) {
+                return prev;
               }
-              return [...prev, toolCallMsg];
+              const next = prev.map(
+                (m, i) => i === prev.length - 1 && m.streaming && m.role === "assistant" && !m.toolCalls ? { ...m, streaming: false } : m
+              );
+              return [...next, {
+                id: `tmp-tc-${parsed.tool_call_id}`,
+                chatId: chatIdRef.current || "",
+                role: "assistant",
+                content: null,
+                toolCalls: [{
+                  id: parsed.tool_call_id,
+                  type: "function",
+                  function: { name: parsed.name, arguments: parsed.arguments || "{}" },
+                  description: parsed.description
+                }],
+                toolCallId: null,
+                name: null,
+                createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                streaming: true
+              }];
             });
           } catch {
           }
@@ -853,20 +1033,6 @@ var SinasSDK = (() => {
             createdAt: (/* @__PURE__ */ new Date()).toISOString()
           };
           setMessages((prev) => [...prev, userMsg]);
-          const assistantId = `tmp-assistant-${Date.now()}`;
-          activeAssistantIdRef.current = assistantId;
-          const assistantMsg = {
-            id: assistantId,
-            chatId: activeChatId,
-            role: "assistant",
-            content: "",
-            toolCalls: null,
-            toolCallId: null,
-            name: null,
-            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-            streaming: true
-          };
-          setMessages((prev) => [...prev, assistantMsg]);
           const controller = streamMessage(
             client,
             activeChatId,
@@ -875,11 +1041,6 @@ var SinasSDK = (() => {
             () => {
               setStreaming(false);
               setToolStatus([]);
-              setMessages(
-                (prev) => prev.filter(
-                  (m) => !(m.streaming && m.role === "assistant" && !m.content && !m.toolCalls)
-                )
-              );
               refreshMessages(activeChatId);
             },
             (err) => {
@@ -901,22 +1062,6 @@ var SinasSDK = (() => {
         setPendingApprovals((prev) => prev.filter((a) => a.toolCallId !== toolCallId));
         setStreaming(true);
         setError(null);
-        const assistantId = `tmp-resume-${Date.now()}`;
-        activeAssistantIdRef.current = assistantId;
-        if (approved) {
-          const assistantMsg = {
-            id: assistantId,
-            chatId: currentChatId,
-            role: "assistant",
-            content: "",
-            toolCalls: null,
-            toolCallId: null,
-            name: null,
-            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-            streaming: true
-          };
-          setMessages((prev) => [...prev, assistantMsg]);
-        }
         (async () => {
           try {
             const result = await approveToolCall(client, currentChatId, toolCallId, approved);
@@ -995,6 +1140,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