@sinas/sdk 0.5.0 → 0.8.0

package/dist/sinas-sdk.umd.js

@@ -50,19 +50,31 @@ var SinasSDK = (() => {
     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,
@@ -71,6 +83,8 @@ var SinasSDK = (() => {
     stateSet: () => stateSet,
     streamFromChannel: () => streamFromChannel,
     streamMessage: () => streamMessage,
+    submitAgentBatch: () => submitAgentBatch,
+    submitFunctionBatch: () => submitFunctionBatch,
     uploadFile: () => uploadFile,
     useAuth: () => useAuth,
     useChat: () => useChat,
@@ -391,6 +405,124 @@ var SinasSDK = (() => {
       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) {
@@ -424,12 +556,111 @@ var SinasSDK = (() => {
     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",
@@ -455,66 +686,117 @@ var SinasSDK = (() => {
       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();
@@ -528,7 +810,7 @@ var SinasSDK = (() => {
           for (const chunk of chunks) {
             onChunk(chunk);
             if (chunk.event === "done") {
-              onDone?.();
+              onDone?.(parseDone(chunk.data));
               return;
             }
           }
@@ -537,9 +819,13 @@ var SinasSDK = (() => {
           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);
@@ -550,75 +836,33 @@ var SinasSDK = (() => {
   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
@@ -833,29 +1077,172 @@ var SinasSDK = (() => {
 
   // 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);
@@ -865,74 +1252,52 @@ var SinasSDK = (() => {
       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") {
@@ -941,39 +1306,18 @@ var SinasSDK = (() => {
             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");
@@ -984,18 +1328,37 @@ var SinasSDK = (() => {
       },
       []
     );
-    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) => {
@@ -1017,10 +1380,12 @@ var SinasSDK = (() => {
             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()}`,
@@ -1033,80 +1398,77 @@ var SinasSDK = (() => {
             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);
@@ -1118,10 +1480,14 @@ var SinasSDK = (() => {
       streaming,
       error,
       pendingApprovals,
+      pendingInputs,
+      thinking: thinkingShown,
       toolStatus,
       send,
       approve,
       reject,
+      answer,
+      follow,
       stop,
       clearError
     };