@agent-native/core 0.84.23 → 0.84.25

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2043
-- template files: 4967
+- template files: 4969

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.84.25
+
+### Patch Changes
+
+- a11293f: Keep tail-resume reconnect content display-only, recover zero-byte action-prep stalls, and polish Design screen tool labels.
+
+## 0.84.24
+
+### Patch Changes
+
+- d88a57f: Fix chat tool-call rows shrinking, keep running chats visibly thinking, stream reconnect content incrementally, and collapse exact repeated tool rows.
+
 ## 0.84.23
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.23",
+  "version": "0.84.25",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/production-agent.ts

@@ -2843,22 +2843,24 @@ export async function runAgentLoop(opts: {
             // reasons, then collapse it when content arrives.
             send({ type: "thinking", text: event.text });
           } else if (event.type === "tool-input-start") {
-            if (event.id && event.name) {
-              toolInputNames.set(event.id, event.name);
-              toolInputBytes.set(event.id, 0);
+            const key = event.id ?? event.name;
+            if (key && event.name) {
+              toolInputNames.set(key, event.name);
+              toolInputBytes.set(key, 0);
             }
             sendToolInputActivity(event.name, undefined, true);
           } else if (event.type === "tool-input-delta") {
+            const key = event.id ?? event.name;
             const toolName =
               event.name ??
               (event.id ? toolInputNames.get(event.id) : undefined);
             let progressBytes: number | undefined;
-            if (event.id) {
-              const previous = toolInputBytes.get(event.id) ?? 0;
+            if (key) {
+              const previous = toolInputBytes.get(key) ?? 0;
               progressBytes =
                 previous +
                 new TextEncoder().encode(event.text ?? "").byteLength;
-              toolInputBytes.set(event.id, progressBytes);
+              toolInputBytes.set(key, progressBytes);
             }
             sendToolInputActivity(toolName, progressBytes);
           } else if (event.type === "gateway-heartbeat") {

package/corpus/core/src/agent/run-manager.ts

@@ -16,6 +16,7 @@ import {
   bumpRunProgress,
   reapIfStale,
   reapUnclaimedBackgroundRun,
+  reconcileTerminalRunFromEvents,
   ensureTerminalRunEvent,
   setRunError,
   setRunTerminalReason,
@@ -125,6 +126,12 @@ export const TERMINAL_RUN_RECONNECT_WINDOW_MS = 10 * 60 * 1000;
 
 const PROVIDER_RATE_LIMITED_ERROR_CODE = "provider_rate_limited";
 
+function isPreparingActionActivityEvent(event: AgentChatEvent): boolean {
+  if (event.type !== "activity") return false;
+  const label = event.label.trim().toLowerCase();
+  return label.startsWith("preparing ") && label.includes(" action");
+}
+
 function getRunErrorMessage(err: unknown): string {
   if (
     typeof err === "object" &&
@@ -423,6 +430,7 @@ export function startRun(
   // chunk. The stuck-detector threshold is on the order of tens of seconds,
   // so 1s resolution is plenty.
   let lastProgressBumpAt = 0;
+  const preparingActivityBytes = new Map<string, number>();
   let eventPersistenceErrorCaptured = false;
   const bumpProgressIfDue = () => {
     const now = Date.now();
@@ -430,6 +438,41 @@ export function startRun(
     lastProgressBumpAt = now;
     bumpRunProgress(runId).catch(() => {});
   };
+  const shouldBumpProgressForEvent = (event: AgentChatEvent): boolean => {
+    if (event.type === "stream_keepalive") return false;
+    if (event.type === "activity" && isPreparingActionActivityEvent(event)) {
+      const toolKey = event.tool?.trim() || event.label.trim();
+      const progressBytes =
+        typeof event.progressBytes === "number" &&
+        Number.isFinite(event.progressBytes) &&
+        event.progressBytes >= 0
+          ? Math.floor(event.progressBytes)
+          : undefined;
+      if (progressBytes === undefined) return false;
+      const previousBytes = preparingActivityBytes.get(toolKey) ?? 0;
+      if (progressBytes <= previousBytes) {
+        preparingActivityBytes.set(
+          toolKey,
+          Math.max(previousBytes, progressBytes),
+        );
+        return false;
+      }
+      preparingActivityBytes.set(toolKey, progressBytes);
+      return true;
+    }
+    if (event.type === "tool_start" || event.type === "tool_done") {
+      const tool = event.tool?.trim();
+      if (tool) preparingActivityBytes.delete(tool);
+    }
+    if (
+      event.type === "clear" ||
+      event.type === "done" ||
+      event.type === "error"
+    ) {
+      preparingActivityBytes.clear();
+    }
+    return true;
+  };
 
   // Periodic SQL abort check interval (for cross-isolate abort on Workers).
   // Also self-aborts when our row is no longer status='running' — catches the
@@ -539,8 +582,12 @@ export function startRun(
     // Bump the durable progress timestamp. Distinct from the heartbeat:
     // heartbeat = "process is up", progress = "real work is happening." The
     // gap between them is what the client-side stuck-detector reads to tell
-    // a hung run from a healthy one.
-    bumpProgressIfDue();
+    // a hung run from a healthy one. Keepalive and zero-byte action prep are
+    // liveness only; streamed input bytes, text, and tool lifecycle events are
+    // real progress.
+    if (shouldBumpProgressForEvent(runEvent.event)) {
+      bumpProgressIfDue();
+    }
 
     // Persist event to SQL. Events are chained through persistenceChain so
     // inserts commit in seq order — an out-of-order commit would advance the
@@ -733,12 +780,16 @@ export function startRun(
       try {
         await insertRunPromise;
         if (!terminalPersistenceError) {
-          const statusUpdated = await updateRunStatusIfRunning(
-            runId,
-            finalStatus,
-          );
+          let statusUpdated = false;
+          try {
+            statusUpdated = await updateRunStatusIfRunning(runId, finalStatus);
+          } catch {
+            statusUpdated = false;
+          }
           if (statusUpdated) {
             await setRunTerminalReason(runId, terminalReason);
+          } else {
+            await reconcileTerminalRunFromEvents(runId).catch(() => false);
           }
         }
       } catch {

package/corpus/core/src/client/AssistantChat.tsx

@@ -37,10 +37,13 @@ import React, {
 import { LLM_MISSING_CREDENTIALS_MESSAGE } from "../agent/engine/credential-errors.js";
 import type { ReasoningEffort } from "../shared/reasoning-effort.js";
 import {
+  ACTIVE_RUN_STATE_EVENT,
+  clearActiveRunIfMatches,
   getActiveRunActivityTool,
   getActiveRun,
   resolveReconnectAfterSeq,
   setActiveRun,
+  type ActiveRunState,
   updateActiveRunActivity,
   updateActiveRunSeq,
 } from "./active-run-state.js";
@@ -282,6 +285,13 @@ export function reconnectProgressTimedOut(args: {
   return args.now - args.lastProgressAt >= threshold;
 }
 
+function activeRunMatchesThread(
+  state: ActiveRunState | null,
+  threadId: string | undefined,
+): boolean {
+  return Boolean(threadId && state?.threadId === threadId && state.runId);
+}
+
 function isAssistantUiDuplicateMessageIdError(error: unknown): boolean {
   const message = error instanceof Error ? error.message : String(error ?? "");
   return (
@@ -627,15 +637,21 @@ export function resolveAssistantChatRunningState({
   isReconnecting,
   optimisticRunning,
   isAutoResuming,
+  hasActiveServerRun,
 }: {
   forceStopped: boolean;
   isRuntimeRunning: boolean;
   isReconnecting: boolean;
   optimisticRunning: boolean;
   isAutoResuming: boolean;
+  hasActiveServerRun?: boolean;
 }): { isRunning: boolean; showRunningInUI: boolean } {
   const isRunning =
-    !forceStopped && (isRuntimeRunning || isReconnecting || optimisticRunning);
+    !forceStopped &&
+    (isRuntimeRunning ||
+      isReconnecting ||
+      optimisticRunning ||
+      Boolean(hasActiveServerRun));
   return {
     isRunning,
     // During auto-continuation, assistant-ui can briefly mark the message done
@@ -1440,13 +1456,34 @@ const AssistantChatInner = forwardRef<
   // When stop is clicked during reconnect, keep content visible (don't wipe it)
   const [reconnectFrozen, setReconnectFrozen] = useState(false);
   const reconnectRunIdRef = useRef<string | null>(null);
-  const [reconnectAfterSeq, setReconnectAfterSeq] = useState(0);
+  const reconnectCanMaterializeRef = useRef(false);
   const reconnectAbortRef = useRef<AbortController | null>(null);
   // Nuclear stop: user clicked stop. Clears the stop button/indicator AND
   // lets new submissions go through immediately — prevents the "stuck
   // queueing forever" state where isReconnecting or isRuntimeRunning gets
   // wedged (e.g. after a tab refresh + stop during reconnect).
   const [forceStopped, setForceStopped] = useState(false);
+  const [hasActiveServerRun, setHasActiveServerRun] = useState(() =>
+    activeRunMatchesThread(getActiveRun(), threadId),
+  );
+  useEffect(() => {
+    const syncActiveRun = (state = getActiveRun()) => {
+      setHasActiveServerRun(activeRunMatchesThread(state, threadId));
+    };
+    syncActiveRun();
+    const handler = (event: Event) => {
+      const state = (event as CustomEvent<{ state?: ActiveRunState | null }>)
+        .detail?.state;
+      syncActiveRun(state ?? null);
+    };
+    const storageHandler = () => syncActiveRun();
+    window.addEventListener(ACTIVE_RUN_STATE_EVENT, handler);
+    window.addEventListener("storage", storageHandler);
+    return () => {
+      window.removeEventListener(ACTIVE_RUN_STATE_EVENT, handler);
+      window.removeEventListener("storage", storageHandler);
+    };
+  }, [threadId]);
   // Real running state drives submission/queue gating; UI running also covers
   // short auto-continuation gaps so the latest assistant message does not flash
   // into a done state while the agent is still working.
@@ -1456,14 +1493,14 @@ const AssistantChatInner = forwardRef<
     isReconnecting,
     optimisticRunning,
     isAutoResuming,
+    hasActiveServerRun,
   });
   const textStreaming = showRunningInUI || externalStreaming;
   // A revealed activity label wins; otherwise stay a steady "Thinking" by
   // default. We only surface "Reconnecting" while we are actively replaying
   // recovered content (reconnectContent populated). A bare reconnect with no
-  // replayed content — e.g. a tail-resume after the serverless wall, where
-  // `scheduleUpdate` intentionally leaves reconnectContent empty — is normal
-  // ongoing work, so it must read as "Thinking", never a perpetual "Working".
+  // replayed content is normal ongoing work, so it must read as "Thinking",
+  // never a perpetual "Working".
   const runningStatusLabel = runningActivityLabel
     ? runningActivityLabel
     : isAutoResuming
@@ -1738,9 +1775,9 @@ const AssistantChatInner = forwardRef<
 
       reconnectRunIdRef.current = runId;
       const afterSeq = resolveReconnectAfterSeq(threadId, runId);
+      reconnectCanMaterializeRef.current = afterSeq === 0;
       const storedActivityTool = getActiveRunActivityTool(threadId, runId);
       setRunningActivityTool(storedActivityTool);
-      setReconnectAfterSeq(afterSeq);
       setActiveRun({
         threadId,
         runId,
@@ -1830,7 +1867,6 @@ const AssistantChatInner = forwardRef<
             let rafPending = false;
             let latestSnapshot: ContentPart[] = [];
             const scheduleUpdate = (snapshot: ContentPart[]) => {
-              if (afterSeq > 0) return;
               latestSnapshot = snapshot;
               if (rafPending) return;
               rafPending = true;
@@ -1909,6 +1945,7 @@ const AssistantChatInner = forwardRef<
             settleInterruptedToolCalls(latestContent);
             setReconnectContent([...latestContent]);
             setReconnectFrozen(latestContent.length > 0);
+            reconnectCanMaterializeRef.current = latestContent.length > 0;
           }
           setRunErrorInfo({
             message:
@@ -1918,10 +1955,13 @@ const AssistantChatInner = forwardRef<
             runId,
           });
           setDismissedRunErrorKey(null);
+          clearActiveRunIfMatches(threadId, runId);
           reconnectAbortRef.current = null;
           setIsReconnecting(false);
           reconnectRunIdRef.current = null;
-          setReconnectAfterSeq(0);
+          if (afterSeq > 0) {
+            reconnectCanMaterializeRef.current = false;
+          }
           window.dispatchEvent(
             new CustomEvent("agentNative.chatRunning", {
               detail: { isRunning: false, tabId: tabId || threadId },
@@ -1930,7 +1970,7 @@ const AssistantChatInner = forwardRef<
           return;
         }
 
-        setReconnectFrozen(true);
+        setReconnectFrozen(afterSeq === 0);
         let loaded = false;
         for (let attempt = 0; attempt < 10; attempt++) {
           await new Promise((r) => setTimeout(r, 500));
@@ -1939,16 +1979,24 @@ const AssistantChatInner = forwardRef<
           if (repoHasAssistantMessage(repo)) {
             setReconnectContent([]);
             setReconnectFrozen(false);
+            reconnectCanMaterializeRef.current = false;
             loaded = true;
             break;
           }
         }
 
         if (reconnectRunIdRef.current === runId) {
+          if (afterSeq > 0) {
+            setReconnectContent([]);
+            setReconnectFrozen(false);
+          }
+          clearActiveRunIfMatches(threadId, runId);
           reconnectAbortRef.current = null;
           setIsReconnecting(false);
           reconnectRunIdRef.current = null;
-          setReconnectAfterSeq(0);
+          if (loaded || afterSeq > 0 || latestContent.length === 0) {
+            reconnectCanMaterializeRef.current = false;
+          }
           window.dispatchEvent(
             new CustomEvent("agentNative.chatRunning", {
               detail: { isRunning: false, tabId: tabId || threadId },
@@ -1956,7 +2004,12 @@ const AssistantChatInner = forwardRef<
           );
         }
         if (!loaded) {
-          await refreshThreadFromServer();
+          const repo = await refreshThreadFromServer();
+          if (afterSeq > 0 || repoHasAssistantMessage(repo)) {
+            setReconnectContent([]);
+            setReconnectFrozen(false);
+            reconnectCanMaterializeRef.current = false;
+          }
         }
       };
 
@@ -2650,6 +2703,7 @@ const AssistantChatInner = forwardRef<
       if (reconnectFrozen) {
         setReconnectFrozen(false);
         setReconnectContent([]);
+        reconnectCanMaterializeRef.current = false;
       }
       if (forceStopped) {
         setForceStopped(false);
@@ -2670,6 +2724,11 @@ const AssistantChatInner = forwardRef<
 
   const materializeFrozenReconnectContent = useCallback(() => {
     if (!reconnectFrozen || reconnectContent.length === 0) return;
+    if (!reconnectCanMaterializeRef.current) {
+      setReconnectFrozen(false);
+      setReconnectContent([]);
+      return;
+    }
     try {
       const frozenContent = cloneContentParts(reconnectContent);
       settleInterruptedToolCalls(frozenContent);
@@ -2710,6 +2769,7 @@ const AssistantChatInner = forwardRef<
       threadRuntime.import(ensureMessageMetadata(repo));
       setReconnectFrozen(false);
       setReconnectContent([]);
+      reconnectCanMaterializeRef.current = false;
     } catch (err) {
       captureError(err, {
         tags: {
@@ -2748,6 +2808,7 @@ const AssistantChatInner = forwardRef<
     setRunErrorInfo(null);
     setDismissedRunErrorKey(null);
     if (runIdToAbort) {
+      if (threadId) clearActiveRunIfMatches(threadId, runIdToAbort);
       fetch(`${apiUrl}/runs/${encodeURIComponent(runIdToAbort)}/abort`, {
         method: "POST",
       }).catch(() => {});
@@ -2756,9 +2817,16 @@ const AssistantChatInner = forwardRef<
       reconnectAbortRef.current?.abort();
       reconnectAbortRef.current = null;
       reconnectRunIdRef.current = null;
-      setReconnectAfterSeq(0);
       setIsReconnecting(false);
-      setReconnectFrozen(reconnectContent.length > 0);
+      const shouldFreezeReconnectContent =
+        reconnectCanMaterializeRef.current && reconnectContent.length > 0;
+      if (shouldFreezeReconnectContent) {
+        setReconnectFrozen(true);
+      } else {
+        setReconnectFrozen(false);
+        setReconnectContent([]);
+        reconnectCanMaterializeRef.current = false;
+      }
     }
     threadRuntime.cancelRun();
     if (typeof window !== "undefined") {
@@ -3610,12 +3678,11 @@ const AssistantChatInner = forwardRef<
                         />
                       )}
                       {(isReconnecting || reconnectFrozen) &&
-                        reconnectAfterSeq === 0 &&
                         reconnectContent.length > 0 && (
                           <ReconnectStreamMessage content={reconnectContent} />
                         )}
                       {(isReconnecting || reconnectFrozen) &&
-                        reconnectAfterSeq > 0 &&
+                        reconnectContent.length === 0 &&
                         reconnectActivityContent.length > 0 && (
                           <ReconnectStreamMessage
                             content={reconnectActivityContent}

package/corpus/core/src/client/active-run-state.ts

@@ -1,4 +1,5 @@
 const STORAGE_KEY = "agent-chat-active-run";
+export const ACTIVE_RUN_STATE_EVENT = "agent-chat:active-run-state-change";
 
 export interface ActiveRunState {
   threadId: string;
@@ -7,6 +8,19 @@ export interface ActiveRunState {
   activityTool?: string | null;
 }
 
+function notifyActiveRunStateChanged(state: ActiveRunState | null): void {
+  if (
+    typeof window === "undefined" ||
+    typeof window.dispatchEvent !== "function" ||
+    typeof CustomEvent === "undefined"
+  ) {
+    return;
+  }
+  window.dispatchEvent(
+    new CustomEvent(ACTIVE_RUN_STATE_EVENT, { detail: { state } }),
+  );
+}
+
 function normalizeActivityTool(toolName: unknown): string | null {
   if (typeof toolName !== "string") return null;
   const tool = toolName.trim();
@@ -17,6 +31,7 @@ export function setActiveRun(state: ActiveRunState): void {
   try {
     sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state));
   } catch {}
+  notifyActiveRunStateChanged(state);
 }
 
 export function getActiveRun(): ActiveRunState | null {
@@ -64,6 +79,13 @@ export function clearActiveRun(): void {
   try {
     sessionStorage.removeItem(STORAGE_KEY);
   } catch {}
+  notifyActiveRunStateChanged(null);
+}
+
+export function clearActiveRunIfMatches(threadId: string, runId: string): void {
+  const state = getActiveRun();
+  if (state?.threadId !== threadId || state.runId !== runId) return;
+  clearActiveRun();
 }
 
 /** Resume reconnect SSE after the last seen event (0 = replay from the start). */

package/corpus/core/src/client/chat/message-components.tsx

@@ -807,6 +807,7 @@ export function shouldShowAssistantMessageFooter({
   hasUnresolvedTool?: boolean;
 }): boolean {
   if (!hasRenderableContent) return false;
+  if (chatRunning) return false;
   if (!isLast) return true;
   if (hasUnresolvedTool) return false;
   return !chatRunning && statusIsTerminal;
@@ -909,7 +910,7 @@ export function AssistantMessage() {
       className="group relative"
       style={{ contentVisibility: isComplete ? "auto" : "visible" }}
     >
-      <div className="max-w-[95%] text-sm leading-relaxed text-foreground">
+      <div className="w-full max-w-[95%] text-sm leading-relaxed text-foreground">
         <MessagePrimitive.Parts
           components={{
             Text: MarkdownText,

package/corpus/core/src/client/chat/tool-call-display.tsx

@@ -418,6 +418,7 @@ export function ToolCallDisplay({
   isRunning,
   structuredMeta,
   approval,
+  repeatCount,
 }: {
   toolName: string;
   argsText?: string;
@@ -428,6 +429,7 @@ export function ToolCallDisplay({
   isRunning: boolean;
   structuredMeta?: Record<string, unknown>;
   approval?: { approvalKey: string; dismissed?: boolean };
+  repeatCount?: number;
 }) {
   // Delegate to bespoke cells when structured metadata is present.
   // These must be separate components so hook order in ToolCallDisplayGeneric
@@ -474,6 +476,7 @@ export function ToolCallDisplay({
       chatUI={chatUI}
       isRunning={isRunning}
       approval={approval}
+      repeatCount={repeatCount}
     />
   );
 }
@@ -487,6 +490,7 @@ function ToolCallDisplayGeneric({
   chatUI,
   isRunning,
   approval,
+  repeatCount,
 }: {
   toolName: string;
   argsText?: string;
@@ -496,6 +500,7 @@ function ToolCallDisplayGeneric({
   chatUI?: ActionChatUIConfig;
   isRunning: boolean;
   approval?: { approvalKey: string; dismissed?: boolean };
+  repeatCount?: number;
 }) {
   const streamRef = useRef<HTMLDivElement>(null);
 
@@ -614,7 +619,7 @@ function ToolCallDisplayGeneric({
   const isExpanded = isAgentCall ? hasStreamText && expanded : expanded;
 
   return (
-    <div className="my-1 overflow-hidden">
+    <div className="my-1 w-full overflow-hidden">
       {mcpApp && <McpAppRenderer app={mcpApp} className="mb-1.5" />}
       <button
         onClick={() => canExpand && setExpanded(!isExpanded)}
@@ -640,6 +645,14 @@ function ToolCallDisplayGeneric({
         <span className="truncate min-w-0">
           <span className="font-medium">{displayName}</span>
         </span>
+        {repeatCount && repeatCount > 1 && (
+          <span
+            className="shrink-0 rounded border border-border/60 px-1.5 py-0.5 text-[10px] leading-none text-muted-foreground"
+            title={`Repeated ${repeatCount} times`}
+          >
+            {repeatCount}x
+          </span>
+        )}
         {canExpand && (
           <IconChevronDown
             className={cn(
@@ -694,6 +707,7 @@ export function ToolCallFallback({
   structuredMeta?: Record<string, unknown>;
   activity?: boolean;
   approval?: { approvalKey: string; dismissed?: boolean };
+  repeatCount?: number;
 }) {
   const chatRunning = React.useContext(ChatRunningContext);
   const isRunning =
@@ -715,6 +729,7 @@ export function ToolCallFallback({
       structuredMeta={rest.structuredMeta}
       isRunning={isRunning}
       approval={rest.approval}
+      repeatCount={rest.repeatCount}
     />
   );
 }
@@ -734,7 +749,7 @@ export function ReconnectStreamMessage({
 
   return (
     <div className="flex justify-start">
-      <div className="max-w-[95%] text-sm leading-relaxed text-foreground space-y-1">
+      <div className="w-full max-w-[95%] text-sm leading-relaxed text-foreground space-y-1">
         {content.map((part, i) => {
           if (part.type === "text") {
             const partStreaming = chatRunning && i === streamingTextPartIndex;
@@ -764,6 +779,7 @@ export function ReconnectStreamMessage({
                   (chatRunning || part.activity === true)
                 }
                 approval={part.approval}
+                repeatCount={part.repeatCount}
               />
             );
           }