@hypercli.com/sdk 2026.3.18 → 2026.3.20

package/dist/gateway.js

@@ -73,6 +73,243 @@ function asRecord(value) {
         ? value
         : null;
 }
+function asContentItems(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => asRecord(item))
+        .filter((item) => item !== null);
+}
+function isBrowserChatAttachment(attachment) {
+    return typeof attachment.dataUrl === "string";
+}
+function parseAttachmentDataUrl(dataUrl) {
+    const match = /^data:([^;]+);base64,(.+)$/i.exec(dataUrl.trim());
+    if (!match)
+        return null;
+    return { mimeType: match[1], content: match[2] };
+}
+export function normalizeChatAttachments(attachments) {
+    if (!attachments || attachments.length === 0)
+        return undefined;
+    return attachments.map((attachment) => {
+        if (!isBrowserChatAttachment(attachment)) {
+            return attachment;
+        }
+        const parsed = parseAttachmentDataUrl(attachment.dataUrl);
+        if (!parsed) {
+            throw new Error(`Invalid chat attachment dataUrl for mime type ${attachment.mimeType}`);
+        }
+        return {
+            type: "image",
+            mimeType: parsed.mimeType,
+            content: parsed.content,
+            ...(attachment.fileName ? { fileName: attachment.fileName } : {}),
+        };
+    });
+}
+function normalizeToolArgs(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function stringifyToolResult(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function gatewayToolCallId(record) {
+    const direct = (typeof record.id === "string" && record.id.trim()) ||
+        (typeof record.toolCallId === "string" && record.toolCallId.trim()) ||
+        (typeof record.tool_call_id === "string" && record.tool_call_id.trim());
+    return direct || undefined;
+}
+function gatewayToolName(record) {
+    const direct = (typeof record.name === "string" && record.name.trim()) ||
+        (typeof record.toolName === "string" && record.toolName.trim()) ||
+        (typeof record.tool_name === "string" && record.tool_name.trim());
+    return direct || undefined;
+}
+function mergeGatewayToolResult(toolCalls, result) {
+    const next = [...toolCalls];
+    let index = -1;
+    for (let cursor = next.length - 1; cursor >= 0; cursor -= 1) {
+        const entry = next[cursor];
+        if (result.id && entry.id && entry.id === result.id) {
+            index = cursor;
+            break;
+        }
+        if (result.name && entry.name === result.name && entry.result == null) {
+            index = cursor;
+            break;
+        }
+    }
+    if (index >= 0) {
+        const current = next[index];
+        next[index] = {
+            ...current,
+            ...(result.id ? { id: result.id } : {}),
+            ...(result.result !== undefined ? { result: result.result } : {}),
+        };
+        return next;
+    }
+    next.push(result);
+    return next;
+}
+export function extractGatewayChatThinking(message) {
+    const record = asRecord(message);
+    if (!record) {
+        return "";
+    }
+    const parts = asContentItems(record.content)
+        .map((item) => {
+        if (item.type !== "thinking" || typeof item.thinking !== "string") {
+            return null;
+        }
+        return item.thinking.trim();
+    })
+        .filter((value) => Boolean(value));
+    return parts.join("\n");
+}
+export function extractGatewayChatMediaUrls(message) {
+    const record = asRecord(message);
+    if (!record) {
+        return [];
+    }
+    const mediaUrls = [];
+    for (const item of asContentItems(record.content)) {
+        if (item.type !== "image") {
+            continue;
+        }
+        const source = asRecord(item.source);
+        if (!source) {
+            continue;
+        }
+        if (source.type === "url" && typeof source.url === "string" && source.url.trim()) {
+            mediaUrls.push(source.url);
+            continue;
+        }
+        if (source.type === "base64" && typeof source.data === "string" && source.data.trim()) {
+            const mimeType = typeof source.media_type === "string" && source.media_type.trim()
+                ? source.media_type.trim()
+                : "image/png";
+            mediaUrls.push(`data:${mimeType};base64,${source.data}`);
+        }
+    }
+    if (typeof record.mediaUrl === "string" && record.mediaUrl.trim()) {
+        mediaUrls.push(record.mediaUrl);
+    }
+    if (Array.isArray(record.mediaUrls)) {
+        for (const entry of record.mediaUrls) {
+            if (typeof entry === "string" && entry.trim()) {
+                mediaUrls.push(entry);
+            }
+        }
+    }
+    return mediaUrls;
+}
+export function extractGatewayChatToolCalls(message) {
+    const record = asRecord(message);
+    if (!record) {
+        return [];
+    }
+    let toolCalls = [];
+    for (const item of asContentItems(record.content)) {
+        const kind = typeof item.type === "string" ? item.type.trim().toLowerCase() : "";
+        const name = gatewayToolName(item);
+        const id = gatewayToolCallId(item);
+        if (kind === "toolcall" ||
+            kind === "tool_call" ||
+            kind === "tooluse" ||
+            kind === "tool_use" ||
+            (name && (item.arguments !== undefined || item.args !== undefined))) {
+            toolCalls.push({
+                ...(id ? { id } : {}),
+                name: name ?? "tool",
+                args: normalizeToolArgs(item.arguments ?? item.args),
+            });
+            continue;
+        }
+        if (kind === "toolresult" || kind === "tool_result") {
+            toolCalls = mergeGatewayToolResult(toolCalls, {
+                ...(id ? { id } : {}),
+                name: name ?? "tool",
+                result: stringifyToolResult(item.text ?? item.content ?? item.result),
+            });
+        }
+    }
+    if (Array.isArray(record.tool_calls)) {
+        for (const item of record.tool_calls) {
+            const tool = asRecord(item);
+            if (!tool)
+                continue;
+            const name = gatewayToolName(tool);
+            if (!name)
+                continue;
+            toolCalls.push({
+                ...(gatewayToolCallId(tool) ? { id: gatewayToolCallId(tool) } : {}),
+                name,
+                args: normalizeToolArgs(tool.arguments ?? tool.args),
+            });
+        }
+    }
+    const topLevelToolName = gatewayToolName(record);
+    const topLevelResult = stringifyToolResult(record.result ?? record.content ?? record.text ?? record.partialResult);
+    const role = typeof record.role === "string" ? record.role.trim().toLowerCase() : "";
+    if (topLevelToolName &&
+        topLevelResult &&
+        (role === "toolresult" || role === "tool_result" || record.toolCallId || record.tool_call_id)) {
+        toolCalls = mergeGatewayToolResult(toolCalls, {
+            ...(gatewayToolCallId(record) ? { id: gatewayToolCallId(record) } : {}),
+            name: topLevelToolName,
+            result: topLevelResult,
+        });
+    }
+    return toolCalls;
+}
+export function normalizeGatewayChatMessage(message) {
+    const record = asRecord(message);
+    if (!record) {
+        return null;
+    }
+    const text = extractMessageText(record) ?? "";
+    const thinking = extractGatewayChatThinking(record);
+    const toolCalls = extractGatewayChatToolCalls(record);
+    const mediaUrls = extractGatewayChatMediaUrls(record);
+    const timestamp = typeof record.timestamp === "number" ? record.timestamp : undefined;
+    const role = typeof record.role === "string" && record.role.trim() ? record.role : "assistant";
+    if (!text && !thinking && toolCalls.length === 0 && mediaUrls.length === 0) {
+        return null;
+    }
+    return {
+        role,
+        text,
+        thinking,
+        toolCalls,
+        mediaUrls,
+        ...(timestamp !== undefined ? { timestamp } : {}),
+    };
+}
 function extractMessageText(message) {
     if (typeof message === "string") {
         return message;
@@ -1344,8 +1581,11 @@ export class GatewayClient {
         return res?.sessions ?? res ?? [];
     }
     async sessionsPreview(sessionKey, limit = 20) {
-        const res = await this.rpc("sessions.preview", { sessionKey, limit });
-        return res?.messages ?? res ?? [];
+        const res = await this.rpc("sessions.preview", { keys: [sessionKey], limit });
+        return res?.previews?.[0]?.items ?? [];
+    }
+    async sessionsPatch(patch) {
+        return await this.rpc("sessions.patch", patch);
     }
     async chatHistory(sessionKey, limit = 50) {
         const params = { limit };
@@ -1361,6 +1601,7 @@ export class GatewayClient {
         await this.rpc("chat.abort", params);
     }
     async sendChat(message, sessionKey = "main", agentId, attachments) {
+        const normalizedAttachments = normalizeChatAttachments(attachments);
         const params = {
             message,
             deliver: false,
@@ -1369,17 +1610,20 @@ export class GatewayClient {
         };
         if (agentId)
             params.agentId = agentId;
-        if (attachments && attachments.length > 0)
-            params.attachments = attachments;
+        if (normalizedAttachments)
+            params.attachments = normalizedAttachments;
         return this.rpc("chat.send", params, CHAT_TIMEOUT);
     }
-    async sessionsReset(sessionKey) {
-        await this.rpc("sessions.reset", { sessionKey });
+    async sessionsReset(sessionKey, reason) {
+        const params = { key: sessionKey };
+        if (reason)
+            params.reason = reason;
+        await this.rpc("sessions.reset", params);
     }
     // ---------------------------------------------------------------------------
     // Chat (streaming via events)
     // ---------------------------------------------------------------------------
-    async *chatSend(message, sessionKey) {
+    async *chatSend(message, sessionKey, attachments) {
         if (!this.connected || !this.ws) {
             throw new Error("Not connected");
         }
@@ -1389,6 +1633,9 @@ export class GatewayClient {
         let resolveWait = null;
         let streamedDisplayText = false;
         let lastLegacyText = "";
+        let lastThinkingText = "";
+        const seenToolCallIds = new Set();
+        const seenToolResultIds = new Set();
         const handler = (evt) => {
             if (evt.event === "chat" || evt.event?.startsWith("chat.")) {
                 queuedEvents.push(evt);
@@ -1399,12 +1646,16 @@ export class GatewayClient {
         };
         this.eventHandlers.add(handler);
         try {
-            const ack = await this.rpc("chat.send", {
+            const normalizedAttachments = normalizeChatAttachments(attachments);
+            const params = {
                 message,
                 deliver: false,
                 sessionKey,
                 idempotencyKey,
-            }, CHAT_TIMEOUT);
+            };
+            if (normalizedAttachments)
+                params.attachments = normalizedAttachments;
+            const ack = await this.rpc("chat.send", params, CHAT_TIMEOUT);
             const serverRunId = typeof ack?.runId === "string" ? ack.runId.trim() : "";
             if (serverRunId) {
                 acceptedRunIds.add(serverRunId);
@@ -1447,15 +1698,61 @@ export class GatewayClient {
                     }
                     continue;
                 }
+                if (evt.event === "agent" && String(payload.stream || "").toLowerCase() === "tool") {
+                    const toolPayload = asRecord(payload.data) ?? {};
+                    const phase = typeof toolPayload.phase === "string" ? toolPayload.phase.toLowerCase() : "";
+                    if (phase === "start") {
+                        const toolCallId = typeof toolPayload.toolCallId === "string" && toolPayload.toolCallId.trim()
+                            ? toolPayload.toolCallId.trim()
+                            : `${typeof toolPayload.name === "string" ? toolPayload.name : "tool"}:${JSON.stringify(toolPayload.args ?? null)}`;
+                        seenToolCallIds.add(toolCallId);
+                        yield {
+                            type: "tool_call",
+                            data: {
+                                ...(toolPayload.toolCallId ? { toolCallId: toolPayload.toolCallId } : {}),
+                                name: toolPayload.name,
+                                args: toolPayload.args,
+                            },
+                        };
+                    }
+                    else if (phase === "result") {
+                        const toolCallId = typeof toolPayload.toolCallId === "string" && toolPayload.toolCallId.trim()
+                            ? toolPayload.toolCallId.trim()
+                            : `${typeof toolPayload.name === "string" ? toolPayload.name : "tool"}:${JSON.stringify(toolPayload.args ?? null)}`;
+                        seenToolResultIds.add(toolCallId);
+                        yield {
+                            type: "tool_result",
+                            data: {
+                                ...(toolPayload.toolCallId ? { toolCallId: toolPayload.toolCallId } : {}),
+                                name: toolPayload.name,
+                                result: toolPayload.result,
+                                isError: toolPayload.isError,
+                            },
+                        };
+                    }
+                    continue;
+                }
                 if (evt.event === "chat.thinking") {
-                    yield { type: "thinking", text: typeof payload.text === "string" ? payload.text : "" };
+                    const text = typeof payload.text === "string" ? payload.text : "";
+                    if (text) {
+                        lastThinkingText += text;
+                    }
+                    yield { type: "thinking", text };
                     continue;
                 }
                 if (evt.event === "chat.tool_call") {
+                    const toolCallId = typeof payload.toolCallId === "string" && payload.toolCallId.trim()
+                        ? payload.toolCallId.trim()
+                        : `${typeof payload.name === "string" ? payload.name : "tool"}:${JSON.stringify(payload.args ?? payload.arguments ?? null)}`;
+                    seenToolCallIds.add(toolCallId);
                     yield { type: "tool_call", data: payload };
                     continue;
                 }
                 if (evt.event === "chat.tool_result") {
+                    const toolCallId = typeof payload.toolCallId === "string" && payload.toolCallId.trim()
+                        ? payload.toolCallId.trim()
+                        : `${typeof payload.name === "string" ? payload.name : "tool"}:${JSON.stringify(payload.args ?? payload.arguments ?? null)}`;
+                    seenToolResultIds.add(toolCallId);
                     yield { type: "tool_result", data: payload };
                     continue;
                 }
@@ -1476,6 +1773,7 @@ export class GatewayClient {
                 }
                 const state = typeof payload.state === "string" ? payload.state.trim().toLowerCase() : "";
                 const currentText = extractMessageText(payload.message) ?? "";
+                const normalizedMessage = normalizeGatewayChatMessage(payload.message);
                 if (state === "delta") {
                     const streamed = streamDelta(lastLegacyText, currentText);
                     lastLegacyText = streamed.nextText;
@@ -1486,6 +1784,39 @@ export class GatewayClient {
                     continue;
                 }
                 if (state === "final") {
+                    const thinkingDelta = normalizedMessage?.thinking
+                        ? streamDelta(lastThinkingText, normalizedMessage.thinking)
+                        : { delta: "", nextText: lastThinkingText };
+                    lastThinkingText = thinkingDelta.nextText;
+                    if (thinkingDelta.delta) {
+                        yield { type: "thinking", text: thinkingDelta.delta, data: payload };
+                    }
+                    for (const toolCall of normalizedMessage?.toolCalls ?? []) {
+                        const toolCallKey = toolCall.id?.trim() ||
+                            `${toolCall.name}:${JSON.stringify(toolCall.args ?? null)}`;
+                        if (toolCall.args !== undefined && !seenToolCallIds.has(toolCallKey)) {
+                            seenToolCallIds.add(toolCallKey);
+                            yield {
+                                type: "tool_call",
+                                data: {
+                                    ...(toolCall.id ? { toolCallId: toolCall.id } : {}),
+                                    name: toolCall.name,
+                                    args: toolCall.args,
+                                },
+                            };
+                        }
+                        if (toolCall.result !== undefined && !seenToolResultIds.has(toolCallKey)) {
+                            seenToolResultIds.add(toolCallKey);
+                            yield {
+                                type: "tool_result",
+                                data: {
+                                    ...(toolCall.id ? { toolCallId: toolCall.id } : {}),
+                                    name: toolCall.name,
+                                    result: toolCall.result,
+                                },
+                            };
+                        }
+                    }
                     if (currentText) {
                         const streamed = streamDelta(lastLegacyText, currentText);
                         lastLegacyText = streamed.nextText;
@@ -1500,6 +1831,10 @@ export class GatewayClient {
                         yield { type: "done", data: payload };
                         return;
                     }
+                    if (normalizedMessage?.thinking || (normalizedMessage?.toolCalls.length ?? 0) > 0) {
+                        yield { type: "done", data: payload };
+                        return;
+                    }
                     const historyText = latestHistoryAssistantText(await this.chatHistory(sessionKey, 20), acceptedRunIds);
                     if (historyText) {
                         yield { type: "content", text: historyText, data: payload };