@opengeni/react 3.3.2 → 3.4.1-canary.38960406141001

package/dist/timeline/index.d.ts

@@ -1,20 +1,25 @@
 export { buildTimeline, creditExhaustedFromEvents, extractSessionRef, groupTimeline, sessionStatusFromEvents, mcpToolLeaf, toolDisplayName, toolMatchesLeaf, } from "./projection.js";
-export type { ActivityItem, AgentMessageItem, AuthNeededItem, ContextCompactionItem, FleetDecisionItem, FleetDecisionScoreItem, GoalItem, HumanInputAnswerSummary, HumanInputItem, MachineInputBatchItem, MachineInputMember, MemoryItem, NoticeItem, ReasoningItem, SandboxItem, StartupPhase, StartupPhaseItem, SessionStatusItem, TimelineGroup, TimelineItem, TimelineAnnotationSourceDescriptor, TurnEndItem, ToolCallItem, UserMessageItem, WorkerCompletionItem, WorkerItem, } from "./types.js";
+export type { GroupTimelineOptions } from "./projection.js";
+export type { ActivityItem, AgentMessageItem, AuthNeededItem, ContextCompactionItem, FleetDecisionItem, FleetDecisionScoreItem, GoalItem, HumanInputAnswerSummary, HumanInputItem, MachineInputBatchItem, MachineInputMember, MemoryItem, MessageSender, KnowledgeItem, NoticeItem, SessionUsageLimitStop, ReasoningItem, SandboxItem, StartupPhase, StartupPhaseItem, SessionStatusItem, TimelineGroup, TimelineItem, TimelineAnnotationSourceDescriptor, TurnEndItem, ToolCallItem, UserMessageItem, WorkerCompletionItem, WorkerItem, } from "./types.js";
 export { createToolRegistry, rawTypeOf } from "./registry.js";
-export type { CreateToolRegistryOptions, RetainedArtifactLoader, RetainedScreenshotLoader, VideoArtifactPlaybackLoader, ToolRegistry, ToolRegistryEntry, ToolRenderer, ToolRendererProps, } from "./registry.js";
+export { createSessionRetainedScreenshotLoader, createWorkspaceRetainedArtifactLoader, createWorkspaceRetainedVideoLoader, } from "./retained-loaders.js";
+export type { RetainedArtifactLoaderClient, RetainedScreenshotLoaderClient, RetainedVideoLoaderClient, } from "./retained-loaders.js";
+export type { CreateToolRegistryOptions, RetainedArtifactLoader, RetainedArtifactLoadOptions, RetainedScreenshotLoader, VideoArtifactPlaybackLoader, ToolRegistry, ToolRegistryEntry, ToolRenderer, ToolRendererProps, } from "./registry.js";
 export { createDefaultToolRegistry, defaultToolRegistry } from "./tool-renderers.js";
 export { ActivityRail } from "./activity-rail.js";
 export type { ActivityRailProps } from "./activity-rail.js";
 export { ActivityDisclosure, BodyNote, MediaEmpty, MediaSkeleton, PayloadBlock, ScreenshotFigure, TermBlock, Thumbnail, } from "./shared.js";
 export type { ActivityDisclosureProps, DisclosureChip } from "./shared.js";
-export { LightboxProvider, useLightbox, useLightboxOptional } from "./screenshot-lightbox.js";
-export type { LightboxControlLabels } from "./screenshot-lightbox.js";
+export { LightboxProvider, useLightbox, useLightboxGalleryItem, useLightboxOptional, } from "./screenshot-lightbox.js";
+export type { LightboxControlLabels, LightboxGalleryEntry, LightboxGalleryImage, } from "./screenshot-lightbox.js";
 export { DisclosureDefaultsProvider, useForcedDefaultOpen } from "./disclosure-context.js";
 export { FoldMemoryProvider, inheritFoldRestingState, useFoldMemory } from "./fold-memory.js";
 export type { FoldRestingState } from "./fold-memory.js";
 export { SeenActivityIdsProvider, useSeenActivityIds } from "./seen-activity-ids.js";
 export { TimelineComputeLabelProvider, useTimelineComputeLabel } from "./compute-label.js";
 export { BUILT_IN_TURN_SUMMARY_FACET_IDS, TurnSummary, useTurnSettleOpen } from "./turn-summary.js";
