@sinas/sdk 0.5.0 → 0.8.0

package/dist/index.cjs

@@ -38,19 +38,31 @@ __export(src_exports, {
   SinasPermissionError: () => SinasPermissionError,
   SinasProvider: () => SinasProvider,
   SinasTimeoutError: () => SinasTimeoutError,
+  answerPendingInput: () => answerPendingInput,
+  answerResumeChannel: () => answerResumeChannel,
+  approvalResumeChannel: () => approvalResumeChannel,
   approveToolCall: () => approveToolCall,
+  cancelBatch: () => cancelBatch,
   checkPermissions: () => checkPermissions,
   createChat: () => createChat,
+  enqueueFunction: () => enqueueFunction,
   executeFunction: () => executeFunction,
   executeQuery: () => executeQuery,
   generateFileUrl: () => generateFileUrl,
+  getBatch: () => getBatch,
   getChat: () => getChat,
   getInfo: () => getInfo,
   getMe: () => getMe,
+  invokeAgent: () => invokeAgent,
+  listBatchExecutions: () => listBatchExecutions,
   listCollections: () => listCollections,
   listFiles: () => listFiles,
+  listPendingInputs: () => listPendingInputs,
   login: () => login,
   logout: () => logout,
+  parsePendingInput: () => parsePendingInput,
+  parsePendingInputs: () => parsePendingInputs,
+  pendingInputFromChunk: () => pendingInputFromChunk,
   refresh: () => refresh,
   sendMessage: () => sendMessage,
   stateDelete: () => stateDelete,
@@ -59,6 +71,8 @@ __export(src_exports, {
   stateSet: () => stateSet,
   streamFromChannel: () => streamFromChannel,
   streamMessage: () => streamMessage,
+  submitAgentBatch: () => submitAgentBatch,
+  submitFunctionBatch: () => submitFunctionBatch,
   uploadFile: () => uploadFile,
   useAuth: () => useAuth,
   useChat: () => useChat,
@@ -380,6 +394,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) {
@@ -413,12 +545,111 @@ async function stateList(client, ns) {
   return res.json();
 }
 
+// src/client/chatEvents.ts
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? v : null;
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var optionsOf = (v) => Array.isArray(v) && v.length > 0 && v.every((o) => typeof o === "string") ? v : null;
+function parsePendingInput(raw) {
+  if (!isObject(raw)) return null;
+  if (typeof raw.tool_call_id !== "string" || !raw.tool_call_id) return null;
+  return {
+    toolCallId: raw.tool_call_id,
+    question: str(raw.question) ?? "",
+    options: optionsOf(raw.options),
+    expiresAt: str(raw.expires_at),
+    createdAt: str(raw.created_at)
+  };
+}
+function parsePendingInputs(raw) {
+  return Array.isArray(raw) ? raw.map(parsePendingInput).filter((p) => p !== null) : [];
+}
+function pendingInputFromChunk(chunk) {
+  if (chunk.event !== "input_required" && chunk.event !== "message") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(chunk.data);
+  } catch {
+    return null;
+  }
+  if (chunk.event === "message" && (!isObject(parsed) || parsed.type !== "input_required")) return null;
+  return parsePendingInput(parsed);
+}
+function parseApproval(raw) {
+  if (!isObject(raw) || typeof raw.tool_call_id !== "string") return null;
+  return {
+    type: str(raw.type) ?? "approval_required",
+    toolCallId: raw.tool_call_id,
+    functionNamespace: str(raw.function_namespace) ?? "",
+    functionName: str(raw.function_name) ?? "",
+    arguments: isObject(raw.arguments) ? raw.arguments : {}
+  };
+}
+function parseUsage(raw) {
+  if (!isObject(raw)) return null;
+  return {
+    calls: num(raw.calls),
+    promptTokens: num(raw.prompt_tokens),
+    completionTokens: num(raw.completion_tokens),
+    totalTokens: num(raw.total_tokens),
+    cacheReadTokens: num(raw.cache_read_tokens),
+    cacheWriteTokens: num(raw.cache_write_tokens),
+    costUsd: typeof raw.cost_usd === "number" ? raw.cost_usd : null,
+    unpricedCalls: num(raw.unpriced_calls),
+    errors: num(raw.errors)
+  };
+}
+var TURN_STATUSES = ["completed", "input_required", "in_progress", "injected"];
+function parseTurnState(raw) {
+  const status = TURN_STATUSES.includes(raw.status) ? raw.status : "completed";
+  return {
+    status,
+    pendingInputs: parsePendingInputs(raw.pending_inputs),
+    channelId: str(raw.channel_id),
+    usage: parseUsage(raw.usage)
+  };
+}
+function parseMessage(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
+  };
+}
+function parseDone(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (isObject(parsed) && typeof parsed.status === "string") return { status: parsed.status };
+  } catch {
+  }
+  return { status: "completed" };
+}
+function approvalResumeChannel(result, approved = true) {
+  if (result.resume === "waiting") return null;
+  if (result.resume === void 0 && !approved) return null;
+  return result.channelId || null;
+}
+function answerResumeChannel(result) {
+  if (!result.resumed && !result.resumePending) return null;
+  return result.channelId || null;
+}
+
 // src/client/chat.ts
-async function createChat(client, agentRef, input) {
+function splitAgentRef(agentRef) {
   const [ns, name] = agentRef.split("/");
   if (!ns || !name) {
     throw new Error(`Invalid agent ref "${agentRef}": expected "namespace/name"`);
   }
+  return [ns, name];
+}
+async function createChat(client, agentRef, input) {
+  const [ns, name] = splitAgentRef(agentRef);
   const config = client.getConfig();
   const res = await client.fetch(`${config.apiBase}/agents/${ns}/${name}/chats`, {
     method: "POST",
@@ -444,66 +675,117 @@ async function sendMessage(client, chatId, content) {
     chatId: data.chat_id,
     role: data.role,
     content: data.content,
-    createdAt: data.created_at
+    createdAt: data.created_at,
+    ...parseTurnState(data)
   };
 }
-function mapMessage(data) {
-  const toolCalls = data.tool_calls;
+async function invokeAgent(client, agentRef, message, options = {}) {
+  const [ns, name] = splitAgentRef(agentRef);
+  const config = client.getConfig();
+  const body = { message };
+  if (options.sessionKey !== void 0) body.session_key = options.sessionKey;
+  if (options.reset !== void 0) body.reset = options.reset;
+  if (options.input !== void 0) body.input = options.input;
+  const res = await client.fetch(`${config.apiBase}/agents/${ns}/${name}/invoke`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const data = await res.json();
   return {
-    id: data.id,
+    reply: typeof data.reply === "string" ? data.reply : "",
     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
+    sessionKey: data.session_key ?? null,
+    ...parseTurnState(data)
   };
 }
 async function getChat(client, chatId) {
   const config = client.getConfig();
   const res = await client.fetch(`${config.apiBase}/chats/${chatId}`);
   const data = await res.json();
-  return {
+  const detail = {
     id: data.id,
     agentNamespace: data.agent_namespace,
     agentName: data.agent_name,
     title: data.title,
-    messages: (data.messages || []).map(mapMessage),
-    pendingApprovals: (data.pending_approvals || []).map((pa) => ({
-      type: "approval_required",
-      toolCallId: pa.tool_call_id,
-      functionNamespace: pa.function_namespace,
-      functionName: pa.function_name,
-      arguments: pa.arguments || {}
-    }))
+    messages: (data.messages || []).map(parseMessage),
+    pendingApprovals: (data.pending_approvals || []).map(parseApproval).filter((a) => a !== null)
   };
+  if (Array.isArray(data.pending_inputs)) {
+    detail.pendingInputs = parsePendingInputs(data.pending_inputs);
+  }
+  return detail;
 }
-async function approveToolCall(client, chatId, toolCallId, approved) {
+async function approveToolCall(client, chatId, toolCallId, approved, options = {}) {
   const config = client.getConfig();
+  const body = { approved };
+  if (approved && options.alwaysAllow) body.always_allow = true;
   const res = await client.fetch(
-    `${config.apiBase}/chats/${chatId}/approve-tool/${toolCallId}`,
-    { method: "POST", body: JSON.stringify({ approved }) }
+    `${config.apiBase}/chats/${chatId}/approve-tool/${encodeURIComponent(toolCallId)}`,
+    { method: "POST", body: JSON.stringify(body) }
   );
   const data = await res.json();
-  return {
+  const result = {
     status: data.status,
     toolCallId: data.tool_call_id,
     channelId: data.channel_id
   };
+  if (data.resume === "waiting" || data.resume === "queued") result.resume = data.resume;
+  if (typeof data.message === "string") result.message = data.message;
+  return result;
 }
-function streamFromChannel(client, chatId, channelId, onChunk, onDone, onError) {
-  const controller = new AbortController();
+async function listPendingInputs(client, chatId) {
+  const config = client.getConfig();
+  const res = await client.fetch(`${config.apiBase}/chats/${chatId}/pending-input`);
+  return parsePendingInputs(await res.json());
+}
+async function answerPendingInput(client, chatId, toolCallId, answer, options = {}) {
   const config = client.getConfig();
+  const body = { answer };
+  if (options.wait) body.wait = true;
+  const res = await client.fetch(
+    `${config.apiBase}/chats/${chatId}/pending-input/${encodeURIComponent(toolCallId)}`,
+    { method: "POST", body: JSON.stringify(body) }
+  );
+  const data = await res.json();
+  if (options.wait) {
+    return {
+      toolCallId: data.tool_call_id,
+      chatId: data.chat_id,
+      reply: typeof data.reply === "string" ? data.reply : "",
+      message: data.message && typeof data.message === "object" ? parseMessage(data.message) : null,
+      ...parseTurnState(data)
+    };
+  }
+  return {
+    status: "answered",
+    toolCallId: data.tool_call_id,
+    resumed: !!data.resumed,
+    resumePending: !!data.resume_pending,
+    channelId: data.channel_id ?? null,
+    message: typeof data.message === "string" ? data.message : ""
+  };
+}
+function streamFromChannel(client, chatId, channelId, onChunk, onDone, onError, options = {}) {
+  const config = client.getConfig();
+  const params = new URLSearchParams({ last_id: options.lastId ?? "0" });
+  if (options.includeThinking) params.set("include_thinking", "true");
+  return runSSE(
+    `${config.apiBase}/chats/${chatId}/stream/${encodeURIComponent(channelId)}?${params}`,
+    (signal) => ({ headers: client.getAuthHeaders(), signal }),
+    "Stream reconnect failed",
+    onChunk,
+    onDone,
+    onError
+  );
+}
+function runSSE(url, init, failure, onChunk, onDone, onError) {
+  const controller = new AbortController();
   (async () => {
     try {
-      const res = await fetch(
-        `${config.apiBase}/chats/${chatId}/stream/${channelId}?last_id=0`,
-        { headers: client.getAuthHeaders(), signal: controller.signal }
-      );
+      const res = await fetch(url, init(controller.signal));
       if (!res.ok) {
         const body = await res.json().catch(() => ({ detail: res.statusText }));
-        throw new Error(body.detail || "Stream reconnect failed");
+        throw new Error(body.detail || failure);
       }
       const reader = res.body.getReader();
       const decoder = new TextDecoder();
@@ -517,7 +799,7 @@ function streamFromChannel(client, chatId, channelId, onChunk, onDone, onError)
         for (const chunk of chunks) {
           onChunk(chunk);
           if (chunk.event === "done") {
-            onDone?.();
+            onDone?.(parseDone(chunk.data));
             return;
           }
         }
@@ -526,9 +808,13 @@ function streamFromChannel(client, chatId, channelId, onChunk, onDone, onError)
         const { chunks } = parseSSE(buffer + "\n\n");
         for (const chunk of chunks) {
           onChunk(chunk);
+          if (chunk.event === "done") {
+            onDone?.(parseDone(chunk.data));
+            return;
+          }
         }
       }
-      onDone?.();
+      onDone?.({ status: "closed" });
     } catch (err) {
       if (err.name === "AbortError") return;
       onError?.(err);
@@ -539,75 +825,33 @@ function streamFromChannel(client, chatId, channelId, onChunk, onDone, onError)
 function parseSSE(buffer) {
   const chunks = [];
   const normalized = buffer.replace(/\r\n/g, "\n");
-  const lines = normalized.split("\n");
-  let event = "";
-  let data = "";
-  let remaining = "";
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (i === lines.length - 1 && !normalized.endsWith("\n")) {
-      remaining = line;
-      break;
-    }
-    if (line.startsWith("event:")) {
-      event = line.slice(6).trim();
-    } else if (line.startsWith("data:")) {
-      data = line.slice(5).trim();
-    } else if (line === "") {
-      if (event || data) {
-        chunks.push({ event: event || "message", data });
-        event = "";
-        data = "";
-      }
+  let start = 0;
+  let end;
+  while ((end = normalized.indexOf("\n\n", start)) !== -1) {
+    const block = normalized.slice(start, end);
+    start = end + 2;
+    let event = "";
+    const data = [];
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) data.push(line.slice(5).trim());
     }
+    if (event || data.length) chunks.push({ event: event || "message", data: data.join("\n") });
   }
-  return { chunks, remaining };
+  return { chunks, remaining: normalized.slice(start) };
 }
-function streamMessage(client, chatId, content, onChunk, onDone, onError) {
-  const controller = new AbortController();
+function streamMessage(client, chatId, content, onChunk, onDone, onError, options = {}) {
   const config = client.getConfig();
-  (async () => {
-    try {
-      const res = await fetch(`${config.apiBase}/chats/${chatId}/messages/stream`, {
-        method: "POST",
-        headers: client.getAuthHeaders(),
-        body: JSON.stringify({ content }),
-        signal: controller.signal
-      });
-      if (!res.ok) {
-        const body = await res.json().catch(() => ({ detail: res.statusText }));
-        throw new Error(body.detail || "Stream request 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;
+  const body = { content };
+  if (options.includeThinking) body.include_thinking = true;
+  return runSSE(
+    `${config.apiBase}/chats/${chatId}/messages/stream`,
+    (signal) => ({ method: "POST", headers: client.getAuthHeaders(), body: JSON.stringify(body), signal }),
+    "Stream request failed",
+    onChunk,
+    onDone,
+    onError
+  );
 }
 
 // src/client/collections.ts
@@ -822,29 +1066,172 @@ function useStateStore(ns, key) {
 
 // src/hooks/useChat.ts
 var import_react5 = __toESM(require("react"), 1);
+
+// 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] = 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 [pendingInputs, setPendingInputs] = import_react5.default.useState([]);
+  const [thinking, setThinking] = import_react5.default.useState(NOT_THINKING);
+  const thinkingShown = import_react5.default.useMemo(() => thinkingView(thinking), [thinking]);
   const [toolStatus, setToolStatus] = import_react5.default.useState([]);
+  const [trailingPoll, setTrailingPoll] = import_react5.default.useState(TRAILING_POLLS_MS.length);
+  const [pollTick, setPollTick] = import_react5.default.useState(0);
   const abortRef = import_react5.default.useRef(null);
   const chatIdRef = import_react5.default.useRef(chatId);
   chatIdRef.current = chatId;
+  const [gate] = import_react5.default.useState(createLatestGate);
+  const refresh2 = import_react5.default.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]
+  );
   import_react5.default.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);
@@ -854,74 +1241,52 @@ function useChat(agentRef, options) {
     return () => {
       cancelled = true;
     };
-  }, [client, options?.chatId]);
+  }, [client, gate, options?.chatId]);
   import_react5.default.useEffect(() => {
     return () => {
       abortRef.current?.abort();
     };
   }, []);
-  const handleStreamChunks = import_react5.default.useCallback(
+  import_react5.default.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 = import_react5.default.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") {
@@ -930,39 +1295,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");
@@ -973,18 +1317,37 @@ function useChat(agentRef, options) {
     },
     []
   );
-  const refreshMessages = import_react5.default.useCallback(
-    async (id) => {
-      try {
-        const detail = await getChat(client, id);
-        setMessages(detail.messages);
-        if (detail.pendingApprovals?.length) {
-          setPendingApprovals(detail.pendingApprovals);
-        }
-      } catch {
+  const streamCallbacks = import_react5.default.useCallback(
+    (id) => [
+      (_done) => {
+        setStreaming(false);
+        setToolStatus([]);
+        setThinking(stopThinking);
+        refresh2(id);
+      },
+      (err) => {
+        setError(err.message);
+        setStreaming(false);
+        setToolStatus([]);
+        setThinking(stopThinking);
       }
+    ],
+    [refresh2]
+  );
+  const followChannel = import_react5.default.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 = import_react5.default.useCallback(
     (content) => {
@@ -1006,10 +1369,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()}`,
@@ -1022,80 +1387,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 = import_react5.default.useCallback(
-    (toolCallId, approved) => {
-      const currentChatId = chatIdRef.current;
-      if (!currentChatId) return;
+  const decide = import_react5.default.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 = import_react5.default.useCallback(
-    (toolCallId) => handleApproval(toolCallId, true),
-    [handleApproval]
+    (toolCallId, opts) => decide(toolCallId, true, !!opts?.alwaysAllow),
+    [decide]
   );
   const reject = import_react5.default.useCallback(
-    (toolCallId) => handleApproval(toolCallId, false),
-    [handleApproval]
+    (toolCallId) => decide(toolCallId, false, false),
+    [decide]
+  );
+  const answer = import_react5.default.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 = import_react5.default.useCallback(
+    (channelId, opts) => {
+      const id = chatIdRef.current;
+      if (!id) return;
+      followChannel(id, channelId, opts?.lastId);
+    },
+    [followChannel]
   );
   const stop = import_react5.default.useCallback(() => {
     abortRef.current?.abort();
     abortRef.current = null;
     setStreaming(false);
+    setThinking(stopThinking);
   }, []);
   const clearError = import_react5.default.useCallback(() => {
     setError(null);
@@ -1107,10 +1469,14 @@ function useChat(agentRef, options) {
     streaming,
     error,
     pendingApprovals,
+    pendingInputs,
+    thinking: thinkingShown,
     toolStatus,
     send,
     approve,
     reject,
+    answer,
+    follow,
     stop,
     clearError
   };
@@ -1214,19 +1580,31 @@ function useAuth(options = {}) {
   SinasPermissionError,
   SinasProvider,
   SinasTimeoutError,
+  answerPendingInput,
+  answerResumeChannel,
+  approvalResumeChannel,
   approveToolCall,
+  cancelBatch,
   checkPermissions,
   createChat,
+  enqueueFunction,
   executeFunction,
   executeQuery,
   generateFileUrl,
+  getBatch,
   getChat,
   getInfo,
   getMe,
+  invokeAgent,
+  listBatchExecutions,
   listCollections,
   listFiles,
+  listPendingInputs,
   login,
   logout,
+  parsePendingInput,
+  parsePendingInputs,
+  pendingInputFromChunk,
   refresh,
   sendMessage,
   stateDelete,
@@ -1235,6 +1613,8 @@ function useAuth(options = {}) {
   stateSet,
   streamFromChannel,
   streamMessage,
+  submitAgentBatch,
+  submitFunctionBatch,
   uploadFile,
   useAuth,
   useChat,