@agent-native/core 0.84.34 → 0.84.36

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

@@ -38,21 +38,119 @@ export interface RunStuckBannerProps {
    * observability events (Sentry, PostHog) at the call site.
    */
   onStuckStateChange?: (state: RunStuckState) => void;
+  /**
+   * Automatically abort and retry once when the server reports a run is
+   * alive but has stopped making real progress. Manual controls remain visible
+   * as the fallback if the automatic recovery cannot clear the run.
+   */
+  autoRetry?: boolean;
+  /**
+   * Stable browser-tab/window id used to coordinate automatic retries across
+   * multiple mounted chat views for the same thread. A local id is generated
+   * when omitted.
+   */
+  autoRetryOwnerId?: string;
   /** Extra class on the outer container. */
   className?: string;
 }
 
+const AUTO_RETRY_CLAIM_TTL_MS = 5 * 60 * 1000;
+
+type BusyState = { type: "none" } | { type: "cancel" | "retry"; runId: string };
+
+type MaybeLockManager = {
+  request<T>(
+    name: string,
+    options: { mode?: "exclusive" | "shared"; ifAvailable?: boolean },
+    callback: (lock: unknown) => T | Promise<T>,
+  ): Promise<T>;
+};
+
+function createAutoRetryOwnerId() {
+  const cryptoApi =
+    typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+      ? crypto
+      : null;
+  return cryptoApi?.randomUUID() ?? `owner-${Math.random().toString(36)}`;
+}
+
+function autoRetryClaimKey(threadId: string, runId: string) {
+  return `agent-native:stuck-auto-retry:${threadId}:${runId}`;
+}
+
+function markAutoRetryClaim(key: string, ownerId: string) {
+  if (typeof window === "undefined") return true;
+  const now = Date.now();
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (raw) {
+      const existing = JSON.parse(raw) as {
+        ownerId?: unknown;
+        expiresAt?: unknown;
+      };
+      const expiresAt =
+        typeof existing.expiresAt === "number" ? existing.expiresAt : 0;
+      if (expiresAt > now && existing.ownerId !== ownerId) return false;
+    }
+    window.localStorage.setItem(
+      key,
+      JSON.stringify({ ownerId, expiresAt: now + AUTO_RETRY_CLAIM_TTL_MS }),
+    );
+    const confirmed = JSON.parse(window.localStorage.getItem(key) ?? "{}") as {
+      ownerId?: unknown;
+    };
+    return confirmed.ownerId === ownerId;
+  } catch {
+    // Private browsing or disabled storage: fall back to in-tab retry. The
+    // server abort is idempotent, and manual controls remain available.
+    return true;
+  }
+}
+
+async function claimAutoRetryAttempt(
+  threadId: string | null | undefined,
+  runId: string,
+  ownerId: string,
+) {
+  if (!threadId) return true;
+  const key = autoRetryClaimKey(threadId, runId);
+  const locks =
+    typeof navigator !== "undefined"
+      ? (navigator as Navigator & { locks?: MaybeLockManager }).locks
+      : undefined;
+  if (locks?.request) {
+    try {
+      return await locks.request(
+        key,
+        { mode: "exclusive", ifAvailable: true },
+        (lock) => (lock ? markAutoRetryClaim(key, ownerId) : false),
+      );
+    } catch {
+      return markAutoRetryClaim(key, ownerId);
+    }
+  }
+  return markAutoRetryClaim(key, ownerId);
+}
+
 export function RunStuckBanner({
   threadId,
   apiUrl,
   stuckThresholdMs,
   onRetry,
   onStuckStateChange,
+  autoRetry = false,
+  autoRetryOwnerId,
   className,
 }: RunStuckBannerProps) {
   const state = useRunStuckDetection({ threadId, stuckThresholdMs, apiUrl });
   const abortRun = useAbortRun(apiUrl);
-  const [busy, setBusy] = useState<"none" | "cancel" | "retry">("none");
+  const [busy, setBusy] = useState<BusyState>({ type: "none" });
+  const autoRetriedRunIdsRef = useRef<Set<string>>(new Set());
+  const generatedOwnerIdRef = useRef<string | null>(null);
+  if (!generatedOwnerIdRef.current) {
+    generatedOwnerIdRef.current = createAutoRetryOwnerId();
+  }
+  const ownerId = autoRetryOwnerId ?? generatedOwnerIdRef.current;
 
   const lastReportedRef = useRef<{
     isStuck: boolean;
@@ -77,39 +175,92 @@ export function RunStuckBanner({
     }
   }, [state, onStuckStateChange, threadId]);
 
-  // Reset the busy spinner once the underlying run has flipped away from
-  // running — no need to keep showing a stale "Retrying…" indicator.
+  // Reset the busy spinner once the underlying run is no longer the one we
+  // acted on. A recovery continuation can start quickly enough that polling
+  // never observes an idle state between run ids.
   useEffect(() => {
-    if (state.status !== "running") {
-      setBusy("none");
+    setBusy((current) => {
+      if (current.type === "none") return current;
+      if (state.status !== "running") return { type: "none" };
+      if (state.runId && state.runId !== current.runId) return { type: "none" };
+      return current;
+    });
+  }, [state.runId, state.status]);
+
+  useEffect(() => {
+    if (
+      !autoRetry ||
+      !state.isStuck ||
+      !state.runId ||
+      busy.type !== "none" ||
+      autoRetriedRunIdsRef.current.has(state.runId)
+    ) {
+      return;
     }
-  }, [state.status]);
+
+    const runId = state.runId;
+    void claimAutoRetryAttempt(threadId, runId, ownerId).then((claimed) => {
+      autoRetriedRunIdsRef.current.add(runId);
+      if (!claimed) return;
+      setBusy({ type: "retry", runId });
+      trackEvent("agent_chat_stuck_auto_retry", {
+        runId,
+        threadId: threadId ?? null,
+        stuckSinceMs: state.stuckSinceMs ?? null,
+      });
+      void abortRun(runId, "auto_stuck_retry").then((aborted) => {
+        if (aborted) {
+          onRetry?.(aborted);
+          return;
+        }
+        setBusy((current) =>
+          current.type !== "none" && current.runId === runId
+            ? { type: "none" }
+            : current,
+        );
+      });
+    });
+  }, [
+    abortRun,
+    autoRetry,
+    busy,
+    onRetry,
+    ownerId,
+    state.isStuck,
+    state.runId,
+    state.stuckSinceMs,
+    threadId,
+  ]);
 
   if (!state.isStuck || !state.runId) return null;
 
   const handleCancel = async () => {
-    if (!state.runId || busy !== "none") return;
-    setBusy("cancel");
+    if (!state.runId || busy.type !== "none") return;
+    const runId = state.runId;
+    setBusy({ type: "cancel", runId });
     trackEvent("agent_chat_stuck_cancel", {
-      runId: state.runId,
+      runId,
       threadId: threadId ?? null,
       stuckSinceMs: state.stuckSinceMs ?? null,
     });
-    await abortRun(state.runId, "user_stuck_cancel");
+    await abortRun(runId, "user_stuck_cancel");
   };
 
   const handleRetry = async () => {
-    if (!state.runId || busy !== "none") return;
-    setBusy("retry");
+    if (!state.runId || busy.type !== "none") return;
+    const runId = state.runId;
+    setBusy({ type: "retry", runId });
     trackEvent("agent_chat_stuck_retry", {
-      runId: state.runId,
+      runId,
       threadId: threadId ?? null,
       stuckSinceMs: state.stuckSinceMs ?? null,
     });
-    const aborted = await abortRun(state.runId, "user_stuck_retry");
+    const aborted = await abortRun(runId, "user_stuck_retry");
     if (aborted) onRetry?.(aborted);
   };
 