-export type { BuiltInTurnSummaryFacetId, TurnOutcome, TurnSummaryContext, TurnSummaryFacet, TurnSummaryFacetConfiguration, TurnSummaryFacetResult, TurnSummaryOptions, TurnSummaryProps, } from "./turn-summary.js";
+export type { BuiltInTurnSummaryFacetId, TurnOutcome, TurnSummaryContext, TurnSummaryFacet, TurnSummaryFacetConfiguration, TurnSummaryFacetResult, TurnSummaryOptions, TurnSummaryProps, TurnSummaryStatus, } from "./turn-summary.js";
 export { applyPatchOps, applyPatchOpsFromToolItem, parseFreeformApplyPatch, controlCaret, execTruncated, isApplyPatch, isExecSessionLostBanner, looksBinary, parseExecBannerSessionId, parseToolArgs, sandboxCommandExitCode, stripExecBanner, tailPeek, unwrapMcpOutput, v4aToGitFileDiff, } from "./parsers.js";
 export type { ApplyPatchOperation } from "./parsers.js";
+export { KnowledgeActivityProvider } from "./knowledge-receipt.js";
+export type { KnowledgeActivityActions } from "./knowledge-receipt.js";

package/dist/timeline/knowledge-receipt.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+export type KnowledgeActivityActions = {
+    onInspect?: ((entryId: string) => void) | undefined;
+    onRetryFile?: ((fileId: string) => Promise<boolean | void>) | undefined;
+    retryDisabled?: boolean | undefined;
+};
+export declare function KnowledgeActivityProvider({ children, ...actions }: KnowledgeActivityActions & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A saved/pending result never opens or blocks the human-input surface. */
+export declare function KnowledgeReceiptRow(props: {
+    outcome: "published" | "pending" | "rejected" | "archived" | "failed";
+    entryId?: string | undefined;
+    fileId?: string | undefined;
+    title?: string | undefined;
+    source?: boolean | undefined;
+}): import("react").JSX.Element;

package/dist/timeline/message-sender.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from "react";
+import type { MessageSender, UserMessageItem } from "./types.js";
+/**
+ * Draws who sent a person's message. The host decides: return null for the
+ * viewer's own messages, or when it has no identity to show for a sender.
+ */
+export type RenderMessageSender = (sender: MessageSender, item: UserMessageItem) => ReactNode;
+export declare const MessageSenderContext: import("react").Context<RenderMessageSender | undefined>;
+/** The sender line above a message bubble, when the host draws one. */
+export declare function MessageSenderSlot({ item }: {
+    item: UserMessageItem;
+}): import("react").JSX.Element | null;
+/** A small avatar and a name, for {@link RenderMessageSender}. */
+export declare function MessageSenderLabel({ name, avatarUrl, className, }: {
+    name: string;
+    /** A same-origin or otherwise allowed image; initials are shown without one. */
+    avatarUrl?: string | null | undefined;
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/timeline/notice-presentation.d.ts

@@ -0,0 +1,13 @@
+import type { NoticeItem } from "./types.js";
+/** An approval notice the person has since answered. */
+export declare function noticeIsResolvedApproval(item: Pick<NoticeItem, "text" | "resolvedAt">): boolean;
+/** A resolved approval notice reads as history. */
+export declare function noticeDisplayText(item: Pick<NoticeItem, "text" | "resolvedAt">): string;
+/** Notice pill tone: failures stay red, an open wait keeps the waiting hue. */
+export declare function noticeTone(item: Pick<NoticeItem, "tone" | "resolvedAt">): "failed" | "waiting" | "neutral";
+/**
+ * Plain-text summary of a recorded agent wait, as web's quiet disclosure reads
+ * it: "Waited for 2 agents · 3m 5s" once later input ended the wait, otherwise
+ * "Waiting · since 10:32" (with the date on a later day).
+ */
+export declare function recordedWaitSummaryText(item: Pick<NoticeItem, "occurredAt" | "waitingAgents" | "waitEndedAt">, now?: Date): string;

package/dist/timeline/parsers.d.ts

@@ -98,6 +98,17 @@ export declare function screenshotDataUrl(out: unknown): string | null;
 export declare function retainedScreenshotMetadata(out: unknown): RetainedArtifactMetadata | null;
 /** Parse the closed permanent generated-image receipt from native/function tools. */
 export declare function generatedImageReceipt(out: unknown): GeneratedImageReceipt | null;
+/**
+ * Images a tool result returned that the platform retained, plus the result
+ * without them, so its text renders as usual. Any tool's result content can
+ * carry these receipts in place of its image blocks.
+ */
+export declare function retainedToolResultImages(out: unknown): {
+    images: Extract<RetainedArtifactMetadata, {
+        available: true;
+    }>[];
+    output: unknown;
+};
 export type TimelineMediaPreview = {
     type: "media_preview";
     mediaType: string;

package/dist/timeline/patch-apply-command.d.ts

@@ -0,0 +1,18 @@
+import type { RetainedArtifactReference } from "@opengeni/sdk";
+import type { RetainedArtifactLoader } from "./registry.js";
+export { isPatchFilename } from "./presented-image.js";
+/** One command that downloads this patch and applies it in the current folder. */
+export declare function patchApplyCommand(url: string): string;
+/** "5 minutes" from the signed URL's expiry; the default download URL lifetime otherwise. */
+export declare function applyCommandLifetime(expiresAt: string | undefined, now?: number): string;
+/**
+ * "Copy command to apply these changes": mints the existing short-lived,
+ * authenticated download URL for this published patch (the same authority as
+ * Download) and copies `curl -fsSL '<url>' | git apply`. The URL is minted on
+ * click, so the copied command works for the URL's lifetime only.
+ */
+export declare function PatchApplyCommand({ artifact, filename, load, }: {
+    artifact: RetainedArtifactReference;
+    filename: string;
+    load: RetainedArtifactLoader | undefined;
+}): import("react").JSX.Element;

package/dist/timeline/platform-activity-presentation.d.ts

@@ -0,0 +1,21 @@
+import type { SandboxItem, StartupPhaseItem, WorkerItem } from "./types.js";
+export declare function sandboxRowTitle(item: SandboxItem, displayName: (name: string) => string): string;
+export declare function startupPhaseTitle(phase: StartupPhaseItem["phase"], status: StartupPhaseItem["status"], outcome: StartupPhaseItem["outcome"]): string;
+export declare const STARTUP_WAIT_TITLES: Record<NonNullable<StartupPhaseItem["blockedReason"]>, string>;
+export declare function startupDuration(durationMs: number | null): string | null;
+/**
+ * A title that names an agent: the words around the name stay quiet and the
+ * name carries the emphasis. `name` is null when no title is known, and
+ * `text` is then the generic fallback.
+ */
+export type AgentTitleParts = {
+    before: string;
+    name: string | null;
+    after: string;
+    text: string;
+};
+export declare function namedAgentTitle(name: string | null | undefined, before: string, after: string, fallback: string): AgentTitleParts;
+/** The worker step title for a spawn or message, by status, naming the agent when known. */
+export declare function workerRowTitleParts(item: Pick<WorkerItem, "action" | "status">, name?: string | null): AgentTitleParts;
+/** The generic worker step title for a spawn or message, by status. */
+export declare function workerRowTitle(item: Pick<WorkerItem, "action" | "status">): string;

package/dist/timeline/platform-activity-row.d.ts

@@ -1,14 +1,13 @@
 import type { ReasoningItem, SandboxItem, StartupPhaseItem } from "./types.js";
 type RowJsx = typeof import("react/jsx-runtime").jsx;
 type RowJsxs = typeof import("react/jsx-runtime").jsxs;
-export default function PlatformActivityRow({ item, d: ActivityDisclosure, p: PayloadBlock, t: displayName, b: BotIcon, m: Markdown, r: truncate, j, s, }: {
+export default function PlatformActivityRow({ item, d: ActivityDisclosure, p: PayloadBlock, t: displayName, b: BotIcon, m: Markdown, j, s, }: {
     item: ReasoningItem | SandboxItem | StartupPhaseItem;
     d: typeof import("./shared.js").ActivityDisclosure;
     p: typeof import("./shared.js").PayloadBlock;
     t: (name: string) => string;
     b: typeof import("lucide-react").BotIcon;
     m: typeof import("../components/markdown.js").Markdown;
-    r: typeof import("../lib/format.js").truncate;
     j: RowJsx;
     s: RowJsxs;
 }): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

package/dist/timeline/presented-image.d.ts

@@ -0,0 +1,11 @@
+import type { ActivityItem, TimelineGroup } from "./types.js";
+/** Shared browser preview allowlist; other published files remain downloads. */
+export declare function isRetainedImageContentType(contentType: string): boolean;
+/** A published patch, applied locally with `git apply`. */
+export declare function isPatchFilename(filename: string): boolean;
+/**
+ * Deliberately published images and patches are primary output, not
+ * incidental screenshots or work files.
+ */
+export declare function activityPresentsImage(items: readonly ActivityItem[]): boolean;
+export declare function timelineGroupContainsPresentedImage(group: TimelineGroup): boolean;

package/dist/timeline/projection.d.ts

@@ -1,7 +1,11 @@
 import { type SessionEvent, type SessionStatus } from "@opengeni/sdk";
 import type { TimelineGroup, TimelineItem } from "./types.js";
 export { toolDisplayName, mcpToolLeaf, toolMatchesLeaf } from "./tool-display-name.js";
-export declare function buildTimeline(events: SessionEvent[]): TimelineItem[];
+/** Message identity only: queue placement needs the surrounding turn history. */
+export declare function isTimelineUserQuestion(event: SessionEvent): boolean;
+export declare function buildTimeline(events: SessionEvent[], options?: {
+    partialStart?: boolean;
+}): TimelineItem[];
 /**
  * Codex subscription web search can return private citation handles without
  * the URL annotation table that would make them resolvable. Keep the canonical
@@ -18,7 +22,32 @@ export declare function stripOpaqueCitationTokens(text: string): string;
 export declare function creditExhaustedFromEvents(events: SessionEvent[]): boolean;
 /** The latest session status carried in the event log, if any. */
 export declare function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus | null;
-export declare function groupTimeline(items: TimelineItem[]): TimelineGroup[];
+export type GroupTimelineOptions = {
+    /** Readable assistant prose with an independent work summary for each turn. */
+    readableTurns?: boolean;
+    /** @deprecated Use readableTurns. Cross-turn exchange folding has been removed. */
+    foldExchanges?: boolean;
+};
+export declare function groupTimeline(items: TimelineItem[], options?: GroupTimelineOptions): TimelineGroup[];
+/** Navigation uses the same queue/start/withdrawal rules as transcript ordering. */
+export declare function timelineQuestionPlacement(question: SessionEvent, evidence: SessionEvent[]): {
+    kind: "visible";
+    sequence: number;
+} | {
+    sequence?: never;
+    kind: "withdrawn";
+} | {
+    sequence?: never;
+    kind: "pending";
+};
+/**
+ * Evidence that a queued prompt crossed the execution boundary when an older
+ * or partially recovered ledger is missing its canonical `turn.started`.
+ * Queue/control bookkeeping intentionally does not qualify: moving, editing,
+ * steering, or deleting a waiting row must never make its prompt appear in the
+ * transcript as though inference had begun.
+ */
+export declare function isTurnExecutionEvidence(type: string): boolean;
 /**
  * Find a session id in orchestration tool arguments or output. Handles raw
  * objects, JSON strings, and MCP tool results (`{ content: [{ type: "text",

package/dist/timeline/provider-logo.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+import type { ToolDisplayMetadata } from "@opengeni/sdk";
+export type ResolveProviderLogo = (providerDomain: string) => string | null | undefined;
+export declare const ProviderLogoProvider: import("react").Provider<ResolveProviderLogo | undefined>;
+/** The logo URL for a tool's connector, when the host has one. */
+export declare function useToolConnectorLogo(display: ToolDisplayMetadata | undefined): string | null;
+/**
+ * A connector's logo at icon size, or `fallback` when there is none or it
+ * fails to load, so a row never shows a broken image.
+ */
+export declare function ConnectorLogoIcon({ src, fallback, className, }: {
+    src: string | null;
+    fallback: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/timeline/question-nav-model.d.ts

@@ -0,0 +1,23 @@
+/**
+ * "Back to your message": which prompt the reader is reading the answer to, and
+ * whether that prompt has scrolled out of view. Renderer-neutral geometry so
+ * the web timeline (DOM rects) and native timelines (layout offsets) agree.
+ */
+/** How far above the viewport a prompt must be before the pill appears. */
+export declare const QUESTION_NAV_HIDDEN_PX = 24;
+/** Breathing room above the question when the reader jumps back to it. */
+export declare const QUESTION_NAV_MARGIN_PX = 12;
+export type QuestionNavPrompt = {
+    key: string;
+    top: number;
+    bottom: number;
+};
+/**
+ * The last prompt before the reading position (the viewport's middle) owns the
+ * response in view; it is a target only once it has scrolled fully above the
+ * viewport. Prompts are in document order; coordinates share one axis.
+ */
+export declare function questionNavTarget(prompts: readonly QuestionNavPrompt[], view: {
+    top: number;
+    height: number;
+}): string | null;

package/dist/timeline/registry.d.ts

@@ -7,9 +7,18 @@ export type ToolRendererProps = {
     loadRetainedArtifact?: RetainedArtifactLoader | undefined;
 };
 export type RetainedScreenshotLoader = (artifact: RetainedArtifactReference, signal: AbortSignal) => Promise<Uint8Array | null>;
-export type RetainedArtifactLoader = (artifact: RetainedArtifactReference, signal: AbortSignal) => Promise<Uint8Array | {
+export type RetainedArtifactLoader = (artifact: RetainedArtifactReference, signal: AbortSignal, options?: RetainedArtifactLoadOptions) => Promise<Uint8Array | {
     url: string;
+    expiresAt?: string | undefined;
 } | null>;
+export type RetainedArtifactLoadOptions = {
+    /**
+     * Ask for a short-lived download URL instead of bytes, for example to build a
+     * copyable `curl … | git apply` command. A loader that cannot mint one may
+     * still return bytes; callers must handle that.
+     */
+    prefer?: "url" | undefined;
+};
 /** Mint an expiring source for native browser playback without loading video bytes in JS. */
 export type VideoArtifactPlaybackLoader = (artifactId: string, signal: AbortSignal) => Promise<VideoArtifactPlaybackSource>;
 export type ToolRenderer = ComponentType<ToolRendererProps>;
@@ -22,6 +31,8 @@ export type ToolRegistryEntry = {
     match: "name";
     name: string;
     render: ToolRenderer;
+    /** Disable untrusted `<server>__${name}` leaf matching for identity-sensitive renderers. */
+    matchPrefixedLeaf?: boolean | undefined;
 };
 export type ToolRegistry = {
     /** Resolve the renderer for a call (never null — falls back to generic). */

package/dist/timeline/retained-image.d.ts

@@ -0,0 +1,18 @@
+import type { RetainedArtifactReference } from "@opengeni/sdk";
+import type { ToolRendererProps } from "./registry.js";
+type RetainedImageState = {
+    kind: "loading";
+} | {
+    kind: "ready";
+    url: string;
+} | {
+    kind: "unavailable";
+    label: string;
+} | {
+    kind: "error";
+    message: string;
+};
+export { isRetainedImageContentType } from "./presented-image.js";
+export declare function useRetainedImageObjectUrl(artifact: RetainedArtifactReference, load: ToolRendererProps["loadRetainedArtifact"]): RetainedImageState & {
+    retry: () => void;
+};

package/dist/timeline/retained-loaders.d.ts

@@ -0,0 +1,27 @@
+import type { OpenGeniClient } from "@opengeni/sdk";
+import type { RetainedArtifactLoader, RetainedScreenshotLoader, VideoArtifactPlaybackLoader } from "./registry.js";
+/** SDK methods the workspace retained-artifact loader needs. */
+export type RetainedArtifactLoaderClient = Pick<OpenGeniClient, "createRetainedArtifactDownloadUrl" | "downloadRetainedArtifact">;
+/** SDK method the session retained-screenshot loader needs. */
+export type RetainedScreenshotLoaderClient = Pick<OpenGeniClient, "downloadRetainedScreenshot">;
+/** SDK method the generated-video playback loader needs. */
+export type RetainedVideoLoaderClient = Pick<OpenGeniClient, "createVideoArtifactPlaybackSource">;
+/**
+ * Bind permanent retained-artifact retrieval (generated images, published
+ * files) to one authenticated workspace, for `MessageTimeline`'s
+ * `loadRetainedArtifact`. Images get a short-lived URL; files are assembled
+ * from verified byte ranges unless the caller asks for a URL.
+ */
+export declare function createWorkspaceRetainedArtifactLoader(client: RetainedArtifactLoaderClient, workspaceId: string): RetainedArtifactLoader;
+/**
+ * Bind the authenticated screenshot downloader to one workspace and session,
+ * for `MessageTimeline`'s `loadRetainedScreenshot`. Fetched metadata must match
+ * the timeline receipt before bytes are handed to React; errors deliberately
+ * contain no storage locator or content.
+ */
+export declare function createSessionRetainedScreenshotLoader(client: RetainedScreenshotLoaderClient, workspaceId: string, sessionId: string): RetainedScreenshotLoader;
+/**
+ * Bind expiring generated-video playback sources to one authenticated
+ * workspace, for `MessageTimeline`'s `loadVideoArtifactPlayback`.
+ */
+export declare function createWorkspaceRetainedVideoLoader(client: RetainedVideoLoaderClient, workspaceId: string): VideoArtifactPlaybackLoader;

package/dist/timeline/rolling-activity.d.ts

@@ -0,0 +1,11 @@
+import type { ToolRegistry } from "./registry.js";
+import type { ActivityItem } from "./types.js";
+/** One stable viewport; updates replace its content without moving the conversation. */
+export declare function RollingActivity({ items, toolRegistry, previousItem, showCount, }: {
+    items: ActivityItem[];
+    /** The standalone item visible immediately before this reel mounted. */
+    previousItem?: ActivityItem | undefined;
+    toolRegistry?: ToolRegistry;
+    /** Show "+N earlier"; off when an enclosing status line already counts steps. */
+    showCount?: boolean;
+}): import("react").JSX.Element | null;

package/dist/timeline/screenshot-lightbox.d.ts

@@ -1,11 +1,33 @@
-import { type ReactNode } from "react";
+import { type ReactNode, type RefObject } from "react";
 type LightboxController = {
     open: (src: string, caption?: string, source?: HTMLElement | null, label?: string, downloadFilename?: string, controlLabels?: LightboxControlLabels, releaseSource?: () => void) => void;
 };
 export type LightboxControlLabels = {
     download?: string | undefined;
     close?: string | undefined;
+    previous?: string | undefined;
+    next?: string | undefined;
 };
+/** One image the open lightbox can page to, resolved only when it is shown. */
+export type LightboxGalleryImage = {
+    src: string;
+    caption?: string | undefined;
+    label?: string | undefined;
+    /** Releases a source owned by this load, such as an object URL. */
+    release?: (() => void) | undefined;
+};
+export type LightboxGalleryEntry = {
+    /** Whether this entry currently resolves to an image; defaults to yes. */
+    isImage?: (() => Promise<boolean>) | undefined;
+    load: () => Promise<LightboxGalleryImage | null>;
+};
+/**
+ * Adds the element's image to the lightbox gallery so an open lightbox can page
+ * to it with the arrow controls, in document order. The entry is resolved only
+ * when it is shown, so deferred images that never scrolled into view still page.
+ * A lightbox opened from inside the element starts at this entry.
+ */
+export declare function useLightboxGalleryItem(ref: RefObject<HTMLElement | null>, entry: LightboxGalleryEntry | null): void;
 /** Open the app-level screenshot lightbox. No-op outside a `LightboxProvider`. */
 export declare function useLightbox(): LightboxController;
 /**

package/dist/timeline/session-usage-limit-row.d.ts

@@ -0,0 +1,11 @@
+import type { SessionUsageLimitStop } from "./types.js";
+/**
+ * A compact historical marker: the task's usage limit stopped further model
+ * requests here. One calm line with the amounts at the stop (the overshoot is
+ * kept, without implying only the final request caused it). The current
+ * state and the one recovery action live in the host's composer notice, so
+ * this row repeats neither. Never a credits or purchase remedy.
+ */
+export declare function SessionUsageLimitRow({ stop }: {
+    stop: SessionUsageLimitStop;
+}): import("react").JSX.Element;

package/dist/timeline/shared.d.ts

@@ -14,6 +14,8 @@ export declare function ToolCallTruncationProvider({ value, children, }: {
     children: ReactNode;
 }): import("react").JSX.Element;
 export type ActivityDisclosureProps = {
+    /** Override the rolling preview; null keeps rapidly streaming details out of the header. */
+    compactPreview?: ReactNode;
     icon: ReactNode;
     /** Icon tint. Defaults to the muted foreground; renderers pass accent/failed. */
     iconTone?: "accent" | "failed" | "running" | "muted" | undefined;
@@ -67,7 +69,8 @@ export type ActivityDisclosureProps = {
  * inline media, and at most one right-gutter settle chip. Compact by default;
  * the body mounts only when expanded.
  */
-export declare function ActivityDisclosure({ icon, iconTone: iconToneProp, title, titleMono, running, preview, media, chip: chipProp, failed, cancelled, expandable, defaultOpen, children, }: ActivityDisclosureProps): import("react").JSX.Element;
+export declare const CompactActivityContext: import("react").Context<boolean>;
+export declare function ActivityDisclosure({ icon, iconTone: iconToneProp, title, titleMono, running, preview, compactPreview, media, chip: chipProp, failed, cancelled, expandable, defaultOpen, children, }: ActivityDisclosureProps): import("react").JSX.Element;
 export declare function TermBlock({ command, workdir, output, live, tailLines, failed, }: {
     /**
      * The command shown in the prompt header. Pass `null` when the row title

package/dist/timeline/startup-dispatch-details.d.ts

@@ -0,0 +1,5 @@
+import type { Session } from "@opengeni/sdk";
+/** Live dispatch diagnostics belong to the current loading area, never history. */
+export declare function StartupDispatchDetails({ wait }: {
+    wait: Session["dispatchWait"];
+}): import("react").JSX.Element;

package/dist/timeline/startup-preference.d.ts

@@ -0,0 +1,3 @@
+export declare function setStartupDetails(value: boolean): void;
+/** Presentation preference only. Startup evidence is always retained. */
+export declare function useStartupDetails(): boolean;

package/dist/timeline/startup-timings.d.ts

@@ -0,0 +1,4 @@
+import type { StartupPhaseItem } from "./types.js";
+export declare function StartupTimings({ phases }: {
+    phases: StartupPhaseItem[];
+}): import("react").JSX.Element;

package/dist/timeline/tool-display-name.d.ts

@@ -6,6 +6,7 @@
  * and bare `session_create` resolve the same UI — without inventing previews
  * from argument JSON.
  */
+import type { ToolDisplayMetadata } from "@opengeni/sdk";
 /** Leaf tool name after the first `__` server boundary (or the whole name). */
 export declare function mcpToolLeaf(name: string): string;
 /**
@@ -16,6 +17,8 @@ export declare function mcpToolLeaf(name: string): string;
 export declare function toolMatchesLeaf(wireName: string, leaf: string): boolean;
 /**
  * Readable label for a tool call ("session_create" / "opengeni__session_create"
- * → "Session create"). Title-cases the first character of the leaf phrase.
+ * → "Session create"). Title-cases the first character of the leaf phrase. A
+ * connector account is named only when the connector has several ("List
+ * issues · alice@example.com"); the connector itself shows as its logo.
  */
-export declare function toolDisplayName(name: string): string;
+export declare function toolDisplayName(name: string, display?: ToolDisplayMetadata): string;

package/dist/timeline/tool-presentation.d.ts

@@ -0,0 +1,172 @@
+import type { GitFileDiff } from "@opengeni/sdk";
+import { type ApplyPatchOperation } from "./parsers.js";
+import type { ToolCallItem } from "./types.js";
+export type ToolIconKind = "terminal" | "keyboard" | "file-diff" | "search" | "question" | "target" | "brain" | "sessions" | "server" | "server-cog" | "calendar" | "panels" | "share" | "message" | "git" | "box" | "key" | "file-search" | "package-search" | "plug" | "wrench";
+export type ToolIconTone = "accent" | "failed" | "running" | "muted";
+export type ToolChip = {
+    tone: "ok" | "bad" | "muted" | "interrupted";
+    text: string;
+};
+/** The collapsed-row secondary line. `running` previews carry the pulse locus. */
+export type ToolPreview = {
+    kind: "text";
+    text: string;
+    running?: boolean | undefined;
+} | {
+    kind: "path";
+    path: string;
+    add?: number | undefined;
+    del?: number | undefined;
+} | {
+    kind: "files";
+    count: number;
+    add: number;
+    del: number;
+} | {
+    kind: "malformed";
+    name: string;
+};
+export type ToolPatchFile = {
+    key: string;
+    path: string;
+    file: GitFileDiff | null;
+    diff: string;
+};
+export type WebSearchResult = {
+    title: string;
+    domain: string;
+    snippet: string;
+};
+/** What the expanded body holds; renderers draw these with their own primitives. */
+export type ToolBody = {
+    kind: "term";
+    command: string | null;
+    workdir: string | null;
+    output: string;
+    live?: boolean | undefined;
+    failed?: boolean | undefined;
+    note?: string | undefined;
+} | {
+    kind: "note";
+    text: string;
+    tone?: "error" | undefined;
+} | {
+    kind: "payloads";
+    /** A short explanation above the payloads. */
+    note?: string | undefined;
+    blocks: Array<{
+        label: string;
+        value: unknown;
+        failed?: boolean;
+    }>;
+} | {
+    kind: "patch";
+    files: ToolPatchFile[];
+    /** A single malformed op renders its raw patch without the path caption. */
+    bare?: boolean | undefined;
+} | {
+    kind: "web-results";
+    results: WebSearchResult[] | null;
+} | {
+    /** A short labelled listing (disclosed tools, search hits) above payloads. */
+    kind: "listing";
+    note?: string | undefined;
+    entries: ToolListingEntry[];
+    /** Entries beyond the visible list ("+N more"). */
+    more?: number | undefined;
+    /** Shown instead of the list when it is known to be empty. */
+    empty?: string | undefined;
+    blocks: Array<{
+        label: string;
+        value: unknown;
+        failed?: boolean;
+    }>;
+};
+export type ToolListingEntry = {
+    key: string;
+    title: string;
+    /** Quiet leading label (the tool's server). */
+    eyebrow?: string | null | undefined;
+    mono?: boolean | undefined;
+    /** Secondary text under the title (a search snippet). */
+    snippet?: string | undefined;
+};
+export type PresentedToolKind = "exec" | "write_stdin" | "apply_patch" | "web_search" | "ask" | "run_on" | "tool_search" | "docs_search" | "session_title" | "generic";
+export type ToolRowPresentation = {
+    tool: PresentedToolKind;
+    icon: ToolIconKind;
+    iconTone: ToolIconTone;
+    title: string;
+    titleMono?: boolean | undefined;
+    running?: boolean | undefined;
+    preview?: ToolPreview | undefined;
+    chip?: ToolChip | undefined;
+    failed?: boolean | undefined;
+    cancelled?: boolean | undefined;
+    body: ToolBody;
+};
+export type ToolPresentationContext = {
+    /** Host-supplied active compute label ("on <label> · …" preview prefix). */
+    computeLabel?: string | null | undefined;
+};
+/** Prefix a collapsed preview with the host-supplied active compute label. */
+export declare function withComputePreview(label: string | null | undefined, preview: string): string;
+export declare function truncatePreview(text: string, max: number): string;
+export declare function execPresentation(item: ToolCallItem, context?: ToolPresentationContext): ToolRowPresentation;
+export declare function writeStdinPresentation(item: ToolCallItem): ToolRowPresentation;
+export declare function patchVerb(op: ApplyPatchOperation | undefined): string;
+export declare function pathBasename(path: string): string;
+export declare function pathDirname(path: string): string;
+export declare function safeParsePatchOp(op: ApplyPatchOperation): GitFileDiff | null;
+/** Returns null when a settled patch has no op (renderers fall back to generic). */
+export declare function applyPatchPresentation(item: ToolCallItem): ToolRowPresentation | null;
+export declare function webSearchQueryFromArguments(args: unknown): string | null;
+export declare function webSearchPresentation(item: ToolCallItem): ToolRowPresentation;
+export declare function askToolPreview(args: unknown): string | null;
+export declare function runOnTargetName(output: unknown): string | null;
+export declare function runOnOpPreview(args: Record<string, unknown>): string | null;
+export declare function goalToolPreview(name: string, args: unknown): string | null;
+/** Explicit first-party leaf/prefix → canonical product icon kind. */
+export declare function genericToolIconKind(name: string): ToolIconKind;
+export declare function askPresentation(item: ToolCallItem): ToolRowPresentation;
+export declare function runOnPresentation(item: ToolCallItem): ToolRowPresentation;
+/**
+ * Baseline craft for unmatched tools: family icon + title-cased leaf + honest
+ * status preview (Running… / Done / error snippet).
+ */
+export declare function genericToolPresentation(item: ToolCallItem): ToolRowPresentation;
+export type DisclosedTool = {
+    /** Full wire name (`server__leaf` or bare). */
+    name: string;
+    /** Server / namespace prefix before `__`, when present. */
+    source: string | null;
+    /** Leaf tool name after `__`. */
+    leaf: string;
+};
+export declare function splitToolWireName(name: string): DisclosedTool;
+/** Capability query from live tool_search args (object or JSON string). */
+export declare function toolSearchQuery(item: ToolCallItem): string;
+/**
+ * Parse disclosed tools from the runtime event shape.
+ * `normalizeSdkEvent` collapses `tool_search_output.tools[]` into text:
+ *   "Disclosed tools: a, b" | "No matching tools found."
+ * Also accept a structured `tools` array when a host/enricher preserves it.
+ */
+export declare function parseDisclosedTools(output: unknown): DisclosedTool[] | null;
+export declare function toolSearchPreview(tools: DisclosedTool[] | null, cancelled: boolean): string | undefined;
+export declare function toolSearchPresentation(item: ToolCallItem): ToolRowPresentation;
+export type SearchHit = {
+    title: string;
+    snippet: string;
+};
+export declare function parseSearchHits(outText: string): SearchHit[] | null;
+export declare function docsSearchPresentation(item: ToolCallItem): ToolRowPresentation;
+export declare function sessionTitlePresentation(item: ToolCallItem): ToolRowPresentation;
+/**
+ * Resolve the shared presenter for a call with the web registry's precedence
+ * (raw.type, exact name, MCP leaf). Tools whose web renderer is richer than the
+ * shared model (computer use, media, knowledge receipts, …) resolve to
+ * `generic`; non-DOM renderers may layer their own presenters on top.
+ */
+export declare function presentedToolKind(item: ToolCallItem): PresentedToolKind;
+export declare function toolRowPresentation(item: ToolCallItem, context?: ToolPresentationContext): ToolRowPresentation;