@agent-native/toolkit 0.226.0 → 0.226.1-nightly-20261107004051

package/src/app/agentkit/react/components.tsx

@@ -2268,18 +2268,21 @@ export const AgentActivityGroup = memo(function AgentActivityGroup({
   messageId,
   foldedReasoningMessageId,
   summarizesTurn = false,
+  part,
 }: {
-  runId?: RunId;
-  afterSequence?: number;
-  throughSequence?: number;
-  excludeAgentActivities?: boolean;
-  isCurrentSegment?: boolean;
+  runId?: RunId | undefined;
+  afterSequence?: number | undefined;
+  throughSequence?: number | undefined;
+  excludeAgentActivities?: boolean | undefined;
+  isCurrentSegment?: boolean | undefined;
   /** The reply this work segment precedes. */
-  messageId?: string;
+  messageId?: string | undefined;
   /** A saved reply whose reasoning before its answer joins this group. */
-  foldedReasoningMessageId?: string;
+  foldedReasoningMessageId?: string | undefined;
   /** This segment is its run's whole turn, so it shows a row with no work. */
-  summarizesTurn?: boolean;
+  summarizesTurn?: boolean | undefined;
+  /** Only the steps' result cards, or only the work row; both by default. */
+  part?: "results" | "row" | undefined;
 }) {
   const {
     threadId,
@@ -2598,6 +2601,15 @@ export const AgentActivityGroup = memo(function AgentActivityGroup({
       minute: labels.durationMinuteShort,
       second: labels.durationSecondShort,
     });
+  const resultCards =
+    durableToolResults.length && part !== "row" ? (
+      <div data-agentkit-tool-results="true">
+        {durableToolResults.map(({ tool, Renderer }) => (
+          <Renderer key={tool.id} value={tool} threadId={threadId} />
+        ))}
+      </div>
+    ) : null;
+  if (part === "results") return resultCards;
   if (
     activityItems.length === 0 &&
     durableToolResults.length === 0 &&
@@ -2732,13 +2744,7 @@ export const AgentActivityGroup = memo(function AgentActivityGroup({
   };
   return (
     <>
-      {durableToolResults.length ? (
-        <div data-agentkit-tool-results="true">
-          {durableToolResults.map(({ tool, Renderer }) => (
-            <Renderer key={tool.id} value={tool} threadId={threadId} />
-          ))}
-        </div>
-      ) : null}
+      {resultCards}
       {hasExpandableActivity || activelyWorking ? (
         <AgentWorkDisclosure
           label={baseSummaryLabel}
@@ -3353,7 +3359,13 @@ function AgentWorkDisclosure({
   children: ReactNode;
 }) {
   const { slots, labels, workedForRowLayout } = useAgentKit();
-  const [open, setOpen] = useState(false);
+  const row = useContext(AgentWorkRowOpenContext);
+  const [open, setOpen] = useState(() => row?.opened.has(row.key) ?? false);
+  useEffect(() => {
+    if (!row) return;
+    if (open) row.opened.add(row.key);
+    else row.opened.delete(row.key);
+  }, [open, row]);
   const contentId = useId();
   const Summary = slots.workedForSummary;
   const failed =
@@ -3368,9 +3380,7 @@ function AgentWorkDisclosure({
     ? failed.split("{{summary}}")
     : ["", ""];
   const fullLabel = failed ? failed.replace("{{summary}}", () => label) : label;
-  const footer = useAgentMessageWorkHost(running ? undefined : messageId);
-  const footerHost = footer?.element ?? null;
-  const handoff = useAgentWorkHandoff(running, footer, setOpen);
+  const footerHost = useAgentMessageWorkHost(messageId);
   const summaryLabel = label ? (
     <span className="agentkit-activities-label">
       {failedBefore || failedAfter ? (
@@ -3403,12 +3413,10 @@ function AgentWorkDisclosure({
   // work with nothing to expand is text, not a disabled button.
   const disclosure = (
     <div
-      ref={handoff.inPlaceRef}
       className="agentkit-activities"
       data-running={running ? "true" : undefined}
       data-expandable={expandable ? "true" : "false"}
       data-open={open ? "true" : "false"}
-      data-handoff={handoff.leavingHeight ? "enter" : undefined}
     >
       <AgentKitDisclosureSummary
         as={expandable || running ? "button" : "static"}
@@ -3437,92 +3445,9 @@ function AgentWorkDisclosure({
       </AgentKitDisclosureContent>
     </div>
   );
-  // Finished work joins its reply's controls under the reply; live work stays
-  // above it, where it is happening. On a live finish the space it left above
-  // the reply closes over the same beat as the row fades in below, so the
-  // reply glides up instead of jumping.
-  return (
-    <>
-      {handoff.leavingHeight ? (
-        <div
-          className="agentkit-work-handoff"
-          data-agentkit-work-handoff="leave"
-          aria-hidden="true"
-          inert
-          style={
-            {
-              "--agentkit-work-handoff-size": `${handoff.leavingHeight}px`,
-            } as CSSProperties
-          }
-        >
-          <AgentKitDisclosureSummary
-            as="static"
-            className="agentkit-activities-summary"
-            rowClassName="agentkit-activities-row"
-            open={false}
-            onToggle={noop}
-            expandable={false}
-            style={workedForRowSummaryStyle(workedForRowLayout)}
-            icon={icon}
-            label={summaryLabel}
-          >
-            {summaryContent}
-          </AgentKitDisclosureSummary>
-        </div>
-      ) : null}
-      {footerHost ? createPortal(disclosure, footerHost) : disclosure}
-    </>
-  );
-}
-
-const AGENT_WORK_HANDOFF_MS = 180;
-
-/**
- * Tracks a work row's move from above its reply to the reply's footer. Only
- * a finish seen live animates (the row ran, or its reply streamed): a saved
- * thread renders the row in place for one unpainted pass before its host
- * registers, and that must not read as a finish. A row opened to watch live
- * work closes as it moves, so its steps never land below the reply.
- */
-function useAgentWorkHandoff(
-  running: boolean | undefined,
-  footer: AgentMessageWorkHost | null,
-  setOpen: (open: boolean) => void,
-) {
-  const prefersReducedMotion = usePrefersReducedMotion();
-  const footerHost = footer?.element ?? null;
-  const live = footer?.live ?? false;
-  const inPlaceRef = useRef<HTMLDivElement>(null);
-  const sawRunningRef = useRef(false);
-  const inPlaceHeightRef = useRef(0);
-  const previousHostRef = useRef<HTMLElement | null>(null);
-  const [leavingHeight, setLeavingHeight] = useState(0);
-  // Measured on every in-place commit, because once the row portals away
-  // its old box is gone. The placeholder keeps the row's margins from the
-  // stylesheet, so only the border box is carried over.
-  useLayoutEffect(() => {
-    if (running) sawRunningRef.current = true;
-    if (footerHost || !inPlaceRef.current) return;
-    inPlaceHeightRef.current = inPlaceRef.current.offsetHeight;
-  });
-  useLayoutEffect(() => {
-    const previousHost = previousHostRef.current;
-    previousHostRef.current = footerHost;
-    if (!footerHost || previousHost) return;
-    if (!live && !sawRunningRef.current) return;
-    setOpen(false);
-    if (prefersReducedMotion || inPlaceHeightRef.current <= 0) return;
-    setLeavingHeight(inPlaceHeightRef.current);
-  }, [footerHost, live, prefersReducedMotion, setOpen]);
-  useEffect(() => {
-    if (!leavingHeight) return;
-    const timer = setTimeout(
-      () => setLeavingHeight(0),
-      AGENT_WORK_HANDOFF_MS + 60,
-    );
-    return () => clearTimeout(timer);
-  }, [leavingHeight]);
-  return { inPlaceRef, leavingHeight: footerHost ? leavingHeight : 0 };
+  // A reply's work sits on its footer line, live or finished, so the finish
+  // never moves it.
+  return footerHost ? createPortal(disclosure, footerHost) : disclosure;
 }
 
 function AgentReasoningPartDisclosure({
@@ -4903,38 +4828,29 @@ function selectedRunModel(
 /**
  * A finished reply's footer offers a host under its message id, and the
  * reply's work row portals into it so it shares the line with the controls.
- * `live` says the footer saw its reply stream, so the row arriving is a
- * finish the reader watched, not a saved reply loading.
  */
-interface AgentMessageWorkHost {
-  element: HTMLElement;
-  live: boolean;
-}
-
 interface AgentMessageWorkHosts {
-  get: (messageId: string) => AgentMessageWorkHost | undefined;
-  set: (messageId: string, host: AgentMessageWorkHost) => void;
+  get: (messageId: string) => HTMLElement | undefined;
+  set: (messageId: string, element: HTMLElement) => void;
   release: (messageId: string, element: HTMLElement) => void;
   subscribe: (listener: () => void) => () => void;
 }
 
 function createAgentMessageWorkHosts(): AgentMessageWorkHosts {
-  const hosts = new Map<string, AgentMessageWorkHost>();
+  const hosts = new Map<string, HTMLElement>();
   const listeners = new Set<() => void>();
   const notify = () => {
     for (const listener of listeners) listener();
   };
   return {
     get: (messageId) => hosts.get(messageId),
-    set(messageId, host) {
-      const current = hosts.get(messageId);
-      if (current?.element === host.element && current.live === host.live)
-        return;
-      hosts.set(messageId, host);
+    set(messageId, element) {
+      if (hosts.get(messageId) === element) return;
+      hosts.set(messageId, element);
       notify();
     },
     release(messageId, element) {
-      if (hosts.get(messageId)?.element !== element) return;
+      if (hosts.get(messageId) !== element) return;
       hosts.delete(messageId);
       notify();
     },
@@ -4945,6 +4861,16 @@ function createAgentMessageWorkHosts(): AgentMessageWorkHosts {
   };
 }
 
+/**
+ * The work rows the reader opened, by run and segment. A segment's row
+ * remounts when narration hides it and again when the run finishes, and an
+ * opened row comes back open.
+ */
+const AgentWorkRowOpenContext = createContext<{
+  key: string;
+  opened: Set<string>;
+} | null>(null);
+
 const AgentMessageWorkHostsContext =
   createContext<AgentMessageWorkHosts | null>(null);
 
@@ -4954,7 +4880,7 @@ function noopSubscribe() {
 
 function useAgentMessageWorkHost(
   messageId: string | undefined,
-): AgentMessageWorkHost | null {
+): HTMLElement | null {
   const hosts = useContext(AgentMessageWorkHostsContext);
   return useSyncExternalStore(
     hosts?.subscribe ?? noopSubscribe,
@@ -4963,23 +4889,17 @@ function useAgentMessageWorkHost(
   );
 }
 
-/**
- * A callback ref that offers its element as a reply's work row host once
- * the reply stops streaming.
- */
+/** A callback ref that offers its element as a reply's work row host. */
 function useAgentMessageWorkHostRef(
   messageId: string | undefined,
-  streaming: boolean,
 ): (element: HTMLElement | null) => void {
   const hosts = useContext(AgentMessageWorkHostsContext);
   const [element, setElement] = useState<HTMLElement | null>(null);
-  const sawStreamingRef = useRef(false);
   useLayoutEffect(() => {
-    if (streaming) sawStreamingRef.current = true;
-    if (!hosts || !messageId || !element || streaming) return;
-    hosts.set(messageId, { element, live: sawStreamingRef.current });
+    if (!hosts || !messageId || !element) return;
+    hosts.set(messageId, element);
     return () => hosts.release(messageId, element);
-  }, [element, hosts, messageId, streaming]);
+  }, [element, hosts, messageId]);
   return setElement;
 }
 
@@ -5376,10 +5296,9 @@ export const AgentMessageActions = memo(function AgentMessageActions({
   const { messageSeq, requestId, runId } = position;
   const isAssistant = message.role === "assistant";
   const isLastAssistantMessage = isAssistant && position.isLast;
-  // A streaming reply keeps its work above it until the answer is complete.
+  // The reply's work row sits on this footer line, live or finished.
   const workHostRef = useAgentMessageWorkHostRef(
     isAssistant ? message.id : undefined,
-    message.status === "streaming",
   );
   const [copied, setCopied] = useState(false);
   const [feedback, setFeedback] = useState<"positive" | "negative" | null>(
@@ -6166,7 +6085,7 @@ export function AgentRunFailure({
             </ActionButton>
           </div>
         ) : null}
-        {continueFailed ? (
+        {continueFailed && !superseded ? (
           <span className="agentkit-command-error" role="alert">
             {labels.continueRunUnavailable}
           </span>
@@ -7801,6 +7720,7 @@ export function AgentKitChat({
     [editingMessage, messageEditEnabled, setEditingMessage],
   );
   const [messageWorkHosts] = useState(createAgentMessageWorkHosts);
+  const [openedWorkRows] = useState(() => new Set<string>());
   const hasConversation =
     thread.messages.length > 0 ||
     pendingSubmissions.length > 0 ||
@@ -8475,6 +8395,12 @@ export function AgentKitChat({
       return messageId ? [messageId] : [];
     }),
   );
+  // A saved reply's reasoning before its answer joins the work group above
+  // it, so the turn shows one disclosure; the stream did not place it there.
+  const foldsLeadingReasoning = (message: AgentMessage) =>
+    message.status !== "streaming" &&
+    !groupedReasoningMessageIds.has(message.id) &&
+    leadingReasoningMessage(message) !== undefined;
   const hasRunWork = (
     runId: RunId,
     afterSequence?: number,
@@ -8487,7 +8413,7 @@ export function AgentKitChat({
     );
   // A message the user sent into a running turn ends the run's work so far,
   // even when no reply was written before it.
-  const { runSegmentEnds, steerSequences } = useMemo(() => {
+  const { runSegmentEnds, runSegmentStarts, steerSequences } = useMemo(() => {
     const deliveredAt = new Map<string, number>();
     for (const event of thread.events) {
       if (
@@ -8499,15 +8425,19 @@ export function AgentKitChat({
       }
     }
     const ends = new Map<RunId, { id: string; sequence: number }>();
+    const starts = new Map<RunId, { id: string; sequence: number }>();
     const steers = new Map<string, number>();
+    const endSegment = (runId: RunId, id: string, sequence: number) => {
+      const previous = ends.get(runId);
+      if (previous) starts.set(runId, previous);
+      ends.set(runId, { id, sequence });
+    };
     for (const message of thread.messages) {
       const runId = messageRunIds.get(message.id);
       if (!runId) continue;
       if (message.role === "assistant") {
         const sequence = messageBoundarySequences.get(message.id);
-        if (sequence !== undefined) {
-          ends.set(runId, { id: message.id, sequence });
-        }
+        if (sequence !== undefined) endSegment(runId, message.id, sequence);
         continue;
       }
       const sequence =
@@ -8524,9 +8454,13 @@ export function AgentKitChat({
       );
       if (!workBefore) continue;
       steers.set(message.id, sequence);
-      ends.set(runId, { id: message.id, sequence });
+      endSegment(runId, message.id, sequence);
     }
-    return { runSegmentEnds: ends, steerSequences: steers };
+    return {
+      runSegmentEnds: ends,
+      runSegmentStarts: starts,
+      steerSequences: steers,
+    };
   }, [
     messageBoundarySequences,
     messageRunIds,
@@ -8564,19 +8498,40 @@ export function AgentKitChat({
     ]),
   );
   const pendingRuns = new Set(pendingRunIds);
-  // A running turn's work after its reply's latest text joins the row above
-  // that reply. As its own row below, the work before reads as finished while
-  // the run is still working, and the turn shows two rows until it ends.
-  const liveReplyRunIds = new Set(
-    pendingRunIds.filter((runId) => {
-      const reply = lastAssistantMessagesByRun.get(runId);
-      return (
-        thread.runs[runId]?.status === "running" &&
-        reply !== undefined &&
-        runSegmentEnds.get(runId)?.id === reply.id
-      );
-    }),
-  );
+  // While a run works on its reply, the reply's work is one row below its
+  // latest text, shown while work runs there: above the reply, narration
+  // pushes it out of view, and split at that text, the work before reads as
+  // finished while the run works. Result cards stay above the reply, where
+  // they sit once it finishes. A finished reply with nothing running after
+  // it keeps its row in its footer.
+  const liveReplies = new Map<
+    RunId,
+    {
+      replyId: string;
+      start: { id: string; sequence: number } | undefined;
+      foldsReasoning: boolean;
+    }
+  >();
+  for (const [runId, reply] of lastAssistantMessagesByRun) {
+    if (
+      thread.runs[runId]?.status !== "running" ||
+      runSegmentEnds.get(runId)?.id !== reply.id
+    ) {
+      continue;
+    }
+    const start = runSegmentStarts.get(runId);
+    const message = thread.messages.find(({ id }) => id === reply.id);
+    if (
+      (message?.status === "streaming" || pendingRuns.has(runId)) &&
+      hasRunWork(runId, start?.sequence)
+    ) {
+      liveReplies.set(runId, {
+        replyId: reply.id,
+        start,
+        foldsReasoning: message ? foldsLeadingReasoning(message) : false,
+      });
+    }
+  }
   const runRevision = (runId: RunId) =>
     `${runId}:${eventIndex.byRun.get(runId)?.length ?? 0}`;
   const renderRunFailure = (runId: RunId) => {
@@ -8630,6 +8585,7 @@ export function AgentKitChat({
     messageId,
     foldedReasoningMessageId,
     summarizesTurn,
+    part,
   }: {
     runId: RunId;
     anchor: string;
@@ -8638,8 +8594,10 @@ export function AgentKitChat({
     messageId?: string | undefined;
     foldedReasoningMessageId?: string | undefined;
     summarizesTurn?: boolean | undefined;
+    part?: "results" | "row" | undefined;
   }) => {
-    const key = `run-work:${threadId}:${runId}:${anchor}`;
+    const openKey = `${threadId}:${runId}:${anchor}`;
+    const key = `run-work:${openKey}${part === "row" ? ":row" : ""}`;
     const resetKey = `${anchor}:${runRevision(runId)}`;
     return cachedRowElement(
       key,
@@ -8650,10 +8608,12 @@ export function AgentKitChat({
         messageId,
         foldedReasoningMessageId,
         summarizesTurn,
+        part,
       ],
       () =>
         renderRunWorkElement({
           key,
+          openKey,
           resetKey,
           runId,
           afterSequence,
@@ -8661,11 +8621,13 @@ export function AgentKitChat({
           messageId,
           foldedReasoningMessageId,
           summarizesTurn,
+          part,
         }),
     );
   };
   const renderRunWorkElement = ({
     key,
+    openKey,
     resetKey,
     runId,
     afterSequence,
@@ -8673,8 +8635,10 @@ export function AgentKitChat({
     messageId,
     foldedReasoningMessageId,
     summarizesTurn,
+    part,
   }: {
     key: string;
+    openKey: string;
     resetKey: string;
     runId: RunId;
     afterSequence?: number | undefined;
@@ -8682,33 +8646,61 @@ export function AgentKitChat({
     messageId?: string | undefined;
     foldedReasoningMessageId?: string | undefined;
     summarizesTurn?: boolean | undefined;
+    part?: "results" | "row" | undefined;
   }) => (
     <AgentKitSurfaceBoundary key={key} surface="activity" resetKey={resetKey}>
-      <AgentCollaborationFeed
-        runId={runId}
-        afterSequence={afterSequence}
-        throughSequence={throughSequence}
-      />
-      <AgentTaskGroup
-        runId={runId}
-        afterSequence={afterSequence}
-        throughSequence={throughSequence}
-      />
-      <AgentActivityGroup
-        runId={runId}
-        afterSequence={afterSequence}
-        throughSequence={throughSequence}
-        excludeAgentActivities
-        isCurrentSegment={throughSequence === undefined}
-        messageId={messageId}
-        foldedReasoningMessageId={foldedReasoningMessageId}
-        summarizesTurn={summarizesTurn}
-      />
+      <AgentWorkRowOpenContext.Provider
+        value={{ key: openKey, opened: openedWorkRows }}
+      >
+        {part === "row" ? null : (
+          <>
+            <AgentCollaborationFeed
+              runId={runId}
+              afterSequence={afterSequence}
+              throughSequence={throughSequence}
+            />
+            <AgentTaskGroup
+              runId={runId}
+              afterSequence={afterSequence}
+              throughSequence={throughSequence}
+            />
+          </>
+        )}
+        <AgentActivityGroup
+          runId={runId}
+          afterSequence={afterSequence}
+          throughSequence={throughSequence}
+          excludeAgentActivities
+          isCurrentSegment={throughSequence === undefined}
+          messageId={messageId}
+          foldedReasoningMessageId={foldedReasoningMessageId}
+          summarizesTurn={summarizesTurn}
+          part={part}
+        />
+      </AgentWorkRowOpenContext.Provider>
     </AgentKitSurfaceBoundary>
   );
   const renderRunTail = (runId: RunId) => {
     const items: ReactNode[] = [];
-    if (pendingRuns.has(runId)) {
+    const liveReply = liveReplies.get(runId);
+    if (liveReply) {
+      // While the reply's text is the newest output the text is the focus,
+      // so the row shows only while work runs after it.
+      if (pendingRuns.has(runId)) {
+        items.push(
+          renderRunWork({
+            runId,
+            anchor: liveReply.start?.id ?? "start",
+            afterSequence: liveReply.start?.sequence,
+            messageId: liveReply.replyId,
+            foldedReasoningMessageId: liveReply.foldsReasoning
+              ? liveReply.replyId
+              : undefined,
+            part: "row",
+          }),
+        );
+      }
+    } else if (pendingRuns.has(runId)) {
       const boundary = runSegmentEnds.get(runId);
       items.push(
         renderRunWork({
@@ -8752,7 +8744,8 @@ export function AgentKitChat({
   }
   const tailRunIds = Array.from(
     new Set([
-      ...pendingRunIds.filter((runId) => !liveReplyRunIds.has(runId)),
+      ...pendingRunIds,
+      ...liveReplies.keys(),
       ...Array.from(failedRuns.keys()).filter(
         (runId) => !lastAssistantMessagesByRun.has(runId),
       ),
@@ -8886,10 +8879,8 @@ export function AgentKitChat({
       !hasRunWork(runId, sequence) &&
       !hasVisibleReasoning(message),
     );
-    const extendsLiveWork =
-      isAssistantBoundary &&
-      liveReplyRunIds.has(runId) &&
-      lastAssistantMessagesByRun.get(runId)?.id === message.id;
+    const isLiveReply =
+      isAssistantBoundary && liveReplies.get(runId)?.replyId === message.id;
     const rendersRunWork = Boolean(
       isAssistantBoundary &&
       runId &&
@@ -8897,26 +8888,21 @@ export function AgentKitChat({
         hasRunWork(
           runId,
           previousAssistant?.sequence,
-          extendsLiveWork ? undefined : sequence,
+          isLiveReply ? undefined : sequence,
         )),
     );
-    // A saved reply's reasoning before its answer joins the work group above
-    // it, so the turn shows one disclosure; the stream did not place it there.
-    const foldsReasoning =
-      rendersRunWork &&
-      message.status !== "streaming" &&
-      !groupedReasoningMessageIds.has(message.id) &&
-      leadingReasoningMessage(message) !== undefined;
+    const foldsReasoning = rendersRunWork && foldsLeadingReasoning(message);
     if (rendersRunWork && runId) {
       transcriptItems.push(
         renderRunWork({
           runId,
           anchor: previousAssistant?.id ?? "start",
           afterSequence: previousAssistant?.sequence,
-          throughSequence: extendsLiveWork ? undefined : sequence,
+          throughSequence: isLiveReply ? undefined : sequence,
           messageId: message.id,
           foldedReasoningMessageId: foldsReasoning ? message.id : undefined,
           summarizesTurn,
+          part: isLiveReply ? "results" : undefined,
         }),
       );
     }

package/src/app/agentkit/react/lifecycle.spec.tsx

@@ -1093,21 +1093,9 @@ describe("AgentChat lifecycle", () => {
         ?.querySelector(".agentkit-message-actions")
         ?.getAttribute("data-streaming"),
     ).toBe("true");
-    expect(runWorkAfter).not.toBeNull();
-    expect(
-      runWorkAfter?.querySelector(".agentkit-activities-label")?.textContent,
-    ).toBe("Worked for 4s");
-    expect(runWorkAfter?.textContent).not.toContain("Thinking");
-    expect(
-      runWorkAfter?.querySelector("[data-agentkit-current-activity]"),
-    ).toBeNull();
-    expect(runWorkAfter?.querySelector('[data-status="running"]')).toBeNull();
-    expect(
-      runWorkAfter && response
-        ? runWorkAfter.compareDocumentPosition(response) &
-            Node.DOCUMENT_POSITION_FOLLOWING
-        : 0,
-    ).not.toBe(0);
+    // oracle-change: while the reply streams after the run's work, the text is the focus, so no work row shows until the run finishes.
+    expect(runWorkAfter).toBeNull();
+    expect(tree.container.textContent).not.toContain("Thinking");
 
     observable.update({
       connection: "connected",
@@ -1566,7 +1554,8 @@ describe("AgentChat lifecycle", () => {
     expect(
       tree.container.querySelector("[data-visible-empty-widget]")?.textContent,
     ).toBe("Rendered widget");
-    expect(tree.container.textContent).toContain("Reading components.tsx");
+    // oracle-change: the streaming reply is the focus, so its finished step waits for the footer row instead of a live row.
+    expect(tree.container.querySelector(".agentkit-activities")).toBeNull();
     expect(
       tree.container.querySelector("[data-agentkit-current-activity]"),
     ).toBeNull();

package/src/app/agentkit/react/stop-button.spec.tsx

@@ -75,7 +75,7 @@ describe("useAgentKitStopButton", () => {
     );
   });
 
-  it("steps down to secondary only while Send sits beside it", async () => {
+  it("steps down to secondary only while End voice chat sits beside it", async () => {
     mocks.activeRunIds = ["run-1"];
     container = document.createElement("div");
     document.body.appendChild(container);