@opengeni/react 4.4.1 → 4.5.1-canary.39832248373001

package/src/hooks/internal.ts

@@ -1,4 +1,4 @@
-import { observedSessionSequence, type SessionEvent } from "@opengeni/sdk";
+import { isTransientRequestError, observedSessionSequence, type SessionEvent } from "@opengeni/sdk";
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import type { EmbeddedSessionEventClientLike } from "../client";
 import { normalizeError } from "../lib/error-message";
@@ -55,16 +55,88 @@ export type AsyncListState<T> = {
   refresh: () => Promise<void>;
 };
 
+/**
+ * How a read hook rides out transient failures (a transport error or a
+ * 502/503/504, as during an API rolling deploy). While the failures last less
+ * than `quietWindowMs`, the hook keeps its loading state or its last data and
+ * retries with backoff; after that it surfaces the error but keeps retrying
+ * every `backgroundDelayMs`, and clears the error when a read succeeds.
+ * Definitive errors (401, 403, 404, other statuses) surface immediately.
+ */
+export type TransientReadRetryOptions = {
+  quietWindowMs?: number | undefined;
+  initialDelayMs?: number | undefined;
+  maxDelayMs?: number | undefined;
+  backgroundDelayMs?: number | undefined;
+};
+
+export type TransientReadRetryPolicy = {
+  quietWindowMs: number;
+  initialDelayMs: number;
+  maxDelayMs: number;
+  backgroundDelayMs: number;
+};
+
+export const DEFAULT_TRANSIENT_READ_RETRY: Readonly<TransientReadRetryPolicy> = Object.freeze({
+  quietWindowMs: 20_000,
+  initialDelayMs: 1_000,
+  maxDelayMs: 4_000,
+  backgroundDelayMs: 15_000,
+});
+
+type TransientReadStreak = { since: number; attempts: number; surfaced: boolean };
+
+function jittered(delayMs: number): number {
+  return Math.round(delayMs * (0.8 + Math.random() * 0.4));
+}
+
+/**
+ * The decision for one transient read failure: stay quiet and retry soon, or
+ * surface the error (once per streak) and keep retrying in the background.
+ */
+export function transientReadRetryStep(
+  streak: TransientReadStreak,
+  now: number,
+  policy: TransientReadRetryPolicy,
+): { quiet: boolean; delayMs: number } {
+  streak.attempts += 1;
+  const quiet = now - streak.since < policy.quietWindowMs;
+  const delayMs = quiet
+    ? Math.min(policy.maxDelayMs, policy.initialDelayMs * 2 ** (streak.attempts - 1))
+    : policy.backgroundDelayMs;
+  return { quiet, delayMs: Math.max(0, jittered(delayMs)) };
+}
+
 /**
  * Shared fetch + optional polling loop for the list/read hooks. Stale
  * responses (superseded by a newer load or an unmount) are dropped.
+ * Transient failures are retried quietly (see {@link TransientReadRetryOptions}).
  */
 export function usePolledValue<T>(
   load: (signal?: AbortSignal) => Promise<T>,
-  options: { pollIntervalMs?: number | undefined; enabled?: boolean | undefined } = {},
+  options: {
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+    /** Quiet retry of transient failures; on by default, `false` surfaces them at once. */
+    transientRetry?: TransientReadRetryOptions | false | undefined;
+  } = {},
 ): AsyncListState<T> {
   const enabled = options.enabled ?? true;
   const pollIntervalMs = options.pollIntervalMs;
+  const transientRetryRef = useRef<TransientReadRetryPolicy | null>(null);
+  transientRetryRef.current =
+    options.transientRetry === false
+      ? null
+      : {
+          quietWindowMs:
+            options.transientRetry?.quietWindowMs ?? DEFAULT_TRANSIENT_READ_RETRY.quietWindowMs,
+          initialDelayMs:
+            options.transientRetry?.initialDelayMs ?? DEFAULT_TRANSIENT_READ_RETRY.initialDelayMs,
+          maxDelayMs: options.transientRetry?.maxDelayMs ?? DEFAULT_TRANSIENT_READ_RETRY.maxDelayMs,
+          backgroundDelayMs:
+            options.transientRetry?.backgroundDelayMs ??
+            DEFAULT_TRANSIENT_READ_RETRY.backgroundDelayMs,
+        };
   const pageLive = usePageLiveActivity();
   const [data, setData] = useState<T | null>(null);
   const [loading, setLoading] = useState(enabled);
@@ -77,6 +149,17 @@ export function usePolledValue<T>(
   const requestAbortRef = useRef<AbortController | null>(null);
   const inFlightRef = useRef<{ load: typeof load; promise: Promise<void> } | null>(null);
   const trailingRefreshRef = useRef<{ load: typeof load; promise: Promise<void> } | null>(null);
+  // The current run of consecutive transient failures, and its pending retry.
+  const transientStreakRef = useRef<TransientReadStreak | null>(null);
+  const transientRetryTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Retries run only while the query is enabled and the page is live.
+  const retryLiveRef = useRef(false);
+  const cancelTransientRetry = useCallback(() => {
+    if (transientRetryTimerRef.current !== null) {
+      clearTimeout(transientRetryTimerRef.current);
+      transientRetryTimerRef.current = null;
+    }
+  }, []);
   const [stateIdentity, setStateIdentity] = useState<{ load: typeof load }>(() => ({ load }));
 
   // A new loader identity means a new query (different session/workspace/...):
@@ -107,6 +190,8 @@ export function usePolledValue<T>(
           activeLoadRef.current === load &&
           !requestAbort.signal.aborted
         ) {
+          transientStreakRef.current = null;
+          cancelTransientRetry();
           setData(result);
           setError(null);
           setLoading(false);
@@ -117,8 +202,36 @@ export function usePolledValue<T>(
           activeLoadRef.current === load &&
           !requestAbort.signal.aborted
         ) {
-          setError(normalizeError(cause));
-          setLoading(false);
+          const policy = transientRetryRef.current;
+          if (policy && retryLiveRef.current && isTransientRequestError(cause)) {
+            // Keep the loading state or the last data on screen while a
+            // deploy or network blip passes; retry, and surface the error
+            // only once it outlasts the quiet window.
+            const now = Date.now();
+            const streak = (transientStreakRef.current ??= {
+              since: now,
+              attempts: 0,
+              surfaced: false,
+            });
+            const step = transientReadRetryStep(streak, now, policy);
+            if (!step.quiet) {
+              // One stable error per streak: background retries that fail
+              // the same way must not re-announce it.
+              if (!streak.surfaced) setError(normalizeError(cause));
+              streak.surfaced = true;
+              setLoading(false);
+            }
+            cancelTransientRetry();
+            transientRetryTimerRef.current = setTimeout(() => {
+              transientRetryTimerRef.current = null;
+              if (retryLiveRef.current) void run();
+            }, step.delayMs);
+          } else {
+            transientStreakRef.current = null;
+            cancelTransientRetry();
+            setError(normalizeError(cause));
+            setLoading(false);
+          }
         }
       } finally {
         if (requestAbortRef.current === requestAbort) requestAbortRef.current = null;
@@ -127,7 +240,7 @@ export function usePolledValue<T>(
     })();
     inFlightRef.current = { load, promise };
     return promise;
-  }, [load]);
+  }, [cancelTransientRetry, load]);
 
   const refresh = useCallback((): Promise<void> => {
     const existing = inFlightRef.current;
@@ -146,7 +259,12 @@ export function usePolledValue<T>(
   }, [load, run]);
 
   useEffect(() => {
+    // Every (re)start begins a fresh streak; a pending retry belongs to the
+    // previous query or visibility period.
+    transientStreakRef.current = null;
+    cancelTransientRetry();
     if (!enabled || !pageLive) {
+      retryLiveRef.current = false;
       setLoading(false);
       generation.current += 1;
       requestAbortRef.current?.abort();
@@ -154,6 +272,7 @@ export function usePolledValue<T>(
       trailingRefreshRef.current = null;
       return;
     }
+    retryLiveRef.current = true;
     setLoading(true);
     let cancelled = false;
     let timer: ReturnType<typeof setTimeout> | null = null;
@@ -168,6 +287,8 @@ export function usePolledValue<T>(
     if (pollIntervalMs === undefined || pollIntervalMs <= 0) {
       return () => {
         cancelled = true;
+        retryLiveRef.current = false;
+        cancelTransientRetry();
         generation.current += 1;
         requestAbortRef.current?.abort();
         inFlightRef.current = null;
@@ -177,12 +298,14 @@ export function usePolledValue<T>(
     return () => {
       cancelled = true;
       if (timer !== null) clearTimeout(timer);
+      retryLiveRef.current = false;
+      cancelTransientRetry();
       generation.current += 1;
       requestAbortRef.current?.abort();
       inFlightRef.current = null;
       trailingRefreshRef.current = null;
     };
-  }, [run, enabled, pageLive, pollIntervalMs]);
+  }, [run, enabled, pageLive, pollIntervalMs, cancelTransientRetry]);
 
   const identityMatches = stateIdentity.load === load;
   return {

package/src/hooks/use-client-config-flags.ts

@@ -14,6 +14,7 @@ export type ClientConfigFlagsSource = {
     archive?: boolean | undefined;
     voiceInput?: ClientVoiceInputConfig | undefined;
     realtimeVoice?: boolean | undefined;
+    browserExtension?: { name: string; installUrl: string } | undefined;
   }>;
 };
 
@@ -46,6 +47,11 @@ export type ClientConfigFlags = {
    * then or when their `realtimeVoice` prop is `true`.
    */
   realtimeVoiceOffered: boolean;
+  /**
+   * The Chrome extension the deployment offers for people's own Chrome, or
+   * null until the config loads or when the server doesn't say (Opengeni Browser).
+   */
+  browserExtension: { name: string; installUrl: string } | null;
 };
 
 const INITIAL_FLAGS: ClientConfigFlags = {
@@ -60,6 +66,7 @@ const INITIAL_FLAGS: ClientConfigFlags = {
   voiceInput: null,
   realtimeVoice: false,
   realtimeVoiceOffered: false,
+  browserExtension: null,
 };
 
 /** Deployment and session-proxy capabilities from the client config. */
@@ -89,6 +96,7 @@ export function useClientConfigFlags(
             voiceInput: config.voiceInput?.available === true ? config.voiceInput : null,
             realtimeVoice: config.realtimeVoice !== false,
             realtimeVoiceOffered: config.realtimeVoice === true,
+            browserExtension: config.browserExtension ?? null,
           });
         }
       },

package/src/hooks/use-session-events.ts

@@ -2,6 +2,7 @@ import {
   isPresentedSessionToolName,
   isRetryableStreamError,
   isSessionModelResponsePhase,
+  isTransientRequestError,
   SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES,
   SESSION_EVENT_CONTENT_STEP_TYPES,
   SESSION_EVENT_CONVERSATION_FILTER_VERSION,
@@ -22,7 +23,11 @@ import type { TimelineItem, TurnStepsItem } from "../timeline/types";
 import type { EmbeddedSessionClientLike } from "../client";
 import { normalizeError } from "../lib/error-message";
 import { joinSessionDetailRead, sessionDetailReadMark } from "../lib/session-detail-read";
-import { usePageLiveActivity } from "./internal";
+import {
+  DEFAULT_TRANSIENT_READ_RETRY,
+  transientReadRetryStep,
+  usePageLiveActivity,
+} from "./internal";
 import { subscribePageWake } from "./page-wake";
 import { deniesRetainedView, useRetainedSessionView } from "./session-view-cache";
 import { markTurnlessOutputGap } from "./turnless-output-gaps";
@@ -311,6 +316,13 @@ export function useSessionEvents(
   const [presentedPass, setPresentedPass] = useState(0);
   // A return to the live tip from history: catch up without replaying steps.
   const rejoinPendingRef = useRef(false);
+  // Consecutive transient failures to open this stream (a deploy or network
+  // blip): they restart it quietly before an error is shown.
+  const streamTransientStreakRef = useRef<{
+    since: number;
+    attempts: number;
+    surfaced: boolean;
+  } | null>(null);
 
   const commitStepStores = useCallback((next: TurnStepStores) => {
     stepStoresRef.current = next;
@@ -659,6 +671,7 @@ export function useSessionEvents(
       initialWindowLoadedRef.current = false;
       reconcileAfterPageResumeRef.current = false;
       rejoinPendingRef.current = false;
+      streamTransientStreakRef.current = null;
       stepGenerationRef.current += 1;
       stepStoresRef.current = EMPTY_STEP_STORES;
       setStepStores(EMPTY_STEP_STORES);
@@ -678,6 +691,9 @@ export function useSessionEvents(
     const generation = generationRef.current + 1;
     generationRef.current = generation;
     if (!sessionId || !streamEnabled) {
+      // A suspended stream starts a fresh transient streak when it resumes: a
+      // failure right after a wake must not count the hidden time.
+      streamTransientStreakRef.current = null;
       // A page that stayed hidden beyond the live-activity grace deliberately
       // closed its SSE connection. Replaying from the old cursor on return can
       // drip a large background backlog through React in many fast batches and
@@ -717,6 +733,15 @@ export function useSessionEvents(
       navigationIdentityRef.current.streamKey === streamKey &&
       navigationIdentityRef.current.enabled === enabled;
     streamAbortRef.current = controller;
+    // A quiet restart or reconciliation retry scheduled by this effect instance.
+    let transientRetryTimer: ReturnType<typeof setTimeout> | null = null;
+    const scheduleTransientRetry = (delayMs: number, retry: () => void) => {
+      if (transientRetryTimer !== null) clearTimeout(transientRetryTimer);
+      transientRetryTimer = setTimeout(() => {
+        transientRetryTimer = null;
+        if (isCurrent()) retry();
+      }, delayMs);
+    };
     // Batch yielded events into one React update per flush window so a long
     // replay (thousands of events) does not render per event. Project every
     // event before retaining it here and synchronously flush at independent
@@ -962,6 +987,7 @@ export function useSessionEvents(
       skippedStepsThroughRef.current =
         retained.events.length === 0 && window.newestSequence > 0 ? window.newestSequence : null;
       initialWindowLoadedRef.current = true;
+      streamTransientStreakRef.current = null;
       setInitialHistoryReady(true);
       setError(null);
       if (status !== undefined) {
@@ -984,6 +1010,31 @@ export function useSessionEvents(
       liveThroughRef.current = Math.max(liveThroughRef.current, streamResumeSequenceRef.current);
     };
 
+    // Reconciliation after an open re-reads the API contract and projections.
+    // A transient failure (a reconnect during an API rollout often lands on a
+    // pod that is still starting) retries quietly; the error is shown only
+    // when it is definitive or outlasts the quiet window.
+    const reconcileAfterOpen = (
+      initialOpen: boolean,
+      streak: { since: number; attempts: number; surfaced: boolean } | null = null,
+    ) => {
+      void Promise.resolve()
+        .then(() => reconcileSession(sessionId, { initialOpen }))
+        .catch((cause) => {
+          if (!isCurrent()) return;
+          if (isTransientRequestError(cause)) {
+            const now = Date.now();
+            const current = streak ?? { since: now, attempts: 0, surfaced: false };
+            const step = transientReadRetryStep(current, now, DEFAULT_TRANSIENT_READ_RETRY);
+            if (step.quiet) {
+              scheduleTransientRetry(step.delayMs, () => reconcileAfterOpen(initialOpen, current));
+              return;
+            }
+          }
+          setError(normalizeError(cause));
+        });
+    };
+
     // One bounded rejoin attempt: it is abandoned once no read completes for
     // REJOIN_STALL_TIMEOUT_MS, and a late result is fenced out of the view
     // (reads without a signal can only be outwaited). A `strict` attempt
@@ -1179,16 +1230,13 @@ export function useSessionEvents(
             const initialOpen = openedStreamKeyRef.current !== streamKey;
             openedStreamKeyRef.current = streamKey;
             strictFailures = 0;
+            // The outage is over: drop an error a long transient streak surfaced.
+            if (streamTransientStreakRef.current?.surfaced) setError(null);
+            streamTransientStreakRef.current = null;
             // Reconciliation repairs projections, but it must not block reading
             // the already-open SSE body. Otherwise live events accumulate in the
             // browser and appear as one delayed burst after every reconciler ends.
-            void Promise.resolve()
-              .then(() => reconcileSession(sessionId, { initialOpen }))
-              .catch((cause) => {
-                if (isCurrent()) {
-                  setError(normalizeError(cause));
-                }
-              });
+            reconcileAfterOpen(initialOpen);
           },
           onStateChange: (state) => {
             if (isCurrent()) {
@@ -1227,7 +1275,32 @@ export function useSessionEvents(
       } catch (cause) {
         if (isCurrent()) {
           flush();
-          setError(normalizeError(cause));
+          let announce = true;
+          if (isTransientRequestError(cause)) {
+            // The tail read or the stream failed transiently (an API rollout
+            // or a network blip). Restart quietly, keeping the loading state
+            // or the current view, and show the error only if it outlasts the
+            // quiet window. Afterwards keep retrying in the background.
+            const now = Date.now();
+            const streak = (streamTransientStreakRef.current ??= {
+              since: now,
+              attempts: 0,
+              surfaced: false,
+            });
+            const step = transientReadRetryStep(streak, now, DEFAULT_TRANSIENT_READ_RETRY);
+            scheduleTransientRetry(step.delayMs, () => setStreamEpoch((epoch) => epoch + 1));
+            if (step.quiet) {
+              setConnectionState("connecting");
+              return;
+            }
+            // One stable error per streak: background retries that fail the
+            // same way must not re-announce it.
+            announce = !streak.surfaced;
+            streak.surfaced = true;
+          } else {
+            streamTransientStreakRef.current = null;
+          }
+          if (announce) setError(normalizeError(cause));
           setConnectionState("error");
           // A failed first compact-tail request has no later success path in
           // this effect instance. End the loading gate so hosts can render the
@@ -1239,6 +1312,7 @@ export function useSessionEvents(
 
     return () => {
       controller.abort();
+      if (transientRetryTimer !== null) clearTimeout(transientRetryTimer);
       if (generationRef.current === generation) {
         generationRef.current = generation + 1;
       }

package/src/hooks/use-workspace-sessions.ts

@@ -1,4 +1,9 @@
-import type { Session, SessionListEntry, SessionListTotals } from "@opengeni/sdk";
+import type {
+  Session,
+  SessionListEntry,
+  SessionListTotals,
+  SiteConversationGroup,
+} from "@opengeni/sdk";
 import { useCallback, useEffect, useRef } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { usePolledValue } from "./internal";
@@ -23,6 +28,11 @@ export type UseWorkspaceSessionsOptions = ClientOverride & {
   archivedOnly?: boolean | undefined;
   sortBy?: "updatedAt" | "createdAt" | "name" | undefined;
   archiveStatus?: "active" | "archived" | "all" | undefined;
+  /**
+   * Conversations that run inside a Site: `include` lists them as rows,
+   * `group` (root pages) returns them as `siteGroups` instead.
+   */
+  siteConversations?: "include" | "group" | undefined;
   /** Refresh interval (ms) for fleet/manager views. Off by default. */
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -41,6 +51,10 @@ export type UseWorkspaceSessionsResult<T extends Session | SessionListEntry = Se
   /** True when the server omitted older pins from its bounded pinned section. */
   pinnedTruncated: boolean;
   totals: SessionListTotals | null;
+  /** Complete Site rows for a `group` page; null when not requested or unsupported. */
+  siteGroups: SiteConversationGroup[] | null;
+  /** True when the server omitted Site rows beyond its bound. */
+  siteGroupsTruncated: boolean;
   nextCursor: string | null;
   loading: boolean;
   error: Error | null;
@@ -79,6 +93,7 @@ export function useWorkspaceSessions(
   const archivedOnly = options.archivedOnly;
   const sortBy = options.sortBy;
   const archiveStatus = options.archiveStatus;
+  const siteConversations = options.siteConversations;
   const enabled = options.enabled ?? true;
   const nextReadRevision = useRef(0);
   const nextReadGeneration = useRef(0);
@@ -99,6 +114,7 @@ export function useWorkspaceSessions(
     archivedOnly ? "archived" : "active",
     sortBy ?? "",
     archiveStatus ?? "",
+    siteConversations ?? "",
   ].join("\u0000");
   const previousQueryKey = useRef(queryKey);
   const queryKeyTransition = previousQueryKey.current !== queryKey;
@@ -122,6 +138,7 @@ export function useWorkspaceSessions(
         ...(archivedOnly ? { archivedOnly: true } : {}),
         ...(sortBy ? { sortBy } : {}),
         ...(archiveStatus ? { archiveStatus } : {}),
+        ...(siteConversations ? { siteConversations } : {}),
         signal,
       };
       const page =
@@ -162,6 +179,7 @@ export function useWorkspaceSessions(
       archivedOnly,
       sortBy,
       archiveStatus,
+      siteConversations,
       queryKey,
     ],
   );
@@ -183,6 +201,8 @@ export function useWorkspaceSessions(
     pinned,
     pinnedTruncated: page?.pinnedTruncated ?? false,
     totals: page?.totals ?? null,
+    siteGroups: page?.siteGroups ?? null,
+    siteGroupsTruncated: page?.siteGroupsTruncated === true,
     nextCursor: page?.nextCursor ?? null,
     // `usePolledValue` clears the old data and starts the new request in an
     // effect. During that query-key transition render, its old loading flag

package/src/messages/en.ts

@@ -383,7 +383,7 @@ export const englishMessages = {
   "browserViewer.inputResultUnknown": "Input result unknown",
   "browserViewer.inspectThePageBeforeContinuing": "Inspect the page before continuing.",
   "browserViewer.installTheOpengeniBrowserExtension":
-    "Install the Opengeni Browser extension in the profile you want to use.",
+    "Install the {extensionName} extension in the profile you want to use.",
   "browserViewer.interactiveBrowserPage": "Interactive browser page",
   "browserViewer.itsPrivateStateIsSaved":
     "Its private state is saved. Opening it creates a fresh, isolated browser process.",
@@ -3992,8 +3992,8 @@ export const englishMessages = {
   "timeline.toolStep.shareFile.running": "Sharing a file",
   "timeline.toolStep.signIn.done": "Signed in",
   "timeline.toolStep.signIn.running": "Signing in",
-  "timeline.toolStep.startHelper.done": "Got help from another assistant",
-  "timeline.toolStep.startHelper.running": "Getting help from another assistant",
+  "timeline.toolStep.startHelper.done": "Started a worker",
+  "timeline.toolStep.startHelper.running": "Starting a worker",
   "timeline.toolStep.switchComputer.done": "Switched computers",
   "timeline.toolStep.switchComputer.running": "Switching computers",
   "timeline.toolStep.syncPosts.done": "Synced posts",

package/src/session-list-model.ts

@@ -16,6 +16,10 @@ import { findPickerRow, type PickerModelRow } from "./model-policy";
 import { sessionDisplayStatus, type SessionDisplayStatus } from "./session-status-model";
 import { type OpenGeniText } from "./messages/runtime";
 
+// Title ranking shared with the web command menu, so chat search on every
+// surface orders matches the same way.
+export { foldForSearch, LOOSE_MATCH_BELOW, rankLabel } from "./app/lib/actions/rank";
+
 /** A list row may be a compact page entry or a complete session response. */
 export type SessionListRow = Session | SessionListEntry;
 

package/src/timeline/activity-rail.tsx

@@ -12,7 +12,6 @@ import {
   BrainCircuitIcon,
   MessageSquareTextIcon,
   SendIcon,
-  WrenchIcon,
 } from "lucide-react";
 import {
   Component,
@@ -43,6 +42,8 @@ import {
 } from "./shared";
 import { invokedToolCall } from "./invoked-tool";
 import { toolDisplayName } from "./tool-display-name";
+import { ToolKindIcon } from "./tool-icon";
+import { genericToolIconKind } from "./tool-presentation";
 import type { ActivityItem, AgentMessageItem, MemoryItem, ToolCallItem, WorkerItem } from "./types";
 import { useOpenGeniText, type OpenGeniText } from "../messages/runtime";
 
@@ -405,7 +406,7 @@ function ToolOutputExactRow({
   return (
     <div data-og-tool-output-loading="" aria-busy="true">
       <ActivityDisclosure
-        icon={<WrenchIcon className="size-3.5" />}
+        icon={<ToolKindIcon kind={genericToolIconKind(item.name)} className="size-3.5" />}
         title={toolDisplayName(msg, item.name, item.display)}
         preview={msg("timeline.toolRenderers.loadingOutput")}
         expandable={false}

package/src/timeline/invoked-tool.ts

@@ -2,14 +2,24 @@ import { parseToolArgs } from "./parsers";
 import { mcpToolLeaf } from "./tool-display-name";
 import type { ToolCallItem } from "./types";
 
+/** The tool a `tool_invoke` call ran, or null for any other call. */
+export function invokedTool(
+  name: string,
+  rawArguments: unknown,
+): { name: string; arguments: unknown } | null {
+  if (mcpToolLeaf(name) !== "tool_invoke") return null;
+  const args = parseToolArgs(rawArguments);
+  if (typeof args.name !== "string" || !args.name.trim()) return null;
+  return { name: args.name, arguments: args.arguments ?? {} };
+}
+
 /**
  * A `tool_invoke` call shown as the tool it ran, so the row reads "Run on …"
  * instead of "Tool invoke". Any other call comes back unchanged.
  */
 export function invokedToolCall(item: ToolCallItem): ToolCallItem {
-  if (mcpToolLeaf(item.name) !== "tool_invoke") return item;
-  const args = parseToolArgs(item.arguments);
-  if (typeof args.name !== "string" || !args.name.trim()) return item;
+  const invoked = invokedTool(item.name, item.arguments);
+  if (!invoked) return item;
   const { display: _display, ...rest } = item;
-  return { ...rest, name: args.name, arguments: args.arguments ?? {} };
+  return { ...rest, ...invoked };
 }

package/src/timeline/projection.ts

@@ -33,6 +33,7 @@ import {
   tryParseJson,
 } from "../lib/format";
 import { mcpToolLeaf, toolMatchesLeaf } from "./tool-display-name";
+import { invokedTool } from "./invoked-tool";
 import { presentTurnFailureText } from "./compaction-copy";
 import { toolOutputPreviewFact, type ToolOutputReader } from "../hooks/tool-output-reads";
 import type {
@@ -894,21 +895,25 @@ export function buildTimeline(
           // decision behind a duplicate generic "Ask" step.
           break;
         }
+        // A worker started or messaged through tool_invoke is the same worker.
+        const invoked = invokedTool(name, args);
+        const workerName = invoked?.name ?? name;
+        const workerArgs = invoked ? invoked.arguments : args;
         if (
-          toolMatchesLeaf(name, WORKER_SPAWN_TOOL) ||
-          toolMatchesLeaf(name, WORKER_MESSAGE_TOOL)
+          toolMatchesLeaf(workerName, WORKER_SPAWN_TOOL) ||
+          toolMatchesLeaf(workerName, WORKER_MESSAGE_TOOL)
         ) {
-          const spawn = toolMatchesLeaf(name, WORKER_SPAWN_TOOL);
-          const title = spawn ? workerTitle(args) : null;
+          const spawn = toolMatchesLeaf(workerName, WORKER_SPAWN_TOOL);
+          const title = spawn ? workerTitle(workerArgs) : null;
           const item: WorkerItem = {
             kind: "worker",
             id: event.id,
             turnId,
             callId,
             action: spawn ? "spawn" : "message",
-            prompt: workerPrompt(args),
+            prompt: workerPrompt(workerArgs),
             ...(title ? { title } : {}),
-            workerSessionId: extractSessionRef(args),
+            workerSessionId: extractSessionRef(workerArgs),
             failure: null,
             status: "running",
             occurredAt: event.occurredAt,

package/src/timeline/rolling-activity.tsx

@@ -1,11 +1,12 @@
 import { renderActivity } from "./activity-rail";
 import { AnimatePresence, motion, useReducedMotion } from "motion/react";
-import { WrenchIcon } from "lucide-react";
 import { Suspense, useEffect, useState } from "react";
 import { CompactActivityContext } from "./shared";
 import { defaultToolRegistry } from "./tool-renderers";
 import type { ToolRegistry } from "./registry";
 import { toolDisplayName } from "./tool-display-name";
+import { ToolKindIcon } from "./tool-icon";
+import { genericToolIconKind } from "./tool-presentation";
 import { toolStepPhase } from "./tool-steps";
 import type { ActivityItem } from "./types";
 import { rollingActivityItem } from "./work-presentation";
@@ -36,7 +37,10 @@ export function RollingActivity({
   const { item, earlierCount } = selected;
   const fallback = (
     <span className="og-rolling-label">
-      <WrenchIcon className="size-3.5" />
+      <ToolKindIcon
+        kind={item.kind === "tool-call" ? genericToolIconKind(item.name) : "wrench"}
+        className="size-3.5"
+      />
       <span>
         {item.kind === "tool-call"
           ? toolDisplayName(t, item.name, item.display, toolStepPhase(item.status))

package/src/timeline/tool-display-name.ts

@@ -28,8 +28,8 @@ export function toolMatchesLeaf(wireName: string, leaf: string): boolean {
 
 /**
  * Readable label for a tool call. Opengeni's own tools read as plain steps in
- * the given phase ("opengeni__session_create" → "Getting help from another
- * assistant" while running, "Got help from another assistant" once done; see
+ * the given phase ("opengeni__session_create" → "Starting a worker" while
+ * running, "Started a worker" once done; see
  * `tool-steps`). Any other tool title-cases its leaf ("list_issues" → "List
  * issues"). A connector account is named only when the connector has several
  * ("List issues · alice@example.com"); the connector itself shows as its logo.