@sinas/sdk 0.1.1 → 0.2.1

package/dist/sinas-sdk.umd.js

@@ -49,14 +49,19 @@ var SinasSDK = (() => {
     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,
@@ -279,6 +284,88 @@ var SinasSDK = (() => {
       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");
@@ -352,6 +439,18 @@ var SinasSDK = (() => {
     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);
 
@@ -527,125 +626,318 @@ var SinasSDK = (() => {
 
   // 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
     };
   }