@agent-native/core 0.95.0 → 0.95.1

package/dist/client/sse-event-processor.js

@@ -61,13 +61,6 @@ function sseActionPreparationStallTimeoutMs(options) {
         ? SSE_DURABLE_ACTION_PREPARATION_STALL_TIMEOUT_MS
         : SSE_ACTION_PREPARATION_STALL_TIMEOUT_MS;
 }
-function formatProgressBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
 function activityProgressBytes(ev) {
     return typeof ev.progressBytes === "number" &&
         Number.isFinite(ev.progressBytes) &&
@@ -103,7 +96,7 @@ function preparationActivityLabel(tool, progressBytes) {
     if (progressBytes <= 0) {
         return `Preparing ${action}...`;
     }
-    return `Writing ${action}... (${formatProgressBytes(progressBytes)} prepared)`;
+    return `Writing ${action}...`;
 }
 function visibleActivityLabel(ev, tool) {
     const progressBytes = activityProgressBytes(ev);
@@ -117,14 +110,9 @@ function findPendingToolCallIndex(content, toolName, toolCallId) {
     // calls can be in flight simultaneously, and name-only matching would
     // attach a result to the wrong call.
     if (toolCallId) {
-        for (let i = content.length - 1; i >= 0; i--) {
-            const part = content[i];
-            if (part.type === "tool-call" &&
-                part.toolCallId === toolCallId &&
-                part.result === undefined) {
-                return i;
-            }
-        }
+        const exactIndex = findPendingToolCallIndexById(content, toolCallId);
+        if (exactIndex >= 0)
+            return exactIndex;
         // Fall through to name-matching: the start event may have arrived before
         // the server started emitting ids (e.g. older server build), so the
         // stored toolCallId is the locally-generated "tc_N" value rather than the
@@ -140,6 +128,56 @@ function findPendingToolCallIndex(content, toolName, toolCallId) {
     }
     return -1;
 }
+function findPendingToolCallIndexById(content, toolCallId) {
+    for (let i = content.length - 1; i >= 0; i--) {
+        const part = content[i];
+        if (part.type === "tool-call" &&
+            part.toolCallId === toolCallId &&
+            part.result === undefined) {
+            return i;
+        }
+    }
+    return -1;
+}
+function findOldestPendingActivityToolCallIndex(content, toolName) {
+    for (let i = 0; i < content.length; i += 1) {
+        const part = content[i];
+        if (part.type === "tool-call" &&
+            part.toolName === toolName &&
+            part.activity === true &&
+            part.result === undefined) {
+            return i;
+        }
+    }
+    return -1;
+}
+function findPendingActivityToolCallIndex(content, toolName, toolCallId) {
+    if (!toolCallId) {
+        return findPendingToolCallIndex(content, toolName);
+    }
+    // Activity events emitted while the model is assembling tool input already
+    // carry the engine's stable call id. Match that id exactly so repeated
+    // progress for one call updates one placeholder while parallel same-name
+    // calls retain separate cards.
+    const exactIndex = findPendingToolCallIndexById(content, toolCallId);
+    if (exactIndex >= 0)
+        return exactIndex;
+    // Older activity events may omit the id before a later progress event adds
+    // it. Upgrade one unambiguous reader-local placeholder instead of painting a
+    // second card for the same logical call.
+    const readerLocalCandidates = [];
+    for (let i = 0; i < content.length; i += 1) {
+        const part = content[i];
+        if (part.type === "tool-call" &&
+            part.toolName === toolName &&
+            part.activity === true &&
+            part.result === undefined &&
+            /^tc_\d+$/.test(part.toolCallId)) {
+            readerLocalCandidates.push(i);
+        }
+    }
+    return readerLocalCandidates.length === 1 ? readerLocalCandidates[0] : -1;
+}
 function findCompletedToolCallIndex(content, toolCallId) {
     if (!toolCallId)
         return -1;
@@ -687,7 +725,13 @@ export function processEvent(ev, content, toolCallCounter, tabId, state) {
         }
         if (!tool)
             return { action: "continue" };
-        const pendingToolCallIndex = findPendingToolCallIndex(content, tool);
+        const pendingToolCallIndex = findPendingActivityToolCallIndex(content, tool, ev.id);
+        if (pendingToolCallIndex >= 0 && ev.id) {
+            const pending = content[pendingToolCallIndex];
+            if (pending?.type === "tool-call" && pending.toolCallId !== ev.id) {
+                content[pendingToolCallIndex] = { ...pending, toolCallId: ev.id };
+            }
+        }
         if (pendingToolCallIndex === -1) {
             // Only surface a placeholder spinner when this tool has no card yet. A
             // trailing activity heartbeat that arrives after the matching tool_done
@@ -696,11 +740,12 @@ export function processEvent(ev, content, toolCallCounter, tabId, state) {
             // flicker. The real card reappears on the next tool_start regardless.
             const hasCompletedSameTool = content.some((part) => part.type === "tool-call" &&
                 part.toolName === tool &&
-                part.result !== undefined);
+                part.result !== undefined &&
+                (!ev.id || part.toolCallId === ev.id));
             if (!hasCompletedSameTool) {
                 content.push({
                     type: "tool-call",
-                    toolCallId: `tc_${++toolCallCounter.value}`,
+                    toolCallId: ev.id ?? `tc_${++toolCallCounter.value}`,
                     toolName: tool,
                     argsText: "",
                     args: {},
@@ -733,7 +778,9 @@ export function processEvent(ev, content, toolCallCounter, tabId, state) {
         }
         // Pass the server-assigned id so we upgrade the pending activity card
         // using id-match when available (parallel same-name calls stay separate).
-        const pendingToolCallIndex = findPendingToolCallIndex(content, tool, ev.id);
+        const pendingToolCallIndex = ev.id
+            ? findPendingActivityToolCallIndex(content, tool, ev.id)
+            : findOldestPendingActivityToolCallIndex(content, tool);
         const pendingToolCall = pendingToolCallIndex >= 0 ? content[pendingToolCallIndex] : undefined;
         const pendingIsActivityPlaceholder = pendingToolCall?.type === "tool-call" &&
             pendingToolCall.activity === true &&