@sinas/sdk 0.5.0 → 0.8.0

package/dist/client.cjs

@@ -27,19 +27,31 @@ __export(client_exports, {
   SinasNotFoundError: () => SinasNotFoundError,
   SinasPermissionError: () => SinasPermissionError,
   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,
@@ -48,6 +60,8 @@ __export(client_exports, {
   stateSet: () => stateSet,
   streamFromChannel: () => streamFromChannel,
   streamMessage: () => streamMessage,
+  submitAgentBatch: () => submitAgentBatch,
+  submitFunctionBatch: () => submitFunctionBatch,
   uploadFile: () => uploadFile,
   verifyOTP: () => verifyOTP
 });
@@ -362,6 +376,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) {
@@ -395,12 +527,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",
@@ -426,66 +657,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();
@@ -499,7 +781,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;
           }
         }
@@ -508,9 +790,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);
@@ -521,75 +807,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
@@ -631,19 +875,31 @@ async function generateFileUrl(client, namespace, collection, filename, expiresI
   SinasNotFoundError,
   SinasPermissionError,
   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,
@@ -652,6 +908,8 @@ async function generateFileUrl(client, namespace, collection, filename, expiresI
   stateSet,
   streamFromChannel,
   streamMessage,
+  submitAgentBatch,
+  submitFunctionBatch,
   uploadFile,
   verifyOTP
 });