@sinas/sdk 0.7.0 → 0.8.0

package/dist/index.js

@@ -6,6 +6,9 @@ import {
   SinasNotFoundError,
   SinasPermissionError,
   SinasTimeoutError,
+  answerPendingInput,
+  answerResumeChannel,
+  approvalResumeChannel,
   approveToolCall,
   cancelBatch,
   checkPermissions,
@@ -18,11 +21,17 @@ import {
   getChat,
   getInfo,
   getMe,
+  invokeAgent,
   listBatchExecutions,
   listCollections,
   listFiles,
+  listPendingInputs,
   login,
   logout,
+  parseApproval,
+  parsePendingInput,
+  parsePendingInputs,
+  pendingInputFromChunk,
   refresh,
   sendMessage,
   stateDelete,
@@ -35,7 +44,7 @@ import {
   submitFunctionBatch,
   uploadFile,
   verifyOTP
-} from "./chunk-QDIOYYBA.js";
+} from "./chunk-RHQVV5O6.js";
 
 // src/hooks/useQuery.ts
 import React2 from "react";
@@ -218,29 +227,172 @@ function useStateStore(ns, key) {
 
 // src/hooks/useChat.ts
 import React5 from "react";
+
+// src/hooks/chatState.ts
+function parseMessageChunk(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return { text: data };
+  }
+  if (!parsed || typeof parsed !== "object") return { text: "" };
+  const p = parsed;
+  const out = { text: typeof p.content === "string" ? p.content : "" };
+  if (typeof p.thinking === "string") out.thinking = p.thinking;
+  return out;
+}
+function applyTextDelta(messages, text, chatId, now = /* @__PURE__ */ new Date()) {
+  if (!text) return messages;
+  const last = messages[messages.length - 1];
+  if (last && last.role === "assistant" && !last.toolCalls && last.streaming) {
+    const next = [...messages];
+    next[next.length - 1] = { ...last, content: (last.content || "") + text };
+    return next;
+  }
+  return [
+    ...messages,
+    {
+      id: `tmp-text-${now.getTime()}`,
+      chatId,
+      role: "assistant",
+      content: text,
+      toolCalls: null,
+      toolCallId: null,
+      name: null,
+      createdAt: now.toISOString(),
+      streaming: true
+    }
+  ];
+}
+function applyToolStart(messages, event, chatId, now = /* @__PURE__ */ new Date()) {
+  if (messages.some((m) => m.toolCalls?.some((tc) => tc.id === event.tool_call_id))) return messages;
+  const frozen = messages.map(
+    (m, i) => i === messages.length - 1 && m.streaming && m.role === "assistant" && !m.toolCalls ? { ...m, streaming: false } : m
+  );
+  return [
+    ...frozen,
+    {
+      id: `tmp-tc-${event.tool_call_id}`,
+      chatId,
+      role: "assistant",
+      content: null,
+      toolCalls: [
+        {
+          id: event.tool_call_id,
+          type: "function",
+          function: { name: event.name, arguments: event.arguments || "{}" },
+          description: event.description
+        }
+      ],
+      toolCallId: null,
+      name: null,
+      createdAt: now.toISOString(),
+      streaming: true
+    }
+  ];
+}
+function applyToolEnd(messages, event) {
+  if (event.result === void 0) return messages;
+  const content = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+  return messages.map(
+    (m) => m.toolCalls?.some((tc) => tc.id === event.tool_call_id) ? { ...m, toolResults: { ...m.toolResults, [event.tool_call_id]: { content, name: event.name } } } : m
+  );
+}
+function addApproval(current, approval) {
+  return current.some((a) => a.toolCallId === approval.toolCallId) ? current : [...current, approval];
+}
+function mergePendingInputs(current, incoming) {
+  const seen = new Set(current.map((p) => p.toolCallId));
+  const added = incoming.filter((p) => !seen.has(p.toolCallId) && seen.add(p.toolCallId));
+  return added.length ? [...current, ...added] : current;
+}
+var NOT_THINKING = { active: false, rounds: [] };
+function applyThinking(state, thinking) {
+  if (!state.active) return { active: true, rounds: [...state.rounds, thinking] };
+  if (!thinking) return state;
+  const rounds = [...state.rounds];
+  rounds[rounds.length - 1] += thinking;
+  return { active: true, rounds };
+}
+function stopThinking(state) {
+  return state.active ? { ...state, active: false } : state;
+}
+function thinkingView(state) {
+  return { active: state.active, text: state.rounds.filter((r) => r).join("\n\n") };
+}
+function createLatestGate() {
+  let latest = 0;
+  return {
+    next: () => ++latest,
+    isCurrent: (ticket) => ticket === latest
+  };
+}
+var PENDING_POLL_MAX_MS = 3e4;
+var PENDING_POLL_MIN_MS = 1e3;
+var EXPIRY_GRACE_MS = 5e3;
+var OVERDUE_POLL_MS = 1e4;
+function nextPendingPollMs(inputs, nowMs) {
+  let wait = PENDING_POLL_MAX_MS;
+  for (const input of inputs) {
+    const deadline = input.expiresAt ? Date.parse(input.expiresAt) : NaN;
+    if (Number.isNaN(deadline)) continue;
+    const untilDue = deadline + EXPIRY_GRACE_MS - nowMs;
+    wait = Math.min(wait, untilDue > 0 ? untilDue : OVERDUE_POLL_MS);
+  }
+  return Math.max(PENDING_POLL_MIN_MS, wait);
+}
+var TRAILING_POLLS_MS = [5e3, 15e3, 3e4];
+
+// src/hooks/useChat.ts
 function useChat(agentRef, options) {
   const client = useClient();
+  const includeThinking = !!options?.includeThinking;
+  const pollPendingInputs = options?.pollPendingInputs !== false;
   const [chatId, setChatId] = React5.useState(options?.chatId ?? null);
   const [messages, setMessages] = React5.useState([]);
   const [loading, setLoading] = React5.useState(false);
   const [streaming, setStreaming] = React5.useState(false);
   const [error, setError] = React5.useState(null);
   const [pendingApprovals, setPendingApprovals] = React5.useState([]);
+  const [pendingInputs, setPendingInputs] = React5.useState([]);
+  const [thinking, setThinking] = React5.useState(NOT_THINKING);
+  const thinkingShown = React5.useMemo(() => thinkingView(thinking), [thinking]);
   const [toolStatus, setToolStatus] = React5.useState([]);
+  const [trailingPoll, setTrailingPoll] = React5.useState(TRAILING_POLLS_MS.length);
+  const [pollTick, setPollTick] = React5.useState(0);
   const abortRef = React5.useRef(null);
   const chatIdRef = React5.useRef(chatId);
   chatIdRef.current = chatId;
+  const [gate] = React5.useState(createLatestGate);
+  const refresh2 = React5.useCallback(
+    async (id) => {
+      const ticket = gate.next();
+      try {
+        const detail = await getChat(client, id);
+        if (!gate.isCurrent(ticket)) return null;
+        setMessages(detail.messages);
+        setPendingApprovals(detail.pendingApprovals ?? []);
+        const inputs = detail.pendingInputs ?? [];
+        setPendingInputs(inputs);
+        return inputs;
+      } catch {
+        return null;
+      }
+    },
+    [client, gate]
+  );
   React5.useEffect(() => {
     if (!options?.chatId) return;
     let cancelled = false;
+    const ticket = gate.next();
     setLoading(true);
     getChat(client, options.chatId).then((detail) => {
-      if (cancelled) return;
+      if (cancelled || !gate.isCurrent(ticket)) return;
       setChatId(detail.id);
       setMessages(detail.messages);
-      if (detail.pendingApprovals?.length) {
-        setPendingApprovals(detail.pendingApprovals);
-      }
+      setPendingApprovals(detail.pendingApprovals ?? []);
+      setPendingInputs(detail.pendingInputs ?? []);
     }).catch((e) => {
       if (cancelled) return;
       setError(e.message);
@@ -250,74 +402,52 @@ function useChat(agentRef, options) {
     return () => {
       cancelled = true;
     };
-  }, [client, options?.chatId]);
+  }, [client, gate, options?.chatId]);
   React5.useEffect(() => {
     return () => {
       abortRef.current?.abort();
     };
   }, []);
-  const handleStreamChunks = React5.useCallback(
+  React5.useEffect(() => {
+    if (!pollPendingInputs || streaming || !chatId) return;
+    let delay = null;
+    if (pendingInputs.length > 0) delay = nextPendingPollMs(pendingInputs, Date.now());
+    else if (trailingPoll < TRAILING_POLLS_MS.length) delay = TRAILING_POLLS_MS[trailingPoll];
+    if (delay === null) return;
+    const waiting = pendingInputs.map((p) => p.toolCallId);
+    const timer = setTimeout(async () => {
+      const now = await refresh2(chatId);
+      if (waiting.length === 0) setTrailingPoll((i) => i + 1);
+      else if (now && waiting.some((id) => !now.some((p) => p.toolCallId === id))) setTrailingPoll(0);
+      setPollTick((t) => t + 1);
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [pollPendingInputs, chatId, streaming, pendingInputs, trailingPoll, pollTick, refresh2]);
+  const handleStreamChunk = React5.useCallback(
     (chunk) => {
+      const asked = pendingInputFromChunk(chunk);
+      if (asked) {
+        setThinking(stopThinking);
+        setPendingInputs((prev) => mergePendingInputs(prev, [asked]));
+        return;
+      }
+      const chatIdNow = chatIdRef.current || "";
       if (chunk.event === "message") {
-        const newContent = (() => {
-          try {
-            const parsed = JSON.parse(chunk.data);
-            return parsed.content || "";
-          } catch {
-            return chunk.data;
-          }
-        })();
-        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
-          }];
-        });
+        const { text, thinking: thought } = parseMessageChunk(chunk.data);
+        if (thought !== void 0) setThinking((prev) => applyThinking(prev, thought));
+        if (text) {
+          setThinking(stopThinking);
+          setMessages((prev) => applyTextDelta(prev, text, chatIdNow));
+        }
       } else if (chunk.event === "tool_start") {
+        setThinking(stopThinking);
         try {
           const parsed = JSON.parse(chunk.data);
           setToolStatus((prev) => [
             ...prev,
             { toolCallId: parsed.tool_call_id, name: parsed.name, description: parsed.description, status: "running" }
           ]);
-          setMessages((prev) => {
-            if (prev.some((m) => m.toolCalls?.some((tc) => tc.id === parsed.tool_call_id))) {
-              return prev;
-            }
-            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
-            }];
-          });
+          setMessages((prev) => applyToolStart(prev, parsed, chatIdNow));
         } catch {
         }
       } else if (chunk.event === "tool_end") {
@@ -326,39 +456,18 @@ function useChat(agentRef, options) {
           setToolStatus(
             (prev) => prev.map((t) => t.toolCallId === parsed.tool_call_id ? { ...t, status: "complete" } : t)
           );
-          if (parsed.result !== void 0) {
-            const resultContent = typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result);
-            setMessages(
-              (prev) => prev.map((m) => {
-                if (m.toolCalls?.some((tc) => tc.id === parsed.tool_call_id)) {
-                  return {
-                    ...m,
-                    toolResults: {
-                      ...m.toolResults,
-                      [parsed.tool_call_id]: { content: resultContent, name: parsed.name }
-                    }
-                  };
-                }
-                return m;
-              })
-            );
-          }
+          setMessages((prev) => applyToolEnd(prev, parsed));
         } catch {
         }
       } else if (chunk.event === "approval_required") {
+        setThinking(stopThinking);
         try {
-          const raw = JSON.parse(chunk.data);
-          const parsed = {
-            type: raw.type,
-            toolCallId: raw.tool_call_id,
-            functionNamespace: raw.function_namespace,
-            functionName: raw.function_name,
-            arguments: raw.arguments
-          };
-          setPendingApprovals((prev) => [...prev, parsed]);
+          const approval = parseApproval(JSON.parse(chunk.data));
+          if (approval) setPendingApprovals((prev) => addApproval(prev, approval));
         } catch {
         }
       } else if (chunk.event === "error") {
+        setThinking(stopThinking);
         try {
           const parsed = JSON.parse(chunk.data);
           setError(parsed.error || "Stream error");
@@ -369,18 +478,37 @@ function useChat(agentRef, options) {
     },
     []
   );
-  const refreshMessages = React5.useCallback(
-    async (id) => {
-      try {
-        const detail = await getChat(client, id);
-        setMessages(detail.messages);
-        if (detail.pendingApprovals?.length) {
-          setPendingApprovals(detail.pendingApprovals);
-        }
-      } catch {
+  const streamCallbacks = React5.useCallback(
+    (id) => [
+      (_done) => {
+        setStreaming(false);
+        setToolStatus([]);
+        setThinking(stopThinking);
+        refresh2(id);
+      },
+      (err) => {
+        setError(err.message);
+        setStreaming(false);
+        setToolStatus([]);
+        setThinking(stopThinking);
       }
+    ],
+    [refresh2]
+  );
+  const followChannel = React5.useCallback(
+    (id, channelId, lastId) => {
+      abortRef.current?.abort();
+      gate.next();
+      setStreaming(true);
+      setError(null);
+      setThinking(NOT_THINKING);
+      const [onDone, onError] = streamCallbacks(id);
+      abortRef.current = streamFromChannel(client, id, channelId, handleStreamChunk, onDone, onError, {
+        includeThinking,
+        lastId
+      });
     },
-    [client]
+    [client, gate, includeThinking, handleStreamChunk, streamCallbacks]
   );
   const send = React5.useCallback(
     (content) => {
@@ -402,10 +530,12 @@ function useChat(agentRef, options) {
           setLoading(false);
         }
         abortRef.current?.abort();
+        gate.next();
         setStreaming(true);
         setError(null);
         setPendingApprovals([]);
         setToolStatus([]);
+        setThinking(NOT_THINKING);
         const displayContent = typeof content === "string" ? content : JSON.stringify(content);
         const userMsg = {
           id: `tmp-user-${Date.now()}`,
@@ -418,80 +548,77 @@ function useChat(agentRef, options) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         setMessages((prev) => [...prev, userMsg]);
-        const controller = streamMessage(
-          client,
-          activeChatId,
-          content,
-          handleStreamChunks,
-          () => {
-            setStreaming(false);
-            setToolStatus([]);
-            refreshMessages(activeChatId);
-          },
-          (err) => {
-            setError(err.message);
-            setStreaming(false);
-            setToolStatus([]);
-          }
-        );
-        abortRef.current = controller;
+        const [onDone, onError] = streamCallbacks(activeChatId);
+        abortRef.current = streamMessage(client, activeChatId, content, handleStreamChunk, onDone, onError, {
+          includeThinking
+        });
       };
       doSend();
     },
-    [client, agentRef, options?.input, handleStreamChunks, refreshMessages]
+    [client, agentRef, options?.input, gate, includeThinking, handleStreamChunk, streamCallbacks]
   );
-  const handleApproval = React5.useCallback(
-    (toolCallId, approved) => {
-      const currentChatId = chatIdRef.current;
-      if (!currentChatId) return;
+  const decide = React5.useCallback(
+    (toolCallId, approved, alwaysAllow) => {
+      const id = chatIdRef.current;
+      if (!id) return;
+      gate.next();
       setPendingApprovals((prev) => prev.filter((a) => a.toolCallId !== toolCallId));
-      setStreaming(true);
       setError(null);
       (async () => {
         try {
-          const result = await approveToolCall(client, currentChatId, toolCallId, approved);
-          if (!approved) {
-            setStreaming(false);
-            refreshMessages(currentChatId);
-            return;
-          }
-          const controller = streamFromChannel(
-            client,
-            currentChatId,
-            result.channelId,
-            handleStreamChunks,
-            () => {
-              setStreaming(false);
-              setToolStatus([]);
-              refreshMessages(currentChatId);
-            },
-            (err) => {
-              setError(err.message);
-              setStreaming(false);
-              setToolStatus([]);
-            }
-          );
-          abortRef.current = controller;
+          const result = await approveToolCall(client, id, toolCallId, approved, { alwaysAllow });
+          const channelId = approvalResumeChannel(result, approved);
+          if (channelId) followChannel(id, channelId);
+          else if (result.resume === void 0) refresh2(id);
         } catch (e) {
           setError(e.message);
-          setStreaming(false);
+          refresh2(id);
         }
       })();
     },
-    [client, handleStreamChunks, refreshMessages]
+    [client, gate, followChannel, refresh2]
   );
   const approve = React5.useCallback(
-    (toolCallId) => handleApproval(toolCallId, true),
-    [handleApproval]
+    (toolCallId, opts) => decide(toolCallId, true, !!opts?.alwaysAllow),
+    [decide]
   );
   const reject = React5.useCallback(
-    (toolCallId) => handleApproval(toolCallId, false),
-    [handleApproval]
+    (toolCallId) => decide(toolCallId, false, false),
+    [decide]
+  );
+  const answer = React5.useCallback(
+    async (toolCallId, text) => {
+      const id = chatIdRef.current;
+      if (!id) return false;
+      setError(null);
+      try {
+        const result = await answerPendingInput(client, id, toolCallId, text);
+        gate.next();
+        setPendingInputs((prev) => prev.filter((p) => p.toolCallId !== toolCallId));
+        const channelId = answerResumeChannel(result);
+        if (channelId) followChannel(id, channelId);
+        return true;
+      } catch (e) {
+        setError(e.message);
+        refresh2(id);
+        return false;
+      }
+    },
+    [client, gate, followChannel, refresh2]
+  );
+  const follow = React5.useCallback(
+    (channelId, opts) => {
+      const id = chatIdRef.current;
+      if (!id) return;
+      followChannel(id, channelId, opts?.lastId);
+    },
+    [followChannel]
   );
   const stop = React5.useCallback(() => {
     abortRef.current?.abort();
     abortRef.current = null;
     setStreaming(false);
+    setThinking(stopThinking);
   }, []);
   const clearError = React5.useCallback(() => {
     setError(null);
@@ -503,10 +630,14 @@ function useChat(agentRef, options) {
     streaming,
     error,
     pendingApprovals,
+    pendingInputs,
+    thinking: thinkingShown,
     toolStatus,
     send,
     approve,
     reject,
+    answer,
+    follow,
     stop,
     clearError
   };
@@ -609,6 +740,9 @@ export {
   SinasPermissionError,
   SinasProvider,
   SinasTimeoutError,
+  answerPendingInput,
+  answerResumeChannel,
+  approvalResumeChannel,
   approveToolCall,
   cancelBatch,
   checkPermissions,
@@ -621,11 +755,16 @@ export {
   getChat,
   getInfo,
   getMe,
+  invokeAgent,
   listBatchExecutions,
   listCollections,
   listFiles,
+  listPendingInputs,
   login,
   logout,
+  parsePendingInput,
+  parsePendingInputs,
+  pendingInputFromChunk,
   refresh,
   sendMessage,
   stateDelete,