@sinas/sdk 0.1.1 → 0.2.1

package/dist/client.js

@@ -5,16 +5,21 @@ import {
   SinasNotFoundError,
   SinasPermissionError,
   SinasTimeoutError,
+  approveToolCall,
   createChat,
   executeFunction,
   executeQuery,
+  getChat,
+  listCollections,
+  listFiles,
   sendMessage,
   stateDelete,
   stateGet,
   stateList,
   stateSet,
+  streamFromChannel,
   streamMessage
-} from "./chunk-M7YHE5Y6.js";
+} from "./chunk-EV5ARSUJ.js";
 export {
   SinasAuthError,
   SinasClient,
@@ -22,14 +27,19 @@ export {
   SinasNotFoundError,
   SinasPermissionError,
   SinasTimeoutError,
+  approveToolCall,
   createChat,
   executeFunction,
   executeQuery,
+  getChat,
+  listCollections,
+  listFiles,
   sendMessage,
   stateDelete,
   stateGet,
   stateList,
   stateSet,
+  streamFromChannel,
   streamMessage
 };
 //# sourceMappingURL=client.js.map

package/dist/index.cjs

@@ -37,14 +37,19 @@ __export(src_exports, {
   SinasPermissionError: () => SinasPermissionError,
   SinasProvider: () => SinasProvider,
   SinasTimeoutError: () => SinasTimeoutError,
+  approveToolCall: () => approveToolCall,
   createChat: () => createChat,
   executeFunction: () => executeFunction,
   executeQuery: () => executeQuery,
+  getChat: () => getChat,
+  listCollections: () => listCollections,
+  listFiles: () => listFiles,
   sendMessage: () => sendMessage,
   stateDelete: () => stateDelete,
   stateGet: () => stateGet,
   stateList: () => stateList,
   stateSet: () => stateSet,
+  streamFromChannel: () => streamFromChannel,
   streamMessage: () => streamMessage,
   useChat: () => useChat,
   useExecute: () => useExecute,
@@ -268,6 +273,88 @@ async function sendMessage(client, chatId, content) {
     createdAt: data.created_at
   };
 }
+function mapMessage(data) {
+  const toolCalls = data.tool_calls;
+  return {
+    id: data.id,
+    chatId: data.chat_id,
+    role: data.role,
+    content: data.content ?? null,
+    toolCalls: toolCalls ?? null,
+    toolCallId: data.tool_call_id ?? null,
+    name: data.name ?? null,
+    createdAt: data.created_at
+  };
+}
+async function getChat(client, chatId) {
+  const config = client.getConfig();
+  const res = await client.fetch(`${config.apiBase}/chats/${chatId}`);
+  const data = await res.json();
+  return {
+    id: data.id,
+    agentNamespace: data.agent_namespace,
+    agentName: data.agent_name,
+    title: data.title,
+    messages: (data.messages || []).map(mapMessage)
+  };
+}
+async function approveToolCall(client, chatId, toolCallId, approved) {
+  const config = client.getConfig();
+  const res = await client.fetch(
+    `${config.apiBase}/chats/${chatId}/approve-tool/${toolCallId}`,
+    { method: "POST", body: JSON.stringify({ approved }) }
+  );
+  const data = await res.json();
+  return {
+    status: data.status,
+    toolCallId: data.tool_call_id,
+    channelId: data.channel_id
+  };
+}
+function streamFromChannel(client, chatId, channelId, onChunk, onDone, onError) {
+  const controller = new AbortController();
+  const config = client.getConfig();
+  (async () => {
+    try {
+      const res = await fetch(
+        `${config.apiBase}/chats/${chatId}/stream/${channelId}?last_id=0`,
+        { headers: client.getAuthHeaders(), signal: controller.signal }
+      );
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ detail: res.statusText }));
+        throw new Error(body.detail || "Stream reconnect failed");
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const { chunks, remaining } = parseSSE(buffer);
+        buffer = remaining;
+        for (const chunk of chunks) {
+          onChunk(chunk);
+          if (chunk.event === "done") {
+            onDone?.();
+            return;
+          }
+        }
+      }
+      if (buffer.trim()) {
+        const { chunks } = parseSSE(buffer + "\n\n");
+        for (const chunk of chunks) {
+          onChunk(chunk);
+        }
+      }
+      onDone?.();
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      onError?.(err);
+    }
+  })();
+  return controller;
+}
 function parseSSE(buffer) {
   const chunks = [];
   const lines = buffer.split("\n");
@@ -341,6 +428,18 @@ function streamMessage(client, chatId, content, onChunk, onDone, onError) {
   return controller;
 }
 
+// src/client/collections.ts
+async function listCollections(client) {
+  const base = client.getProxyBase();
+  const res = await client.fetch(`${base}/collections`);
+  return res.json();
+}
+async function listFiles(client, namespace, collection) {
+  const base = client.getProxyBase();
+  const res = await client.fetch(`${base}/files/${namespace}/${collection}`);
+  return res.json();
+}
+
 // src/hooks/useQuery.ts
 var import_react2 = __toESM(require("react"), 1);
 
@@ -516,125 +615,318 @@ function useStateStore(ns, key) {
 
 // src/hooks/useChat.ts
 var import_react5 = __toESM(require("react"), 1);
-function useChat(agentRef) {
+function useChat(agentRef, options) {
   const client = useClient();
-  const [chatId, setChatId] = import_react5.default.useState(null);
+  const [chatId, setChatId] = import_react5.default.useState(options?.chatId ?? null);
   const [messages, setMessages] = import_react5.default.useState([]);
   const [loading, setLoading] = import_react5.default.useState(false);
   const [streaming, setStreaming] = import_react5.default.useState(false);
   const [error, setError] = import_react5.default.useState(null);
+  const [pendingApprovals, setPendingApprovals] = import_react5.default.useState([]);
+  const [toolStatus, setToolStatus] = import_react5.default.useState([]);
   const abortRef = import_react5.default.useRef(null);
+  const chatIdRef = import_react5.default.useRef(chatId);
+  chatIdRef.current = chatId;
+  const activeAssistantIdRef = import_react5.default.useRef("");
+  import_react5.default.useEffect(() => {
+    if (!options?.chatId) return;
+    let cancelled = false;
+    setLoading(true);
+    getChat(client, options.chatId).then((detail) => {
+      if (cancelled) return;
+      setChatId(detail.id);
+      setMessages(detail.messages);
+    }).catch((e) => {
+      if (cancelled) return;
+      setError(e.message);
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, options?.chatId]);
   import_react5.default.useEffect(() => {
     return () => {
       abortRef.current?.abort();
     };
   }, []);
-  const doCreateChat = import_react5.default.useCallback(
-    async (input) => {
-      setLoading(true);
-      setError(null);
-      try {
-        const result = await createChat(client, agentRef, input);
-        setChatId(result.id);
-        setMessages([]);
-        return result.id;
-      } catch (e) {
-        setError(e.message);
-      } finally {
-        setLoading(false);
+  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
+              )
+            );
+          }
+        } catch {
+          const targetId = activeAssistantIdRef.current;
+          setMessages(
+            (prev) => prev.map(
+              (m) => m.id === targetId ? { ...m, content: (m.content || "") + chunk.data } : m
+            )
+          );
+        }
+      } else if (chunk.event === "tool_start") {
+        try {
+          const parsed = JSON.parse(chunk.data);
+          setToolStatus((prev) => [
+            ...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 || "{}" }
+            }],
+            toolCallId: null,
+            name: null,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          setMessages((prev) => {
+            const filtered = prev.filter(
+              (m) => !(m.id === placeholderId && m.streaming && !m.content)
+            );
+            return [...filtered, toolCallMsg];
+          });
+        } catch {
+        }
+      } else if (chunk.event === "tool_end") {
+        try {
+          const parsed = JSON.parse(chunk.data);
+          setToolStatus(
+            (prev) => prev.map((t) => t.toolCallId === parsed.tool_call_id ? { ...t, status: "complete" } : t)
+          );
+          if (parsed.result !== void 0) {
+            const toolResultMsg = {
+              id: `tmp-tr-${parsed.tool_call_id}`,
+              chatId: chatIdRef.current || "",
+              role: "tool",
+              content: typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result),
+              toolCalls: null,
+              toolCallId: parsed.tool_call_id,
+              name: parsed.name,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            setMessages((prev) => [...prev, toolResultMsg]);
+          }
+          setToolStatus((currentStatus) => {
+            const stillRunning = currentStatus.filter((t) => t.status === "running");
+            if (stillRunning.length === 0) {
+              const newAssistantId = `tmp-assistant-${Date.now()}`;
+              activeAssistantIdRef.current = newAssistantId;
+              const newMsg = {
+                id: newAssistantId,
+                chatId: chatIdRef.current || "",
+                role: "assistant",
+                content: "",
+                toolCalls: null,
+                toolCallId: null,
+                name: null,
+                createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                streaming: true
+              };
+              setMessages((prev) => [...prev, newMsg]);
+            }
+            return currentStatus;
+          });
+        } catch {
+        }
+      } else if (chunk.event === "approval_required") {
+        try {
+          const parsed = JSON.parse(chunk.data);
+          setPendingApprovals((prev) => [...prev, parsed]);
+        } catch {
+        }
+      } else if (chunk.event === "error") {
+        try {
+          const parsed = JSON.parse(chunk.data);
+          setError(parsed.error || "Stream error");
+        } catch {
+          setError(chunk.data || "Stream error");
+        }
       }
     },
-    [client, agentRef]
+    []
   );
-  const doSendMessage = import_react5.default.useCallback(
-    async (content) => {
-      if (!chatId) {
-        setError("No active chat. Call createChat first.");
-        return;
-      }
-      setLoading(true);
-      setError(null);
-      const userMsg = {
-        id: `tmp-${Date.now()}`,
-        chatId,
-        role: "user",
-        content,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setMessages((prev) => [...prev, userMsg]);
+  const refreshMessages = import_react5.default.useCallback(
+    async (id) => {
       try {
-        const msg = await sendMessage(client, chatId, content);
-        setMessages((prev) => [...prev, msg]);
-        return msg;
-      } catch (e) {
-        setError(e.message);
-      } finally {
-        setLoading(false);
+        const detail = await getChat(client, id);
+        setMessages(detail.messages);
+      } catch {
       }
     },
-    [client, chatId]
+    [client]
   );
-  const doStreamMessage = import_react5.default.useCallback(
+  const send = import_react5.default.useCallback(
     (content) => {
-      if (!chatId) {
-        setError("No active chat. Call createChat first.");
-        return;
-      }
-      abortRef.current?.abort();
+      const doSend = async () => {
+        let activeChatId = chatIdRef.current;
+        if (!activeChatId) {
+          setLoading(true);
+          setError(null);
+          try {
+            const result = await createChat(client, agentRef, options?.input);
+            activeChatId = result.id;
+            setChatId(result.id);
+            chatIdRef.current = result.id;
+          } catch (e) {
+            setError(e.message);
+            setLoading(false);
+            return;
+          }
+          setLoading(false);
+        }
+        abortRef.current?.abort();
+        setStreaming(true);
+        setError(null);
+        setPendingApprovals([]);
+        setToolStatus([]);
+        const displayContent = typeof content === "string" ? content : JSON.stringify(content);
+        const userMsg = {
+          id: `tmp-user-${Date.now()}`,
+          chatId: activeChatId,
+          role: "user",
+          content: displayContent,
+          toolCalls: null,
+          toolCallId: null,
+          name: null,
+          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,
+          content,
+          handleStreamChunks,
+          () => {
+            setStreaming(false);
+            setToolStatus([]);
+            refreshMessages(activeChatId);
+          },
+          (err) => {
+            setError(err.message);
+            setStreaming(false);
+            setToolStatus([]);
+          }
+        );
+        abortRef.current = controller;
+      };
+      doSend();
+    },
+    [client, agentRef, options?.input, handleStreamChunks, refreshMessages]
+  );
+  const handleApproval = import_react5.default.useCallback(
+    (toolCallId, approved) => {
+      const currentChatId = chatIdRef.current;
+      if (!currentChatId) return;
+      setPendingApprovals((prev) => prev.filter((a) => a.toolCallId !== toolCallId));
       setStreaming(true);
       setError(null);
-      const userMsg = {
-        id: `tmp-${Date.now()}`,
-        chatId,
-        role: "user",
-        content,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setMessages((prev) => [...prev, userMsg]);
-      const assistantId = `stream-${Date.now()}`;
-      const assistantMsg = {
-        id: assistantId,
-        chatId,
-        role: "assistant",
-        content: "",
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setMessages((prev) => [...prev, assistantMsg]);
-      const controller = streamMessage(
-        client,
-        chatId,
-        content,
-        (chunk) => {
-          if (chunk.event === "content" || chunk.event === "message") {
-            setMessages(
-              (prev) => prev.map(
-                (m) => m.id === assistantId ? { ...m, content: m.content + chunk.data } : m
-              )
-            );
+      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);
+          if (!approved) {
+            setStreaming(false);
+            refreshMessages(currentChatId);
+            return;
           }
-        },
-        () => {
-          setStreaming(false);
-        },
-        (err) => {
-          setError(err.message);
+          const controller = streamFromChannel(
+            client,
+            currentChatId,
+            result.channelId,
+            handleStreamChunks,
+            () => {
+              setStreaming(false);
+              setToolStatus([]);
+              refreshMessages(currentChatId);
+            },
+            (err) => {
+              setError(err.message);
+              setStreaming(false);
+              setToolStatus([]);
+            }
+          );
+          abortRef.current = controller;
+        } catch (e) {
+          setError(e.message);
           setStreaming(false);
         }
-      );
-      abortRef.current = controller;
-      return controller;
+      })();
     },
-    [client, chatId]
+    [client, handleStreamChunks, refreshMessages]
+  );
+  const approve = import_react5.default.useCallback(
+    (toolCallId) => handleApproval(toolCallId, true),
+    [handleApproval]
   );
+  const reject = import_react5.default.useCallback(
+    (toolCallId) => handleApproval(toolCallId, false),
+    [handleApproval]
+  );
+  const stop = import_react5.default.useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    setStreaming(false);
+  }, []);
+  const clearError = import_react5.default.useCallback(() => {
+    setError(null);
+  }, []);
   return {
     chatId,
     messages,
     loading,
     streaming,
     error,
-    createChat: doCreateChat,
-    sendMessage: doSendMessage,
-    streamMessage: doStreamMessage
+    pendingApprovals,
+    toolStatus,
+    send,
+    approve,
+    reject,
+    stop,
+    clearError
   };
 }
 
@@ -660,14 +952,19 @@ function useSinas() {
   SinasPermissionError,
   SinasProvider,
   SinasTimeoutError,
+  approveToolCall,
   createChat,
   executeFunction,
   executeQuery,
+  getChat,
+  listCollections,
+  listFiles,
   sendMessage,
   stateDelete,
   stateGet,
   stateList,
   stateSet,
+  streamFromChannel,
   streamMessage,
   useChat,
   useExecute,