+  const busyType = busy.type;
+
   const stuckSeconds =
     state.stuckSinceMs != null ? Math.floor(state.stuckSinceMs / 1000) : null;
 
@@ -134,16 +285,19 @@ export function RunStuckBanner({
             No progress
             {stuckSeconds != null ? ` for ${stuckSeconds}s` : ""}. The agent may
             have hit a server timeout or lost its connection.
+            {autoRetry && busyType === "retry"
+              ? " Retrying automatically now."
+              : ""}
           </span>
         </div>
         <div className="flex flex-wrap items-center gap-2">
           <button
             type="button"
             onClick={handleRetry}
-            disabled={busy !== "none"}
+            disabled={busyType !== "none"}
             className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md bg-foreground px-2.5 text-[11px] font-medium text-background transition-colors hover:bg-foreground/90 disabled:cursor-not-allowed disabled:opacity-60"
           >
-            {busy === "retry" ? (
+            {busyType === "retry" ? (
               <IconLoader2
                 size={12}
                 className="animate-spin"
@@ -155,10 +309,10 @@ export function RunStuckBanner({
           <button
             type="button"
             onClick={handleCancel}
-            disabled={busy !== "none"}
+            disabled={busyType !== "none"}
             className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md border border-border bg-background px-2.5 text-[11px] font-medium text-foreground transition-colors hover:bg-accent disabled:cursor-not-allowed disabled:opacity-60"
           >
-            {busy === "cancel" ? (
+            {busyType === "cancel" ? (
               <IconLoader2
                 size={12}
                 className="animate-spin"

package/corpus/core/src/client/blocks/library/wireframe-kit.tsx

@@ -26,10 +26,10 @@ import type {
  * DECOUPLING: the only behavioral change from the plan copy is theme detection —
  * core blocks read `document.documentElement.classList.contains("dark")` (the
  * MermaidBlock precedent) instead of importing `next-themes`. Everything else
- * (the `.plan-wf` / `[data-rough]` class contract the rough overlay measures,
- * the `--wf-*` / `--ink` / `--paper` token names every primitive reads) is
- * preserved exactly, so the kit looks identical in plan and renders correctly in
- * any app once the matching tokens exist in `core/styles/blocks.css`.
+ * (the `.plan-wf` / `.wf-*` / `[data-rough]` class contract the rough overlay
+ * measures, the `--wf-*` / `--ink` / `--paper` token names every primitive
+ * reads) is preserved exactly, so the kit looks identical in plan and renders
+ * correctly in any app once the matching tokens exist in `core/styles/blocks.css`.
  */
 
 /* ========================================================================== */
@@ -211,7 +211,7 @@ export function Screen({
         // clipping. The frame shell (`ArtboardFrame`) owns the height policy; a
         // caller can still override via `style.height` for a fixed canvas.
         minHeight: "100%",
-        background: V.paper,
+        background: "transparent",
         color: V.ink,
         fontFamily: V.hand,
         fontSize: V.fs,
@@ -1425,9 +1425,9 @@ const gen = rough.generator();
 
 type RoughPath = { d: string; stroke: string; strokeWidth: number };
 
-/** The default selector used for HTML mockups: controls plus explicit opt-ins. */
+/** The default selector used for HTML mockups: standard wireframe primitives plus explicit opt-ins. */
 export const HTML_ROUGH_SELECTOR =
-  "[data-rough],button,input,textarea,select,hr";
+  "[data-rough],button,input,textarea,select,hr,.wf-btn,.wf-card,.wf-box,.wf-pill,.wf-chip,.wf-icon-fallback,[style*='border:'],[style*='border-top:'],[style*='border-right:'],[style*='border-bottom:'],[style*='border-left:']";
 
 /** Stable per-element seed so a frame doesn't re-wobble on every measure. */
 function seedFrom(...parts: Array<string | number>): number {
@@ -1528,6 +1528,50 @@ function elementStroke(node: Element, fallback: string): string {
   return fallback;
 }
 
+function visibleBorderSides(
+  node: Element,
+): Array<"top" | "right" | "bottom" | "left"> {
+  const cs = getComputedStyle(node);
+  const sides: Array<"top" | "right" | "bottom" | "left"> = [];
+  for (const [side, widthProp, colorProp] of [
+    ["top", "borderTopWidth", "borderTopColor"],
+    ["right", "borderRightWidth", "borderRightColor"],
+    ["bottom", "borderBottomWidth", "borderBottomColor"],
+    ["left", "borderLeftWidth", "borderLeftColor"],
+  ] as const) {
+    const width = parseFloat(cs[widthProp]);
+    const color = cs[colorProp];
+    if (
+      width > 0 &&
+      color &&
+      color !== "rgba(0, 0, 0, 0)" &&
+      color !== "transparent"
+    ) {
+      sides.push(side);
+    }
+  }
+  return sides;
+}
+
+function inferRoughKind(node: HTMLElement): string {
+  const explicit = node.getAttribute("data-rough");
+  if (explicit) return explicit;
+  if (node.tagName === "HR") return "line:middle";
+  const sides = visibleBorderSides(node);
+  if (sides.length !== 1) return "rect";
+  switch (sides[0]) {
+    case "top":
+      return "line:top";
+    case "right":
+      return "line:right";
+    case "bottom":
+      return "line:bottom";
+    case "left":
+      return "line:left";
+  }
+  return "rect";
+}
+
 function build(
   scope: HTMLElement,
   opts: {
@@ -1602,7 +1646,7 @@ function build(
     const w = r.width / zoom;
     const h = r.height / zoom;
     if (w < 2 || h < 2) return;
-    const kind = node.getAttribute("data-rough") || "rect";
+    const kind = inferRoughKind(node);
     const rawStroke = elementStroke(node, sketch);
     const stroke =
       sameColor(rawStroke, ink) || (line !== "" && sameColor(rawStroke, line))
@@ -1621,11 +1665,15 @@ function build(
     let drawable: unknown;
     if (kind === "ellipse") {
       drawable = gen.ellipse(x + w / 2, y + h / 2, w, h, o);
+    } else if (kind === "line:left") {
+      drawable = gen.line(x, y, x, y + h, o);
     } else if (kind === "line:right") {
       drawable = gen.line(x + w, y, x + w, y + h, o);
     } else if (kind === "line:bottom") {
       drawable = gen.line(x, y + h, x + w, y + h, o);
-    } else if (kind === "line:top" || node.tagName === "HR") {
+    } else if (kind === "line:top") {
+      drawable = gen.line(x, y, x + w, y, o);
+    } else if (kind === "line:middle") {
       drawable = gen.line(x, y + h / 2, x + w, y + h / 2, o);
     } else {
       const cr = parseFloat(getComputedStyle(node).borderTopLeftRadius) || 0;

package/corpus/core/src/client/blocks/library/wireframe.tsx

@@ -56,8 +56,8 @@ import {
  * - The plan-only prototype runtime, design-element selection, and legacy region
  *   fallback are intentionally NOT ported; those are plan-canvas features, not
  *   part of the document-block render. The kit element vocabulary, the `--wf-*`
- *   token contract, and the `.plan-wf` / `[data-rough]` classes the overlay
- *   measures are preserved exactly.
+ *   token contract, and the `.plan-wf` / `.wf-*` / `[data-rough]` classes the
+ *   overlay measures are preserved exactly.
  *
  * The section carries the app-neutral `an-block` class plus the legacy
  * `plan-block` class so plan renders byte-identically while any other app gets
@@ -164,12 +164,6 @@ function ArtboardFrame({
   const designMode = renderMode === "design";
   const sketchy = !designMode && style === "sketchy" && !skeleton;
   const roughEnabled = sketchy && roughOverlay;
-  const paper = designMode
-    ? "hsl(var(--background))"
-    : "var(--plan-document, hsl(var(--background)))";
-  const frameBorder = skeleton
-    ? "var(--plan-placeholder-line, var(--plan-line, hsl(var(--border))))"
-    : "var(--plan-line, hsl(var(--border)))";
 
   useEffect(() => {
     const element = fitRef.current;
@@ -243,7 +237,6 @@ function ArtboardFrame({
             // a fixed `canvasSize` locks the height for canvas artboards.
             ...(fixedHeight != null ? { height: fixedHeight } : { minHeight }),
             borderRadius: preset.radius,
-            background: paper,
             ...(fitScale !== 1
               ? {
                   transform: `scale(${fitScale})`,
@@ -266,18 +259,10 @@ function ArtboardFrame({
           >
             {render({ theme, style })}
           </div>
-          {!roughEnabled && (
-            <div
-              className="pointer-events-none absolute inset-0"
-              style={{
-                borderRadius: preset.radius,
-                border: `1.5px solid ${frameBorder}`,
-              }}
-            />
-          )}
           <RoughOverlay
             scopeRef={ref}
             enabled={roughEnabled}
+            drawFrame={false}
             frameRadius={preset.radius}
             selector={selector}
           />

package/corpus/core/src/client/chat/widgets/builtin-tool-renderers.tsx

@@ -34,10 +34,37 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 function normalizeActionDataWidgetResult(
   context: ToolRendererContext,
 ): DataWidgetResult | null {
+  const renderer = context.chatUI?.renderer;
+  if (isRecord(context.resultJson)) {
+    if (renderer === ACTION_CHAT_UI_DATA_TABLE_RENDERER) {
+      return normalizeDataWidgetResult({
+        ...context.resultJson,
+        widget: DATA_TABLE_WIDGET,
+        table: isRecord(context.resultJson.table)
+          ? context.resultJson.table
+          : context.resultJson,
+      });
+    }
+    if (renderer === ACTION_CHAT_UI_DATA_CHART_RENDERER) {
+      return normalizeDataWidgetResult({
+        ...context.resultJson,
+        widget: DATA_CHART_WIDGET,
+        chartSeries: isRecord(context.resultJson.chartSeries)
+          ? context.resultJson.chartSeries
+          : context.resultJson,
+      });
+    }
+    if (renderer === ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER) {
+      return normalizeDataWidgetResult({
+        ...context.resultJson,
+        widget: DATA_INSIGHTS_WIDGET,
+      });
+    }
+  }
+
   const result = normalizeDataWidgetResult(context.resultJson);
   if (result) return result;
 
-  const renderer = context.chatUI?.renderer;
   if (
     renderer === ACTION_CHAT_UI_DATA_WIDGET_RENDERER ||
     context.toolName === "render-data-widget"
@@ -46,37 +73,6 @@ function normalizeActionDataWidgetResult(
     if (argsResult) return argsResult;
   }
 
-  if (!isRecord(context.resultJson)) return null;
-
-  if (renderer === ACTION_CHAT_UI_DATA_TABLE_RENDERER) {
-    return normalizeDataWidgetResult({
-      widget: DATA_TABLE_WIDGET,
-      table: isRecord(context.resultJson.table)
-        ? context.resultJson.table
-        : context.resultJson,
-      display: isRecord(context.resultJson.display)
-        ? context.resultJson.display
-        : undefined,
-    });
-  }
-  if (renderer === ACTION_CHAT_UI_DATA_CHART_RENDERER) {
-    return normalizeDataWidgetResult({
-      widget: DATA_CHART_WIDGET,
-      chartSeries: isRecord(context.resultJson.chartSeries)
-        ? context.resultJson.chartSeries
-        : context.resultJson,
-      display: isRecord(context.resultJson.display)
-        ? context.resultJson.display
-        : undefined,
-    });
-  }
-  if (renderer === ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER) {
-    return normalizeDataWidgetResult({
-      ...context.resultJson,
-      widget: DATA_INSIGHTS_WIDGET,
-    });
-  }
-
   return null;
 }
 

package/corpus/core/src/client/code-agent-chat-adapter.ts

@@ -180,7 +180,8 @@ export function createCodeAgentChatAdapter(
           }
 
           const content = codeAgentTranscriptEventsToContent(tailedEvents);
-          if (content.length > 0 && nextEvents.length > 0) {
+          const sawClear = nextEvents.some(isAgentChatClearTranscriptEvent);
+          if ((content.length > 0 || sawClear) && nextEvents.length > 0) {
             yieldedContent = true;
             yield withRunMetadata({ content: [...content] }, runId);
           }
@@ -249,6 +250,12 @@ export function codeAgentTranscriptEventsToContent(
   return content;
 }
 
+function isAgentChatClearTranscriptEvent(
+  event: CodeAgentChatTranscriptEvent | undefined,
+): boolean {
+  return event?.metadata?.agentChatEventType === "clear";
+}
+
 function latestUserMessage(
   messages: ChatModelRunOptions["messages"],
 ): ChatModelRunOptions["messages"][number] | undefined {

package/corpus/core/src/client/sse-event-processor.ts

@@ -698,11 +698,15 @@ export function processEvent(
   };
 } {
   if (ev.type === "clear") {
-    // Server is retrying — discard partial text/tool output from the failed attempt
-    content.length = 0;
+    // Server is retrying — discard rejected draft text and unfinished tool
+    // output while keeping completed tool results visible.
+    clearAssistantDraftContent(content);
     resetProcessEventState(state);
     dispatchActivityClear(tabId);
-    return { action: "continue" };
+    return {
+      action: "yield",
+      result: { content: contentSnapshot(content) } as ChatModelRunResult,
+    };
   }
 
   if (ev.type === "text") {
@@ -1159,6 +1163,20 @@ export function processEvent(
   return { action: "continue" };
 }
 
+function clearAssistantDraftContent(content: ContentPart[]): void {
+  for (let index = content.length - 1; index >= 0; index--) {
+    const part = content[index];
+    if (!part) continue;
+    if (part.type === "text") {
+      content.splice(index, 1);
+      continue;
+    }
+    if (part.type === "tool-call" && part.result === undefined) {
+      content.splice(index, 1);
+    }
+  }
+}
+
 /**
  * Read and process SSE events from a ReadableStream response body.
  * Yields ChatModelRunResult for each meaningful event.

package/corpus/core/src/code-agents/transcript-normalizer.ts

@@ -92,6 +92,12 @@ export function normalizeCodeAgentTranscript(
 
   for (const event of events) {
     const currentTurnIndex = Math.max(turnIndex, 0);
+    if (isAgentChatClearEvent(event)) {
+      clearNormalizedAgentDraftItems(items, currentTurnIndex);
+      hiddenEvents.push(event);
+      continue;
+    }
+
     if (event.kind === "user") {
       turnIndex = turnIndex < 0 ? (items.length === 0 ? 0 : 1) : turnIndex + 1;
       items.push(createUserTurn(event, turnIndex));
@@ -359,6 +365,31 @@ function findOpenToolEvent(
   return null;
 }
 
+function isAgentChatClearEvent(event: CodeAgentTranscriptEvent): boolean {
+  return stringMetadata(event.metadata, "agentChatEventType") === "clear";
+}
+
+function clearNormalizedAgentDraftItems(
+  items: NormalizedCodeAgentTranscriptItem[],
+  turnIndex: number,
+): void {
+  for (let index = items.length - 1; index >= 0; index--) {
+    const item = items[index];
+    if (!item || item.turnIndex !== turnIndex) continue;
+    if (
+      item.type === "assistant" ||
+      item.type === "thinking" ||
+      item.type === "status"
+    ) {
+      items.splice(index, 1);
+      continue;
+    }
+    if (item.type === "tool" && item.state !== "completed") {
+      items.splice(index, 1);
+    }
+  }
+}
+
 function suppressDuplicateFinalAssistantText(
   items: readonly NormalizedCodeAgentTranscriptItem[],
   hiddenEvents: CodeAgentTranscriptEvent[],

package/corpus/core/src/db/schema.ts

@@ -19,6 +19,7 @@
 import { sql } from "drizzle-orm";
 import {
   pgTable,
+  alias as pgAlias,
   index as pgIndex,
   text as pgText,
   integer as pgInteger,
@@ -28,6 +29,7 @@ import {
 } from "drizzle-orm/pg-core";
 import {
   sqliteTable,
+  alias as sqliteAlias,
   index as sqliteIndex,
   text as sqliteText,
   integer as sqliteInteger,
@@ -50,6 +52,9 @@ function pg(): boolean {
 export const table: typeof sqliteTable = ((...args: any[]) =>
   pg() ? (pgTable as any)(...args) : (sqliteTable as any)(...args)) as any;
 
+export const alias: typeof sqliteAlias = ((...args: any[]) =>
+  pg() ? (pgAlias as any)(...args) : (sqliteAlias as any)(...args)) as any;
+
 export const index: typeof sqliteIndex = ((...args: any[]) =>
   pg() ? (pgIndex as any)(...args) : (sqliteIndex as any)(...args)) as any;
 

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -21,7 +21,10 @@ import {
   hasConfiguredA2ASecret,
   isA2AProductionRuntime,
 } from "../a2a/auth-policy.js";
-import { collectFinalResponseTextFromAgentEvents } from "../a2a/response-text.js";
+import {
+  applyAgentTextEventToBuffer,
+  collectFinalResponseTextFromAgentEvents,
+} from "../a2a/response-text.js";
 import { updateTaskStatusMessage } from "../a2a/task-store.js";
 import { ACTION_CHAT_UI_DATA_WIDGET_RENDERER } from "../action-ui.js";
 import type { ActionHttpConfig } from "../action.js";
@@ -5179,7 +5182,10 @@ export function createAgentChatPlugin(
                 ],
                 actions: mcpActions,
                 send: (event) => {
-                  if (event.type === "text") accumulatedText += event.text;
+                  accumulatedText = applyAgentTextEventToBuffer(
+                    accumulatedText,
+                    event,
+                  );
                 },
                 signal: controller.signal,
               },