@opengeni/react 0.3.1 → 0.4.0

package/src/timeline/parsers.ts

@@ -0,0 +1,248 @@
+import type { GitFileDiff } from "@opengeni/sdk";
+import { tryParseJson } from "../lib/format";
+
+/* ----------------------------------------------------------------------------
+   Pure parsers for the provider-native tool shapes that the timeline renders.
+
+   These are intentionally browser-safe, dependency-free mirrors of the
+   server-side helpers in `@opengeni/runtime` (`sandboxCommandExitCode`,
+   `parseExecBannerSessionId`, `stripExecBanner`) plus the V4A diff parser the
+   apply-patch renderer needs. The SDK does not depend on `@opengeni/runtime` by
+   design (runtime is a heavy server package); these few regexes are cheap to
+   own here and keep the React surface free of a server dependency.
+
+   Every function is pure -- same input, same output -- so it can be
+   unit-tested and memoized.
+   -------------------------------------------------------------------------- */
+
+/** Recover the exit code from a sandbox exec banner (`Process exited with code N`). */
+export function sandboxCommandExitCode(out: unknown): number | null {
+  const match = String(out ?? "").match(/Process exited with code (-?\d+)/);
+  return match ? Number(match[1]) : null;
+}
+
+/**
+ * Recover the numeric exec-session id the sandbox embeds for a STILL-RUNNING
+ * (backgrounded) process (`Process running with session ID N`). A finished
+ * command emits `Process exited with code N` instead, which yields `null`.
+ */
+export function parseExecBannerSessionId(out: unknown): number | null {
+  const text = String(out ?? "");
+  const outputIdx = text.indexOf("\nOutput:\n");
+  const banner = outputIdx >= 0 ? text.slice(0, outputIdx) : text.startsWith("Output:\n") ? "" : text;
+  const match = banner.match(/Process running with session ID (\d+)/);
+  if (!match) {
+    return null;
+  }
+  const n = Number.parseInt(match[1]!, 10);
+  return Number.isFinite(n) ? n : null;
+}
+
+/** Strip the exec banner (`Chunk ID ...\n...\nOutput:\n`) down to the command's stdout. */
+export function stripExecBanner(out: unknown): string {
+  const text = String(out ?? "");
+  const marker = text.indexOf("\nOutput:\n");
+  if (marker >= 0) {
+    return text.slice(marker + "\nOutput:\n".length);
+  }
+  if (text.startsWith("Output:\n")) {
+    return text.slice("Output:\n".length);
+  }
+  return text;
+}
+
+/** The sandbox clamped the output (token/line truncation markers in the banner). */
+export function execTruncated(out: unknown): boolean {
+  return /Total output lines:|\.{3}\d+ tokens truncated\.{3}|\[\.{3}\d+ characters truncated/.test(String(out ?? ""));
+}
+
+/** A `write_stdin` whose target PTY vanished (`write_stdin failed: session not found: N`). */
+export function isExecSessionLostBanner(out: unknown): boolean {
+  return /write_stdin failed: session not found: \d+/.test(String(out ?? ""));
+}
+
+/** True when the exec stdout looks binary/garbled (a NUL byte or ELF magic). */
+export function looksBinary(text: string): boolean {
+  return text.includes("\u0000") || text.startsWith("\u007fELF");
+}
+
+/**
+ * Render unprintable control characters as caret notation (0x03 -> `^C`) so a
+ * `write_stdin` keystroke payload reads cleanly in the row title.
+ */
+export function controlCaret(printable: string): string {
+  return String(printable).replace(/[\u0000-\u001f]/g, (c) => `^${String.fromCharCode(c.charCodeAt(0) + 64)}`);
+}
+
+/* --- V4A apply_patch diff -> GitFileDiff ------------------------------------ */
+
+/** One operation inside an `apply_patch_call` (a V4A file edit). */
+export type ApplyPatchOperation = {
+  /**
+   * The V4A op kind. The three canonical values are `create_file`,
+   * `update_file`, and `delete_file`; the open `string` tail tolerates a
+   * forward-compatible/unknown op kind from the provider without a type error
+   * (it falls through to the "Edited" treatment).
+   */
+  type: "create_file" | "update_file" | "delete_file" | (string & {});
+  path: string;
+  /** Rename target -- when present the op is a move/rename. */
+  moveTo?: string | null | undefined;
+  /** The V4A hunk string (`@@ ...` lines with `+`/`-`/context prefixes). */
+  diff?: string | undefined;
+};
+
+/**
+ * Parse a single V4A `apply_patch` operation into the SDK's `GitFileDiff` shape
+ * so it can flow into the SAME `DiffView` / `PierreDiff` the Files tab uses.
+ * Throws on a hunk string it cannot structure (no `@@` anchor on an update); the
+ * renderer catches and falls back to a raw-patch view.
+ */
+export function v4aToGitFileDiff(op: ApplyPatchOperation): GitFileDiff {
+  const status: GitFileDiff["status"] =
+    op.type === "create_file" ? "added" : op.type === "delete_file" ? "deleted" : op.moveTo ? "renamed" : "modified";
+  const oldPath = op.moveTo ? op.path : null;
+  const path = op.moveTo || op.path;
+
+  const hunks: GitFileDiff["hunks"] = [];
+  let additions = 0;
+  let deletions = 0;
+  let sawHunkAnchor = false;
+
+  if (op.type !== "delete_file") {
+    const lines = (op.diff ?? "").split("\n");
+    let cur: GitFileDiff["hunks"][number] | null = null;
+    let oldNo = 1;
+    let newNo = 1;
+    for (const raw of lines) {
+      if (raw.startsWith("@@")) {
+        sawHunkAnchor = true;
+        const match = raw.match(/-(\d+)(?:,\d+)?\s+\+(\d+)/);
+        oldNo = match ? Number(match[1]) : 1;
+        newNo = match ? Number(match[2]) : 1;
+        cur = {
+          oldStart: oldNo,
+          oldLines: 0,
+          newStart: newNo,
+          newLines: 0,
+          header: raw,
+          lines: [{ type: "meta", oldNo: null, newNo: null, text: raw }],
+        };
+        hunks.push(cur);
+      } else if (cur || op.type === "create_file") {
+        if (!cur) {
+          cur = { oldStart: 0, oldLines: 0, newStart: 1, newLines: 0, header: "@@ +1 @@", lines: [] };
+          hunks.push(cur);
+          oldNo = 0;
+          newNo = 1;
+        }
+        if (raw.startsWith("+")) {
+          cur.lines.push({ type: "add", oldNo: null, newNo: newNo++, text: raw.slice(1) });
+          cur.newLines += 1;
+          additions += 1;
+        } else if (raw.startsWith("-")) {
+          cur.lines.push({ type: "del", oldNo: oldNo++, newNo: null, text: raw.slice(1) });
+          cur.oldLines += 1;
+          deletions += 1;
+        } else {
+          cur.lines.push({ type: "context", oldNo: oldNo++, newNo: newNo++, text: raw.replace(/^ /, "") });
+          cur.oldLines += 1;
+          cur.newLines += 1;
+        }
+      }
+    }
+    // An update with content but no recognizable hunk anchor is malformed V4A;
+    // the caller falls back to the raw-patch view instead of a structured diff.
+    if (op.type === "update_file" && !sawHunkAnchor && lines.some((l) => l.trim().length > 0)) {
+      throw new Error("malformed V4A: no @@ hunk anchor");
+    }
+  }
+
+  return { path, oldPath, status, isBinary: false, isImage: false, additions, deletions, hunks, truncated: false };
+}
+
+/**
+ * Extract the `apply_patch` operations from a provider-native tool item's `raw`
+ * payload, normalizing the two wire shapes (`raw.operations[]` for a multi-file
+ * patch, `raw.operation` for a single op). The single owner of this shape so the
+ * renderer and the turn-summary facet counter never drift.
+ */
+export function applyPatchOps(raw: unknown): ApplyPatchOperation[] {
+  const r = (raw ?? {}) as { operation?: ApplyPatchOperation; operations?: ApplyPatchOperation[] };
+  if (Array.isArray(r.operations)) {
+    return r.operations;
+  }
+  return r.operation ? [r.operation] : [];
+}
+
+/**
+ * True when a tool item is an `apply_patch_call` — by its provider-native
+ * `raw.type` (the live-wire source of truth) or by tool `name` (first-party
+ * replays that omit `raw`). Centralizes the rawType-or-name check.
+ */
+export function isApplyPatch(item: { name: string; raw: unknown }): boolean {
+  const type = item.raw && typeof item.raw === "object" ? (item.raw as { type?: unknown }).type : undefined;
+  return type === "apply_patch_call" || item.name === "apply_patch_call";
+}
+
+/* --- secret redaction ------------------------------------------------------- */
+
+const SECRET_KEY = /^(value|secret|token|password|api[_-]?key|signing[_-]?key)$/i;
+
+/** Deep-redact secret-looking values so arguments never leak a key into the UI. */
+export function redactSecrets(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(redactSecrets);
+  }
+  if (value && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = SECRET_KEY.test(k) ? "••••" : redactSecrets(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+/** Parse tool arguments that may arrive as a JSON string or an object. */
+export function parseToolArgs(args: unknown): Record<string, unknown> {
+  if (args == null) {
+    return {};
+  }
+  if (typeof args === "string") {
+    const parsed = tryParseJson(args);
+    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {};
+  }
+  return typeof args === "object" ? (args as Record<string, unknown>) : {};
+}
+
+/** The last non-empty line of a string -- the compact "what happened" peek. */
+export function tailPeek(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const lines = trimmed.split("\n");
+  return lines[lines.length - 1] ?? "";
+}
+
+/**
+ * Unwrap an MCP tool result (`{ content: [{ type: "text", text }], isError? }`)
+ * into a flat `{ text, isError }`. Non-MCP outputs pass through as their string
+ * form.
+ */
+export function unwrapMcpOutput(output: unknown): { text: string; isError: boolean } {
+  if (output && typeof output === "object" && "content" in output) {
+    const record = output as { content?: unknown; isError?: unknown };
+    const isError = Boolean(record.isError);
+    if (Array.isArray(record.content)) {
+      const textPart = record.content.find(
+        (part): part is { type: string; text: string } =>
+          !!part && typeof part === "object" && (part as { type?: unknown }).type === "text",
+      );
+      return { text: textPart ? String(textPart.text) : JSON.stringify(output), isError };
+    }
+    return { text: JSON.stringify(output), isError };
+  }
+  return { text: typeof output === "string" ? output : output == null ? "" : JSON.stringify(output), isError: false };
+}

package/src/{timeline.ts → timeline/projection.ts}

@@ -1,5 +1,16 @@
-import type { ResourceRef, SessionEvent, SessionStatus, ToolRef } from "@opengeni/sdk";
-import { stringifyPayload, tryParseJson } from "./lib/format";
+import type { SessionEvent, SessionStatus } from "@opengeni/sdk";
+import { tryParseJson } from "../lib/format";
+import type {
+  AgentMessageItem,
+  ActivityItem,
+  GoalItem,
+  SandboxItem,
+  SessionStatusItem,
+  TimelineGroup,
+  TimelineItem,
+  ToolCallItem,
+  WorkerItem,
+} from "./types";
 
 /* ----------------------------------------------------------------------------
    Timeline projection
@@ -15,112 +26,6 @@ import { stringifyPayload, tryParseJson } from "./lib/format";
    memoized, unit-tested, and re-run incrementally as new events stream in.
    -------------------------------------------------------------------------- */
 
-export type UserMessageItem = {
-  kind: "user-message";
-  id: string;
-  text: string;
-  /** Resources attached to this message (file uploads, repositories). */
-  resources: ResourceRef[];
-  /** Tools requested for the turn this message starts. */
-  tools: ToolRef[];
-  occurredAt: string;
-};
-
-export type AgentMessageItem = {
-  kind: "agent-message";
-  id: string;
-  turnId: string | null;
-  text: string;
-  /** Still receiving deltas (no completed/turn-end seen yet). */
-  streaming: boolean;
-  occurredAt: string;
-};
-
-export type ReasoningItem = {
-  kind: "reasoning";
-  id: string;
-  turnId: string | null;
-  text: string;
-  streaming: boolean;
-  occurredAt: string;
-};
-
-export type ToolCallItem = {
-  kind: "tool-call";
-  id: string;
-  turnId: string | null;
-  callId: string | null;
-  name: string;
-  arguments: unknown;
-  output: unknown;
-  status: "running" | "complete";
-  occurredAt: string;
-};
-
-/**
- * An orchestration call against another session — the manager spawning or
- * messaging a worker. Rendered as a first-class "worker" row, not a generic
- * tool call.
- */
-export type WorkerItem = {
-  kind: "worker";
-  id: string;
-  turnId: string | null;
-  callId: string | null;
-  action: "spawn" | "message";
-  /** The worker's initial message / the message sent to it, when parseable. */
-  prompt: string | null;
-  /** The target/spawned worker session id, when parseable from args/output. */
-  workerSessionId: string | null;
-  status: "running" | "complete";
-  occurredAt: string;
-};
-
-export type SandboxItem = {
-  kind: "sandbox";
-  id: string;
-  turnId: string | null;
-  name: string;
-  command: string | null;
-  output: string;
-  status: "running" | "complete" | "failed";
-  occurredAt: string;
-};
-
-export type SessionStatusItem = {
-  kind: "session-status";
-  id: string;
-  status: SessionStatus;
-  occurredAt: string;
-};
-
-export type GoalItem = {
-  kind: "goal";
-  id: string;
-  action: "set" | "updated" | "completed" | "paused" | "resumed" | "continuation";
-  text: string | null;
-  occurredAt: string;
-};
-
-export type NoticeItem = {
-  kind: "notice";
-  id: string;
-  tone: "waiting" | "cancelled" | "failed";
-  text: string;
-  occurredAt: string;
-};
-
-export type TimelineItem =
-  | UserMessageItem
-  | AgentMessageItem
-  | ReasoningItem
-  | ToolCallItem
-  | WorkerItem
-  | SandboxItem
-  | SessionStatusItem
-  | GoalItem
-  | NoticeItem;
-
 /** Tool names on the first-party OpenGeni MCP server that operate on sessions. */
 const WORKER_SPAWN_TOOL = "session_create";
 const WORKER_MESSAGE_TOOL = "session_send_message";
@@ -139,7 +44,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
     }
   };
 
-  const finalizeOpen = (turnId?: string | null): void => {
+  const finalizeOpen = (turnId?: string | null, disposition: "complete" | "failed" | "cancelled" = "complete"): void => {
     for (const item of items) {
       if (turnId !== undefined && "turnId" in item && item.turnId && turnId && item.turnId !== turnId) {
         continue;
@@ -148,10 +53,10 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         item.streaming = false;
       }
       if ((item.kind === "tool-call" || item.kind === "worker") && item.status === "running") {
-        item.status = "complete";
+        item.status = disposition;
       }
       if (item.kind === "sandbox" && item.status === "running") {
-        item.status = "complete";
+        item.status = disposition;
       }
     }
   };
@@ -276,6 +181,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           name,
           arguments: args,
           output: undefined,
+          // The provider-native item drives the per-tool renderers (apply_patch
+          // operation, computer_call action, web_search providerData, …).
+          raw: payload.raw,
           status: "running",
           occurredAt: event.occurredAt,
         });
@@ -289,11 +197,15 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           break;
         }
         if (target.kind === "worker") {
-          target.status = "complete";
+          // A worker spawn/message that returns an error flag (or an MCP
+          // isError result) settles to "failed" too, so WorkerRow surfaces it.
+          target.status = isErrorOutput(payload) ? "failed" : "complete";
           target.workerSessionId = target.workerSessionId ?? extractSessionRef(payload.output);
           break;
         }
-        target.status = "complete";
+        // An output carrying an explicit error flag (or an MCP isError result)
+        // settles the tool to "failed" so the renderer can surface it loudly.
+        target.status = isErrorOutput(payload) ? "failed" : "complete";
         target.output = payload.output;
         break;
       }
@@ -375,7 +287,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       }
 
       case "turn.failed": {
-        finalizeOpen(turnId);
+        finalizeOpen(turnId, "failed");
         items.push({
           kind: "notice",
           id: event.id,
@@ -387,7 +299,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       }
 
       case "turn.cancelled": {
-        finalizeOpen(turnId);
+        finalizeOpen(turnId, "cancelled");
         items.push({
           kind: "notice",
           id: event.id,
@@ -442,22 +354,32 @@ export function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus |
    sandbox) cluster into one collapsible block between chat messages.
    -------------------------------------------------------------------------- */
 
-export type TimelineGroup =
-  | { kind: "item"; item: TimelineItem }
-  | { kind: "activity"; id: string; items: (ReasoningItem | ToolCallItem | WorkerItem | SandboxItem)[] };
-
-const ACTIVITY_KINDS = new Set(["reasoning", "tool-call", "worker", "sandbox"]);
+/**
+ * Whether an item clusters into an activity block. A `switch` (not a stringly-
+ * typed set) so adding an {@link ActivityItem} kind is a compile-time prompt to
+ * decide its grouping — and it narrows `item` to `ActivityItem` with no cast.
+ */
+function isActivityItem(item: TimelineItem): item is ActivityItem {
+  switch (item.kind) {
+    case "reasoning":
+    case "tool-call":
+    case "worker":
+    case "sandbox":
+      return true;
+    default:
+      return false;
+  }
+}
 
 export function groupTimeline(items: TimelineItem[]): TimelineGroup[] {
   const groups: TimelineGroup[] = [];
   for (const item of items) {
-    if (ACTIVITY_KINDS.has(item.kind)) {
+    if (isActivityItem(item)) {
       const open = groups[groups.length - 1];
-      const activity = item as ReasoningItem | ToolCallItem | WorkerItem | SandboxItem;
       if (open?.kind === "activity") {
-        open.items.push(activity);
+        open.items.push(item);
       } else {
-        groups.push({ kind: "activity", id: `activity-${item.id}`, items: [activity] });
+        groups.push({ kind: "activity", id: `activity-${item.id}`, items: [item] });
       }
       continue;
     }
@@ -475,11 +397,11 @@ function asRecord(value: unknown): Record<string, unknown> {
 const SESSION_STATUSES: readonly SessionStatus[] = ["queued", "running", "idle", "requires_action", "failed", "cancelled"];
 
 /** Keep only entries that match the wire shapes; user payloads are untyped. */
-function resourceRefs(value: unknown): ResourceRef[] {
+function resourceRefs(value: unknown): import("@opengeni/sdk").ResourceRef[] {
   if (!Array.isArray(value)) {
     return [];
   }
-  return value.filter((entry): entry is ResourceRef => {
+  return value.filter((entry): entry is import("@opengeni/sdk").ResourceRef => {
     const record = asRecord(entry);
     if (record.kind === "repository") {
       return typeof record.uri === "string" && typeof record.ref === "string";
@@ -488,11 +410,11 @@ function resourceRefs(value: unknown): ResourceRef[] {
   });
 }
 
-function toolRefs(value: unknown): ToolRef[] {
+function toolRefs(value: unknown): import("@opengeni/sdk").ToolRef[] {
   if (!Array.isArray(value)) {
     return [];
   }
-  return value.filter((entry): entry is ToolRef => {
+  return value.filter((entry): entry is import("@opengeni/sdk").ToolRef => {
     const record = asRecord(entry);
     return record.kind === "mcp" && typeof record.id === "string";
   });
@@ -502,6 +424,15 @@ function isSessionStatus(value: unknown): value is SessionStatus {
   return typeof value === "string" && (SESSION_STATUSES as readonly string[]).includes(value);
 }
 
+/** Does this tool output represent an error (explicit flag or MCP `isError`)? */
+function isErrorOutput(payload: Record<string, unknown>): boolean {
+  if (payload.error === true || payload.failed === true) {
+    return true;
+  }
+  const output = payload.output;
+  return !!output && typeof output === "object" && (output as { isError?: unknown }).isError === true;
+}
+
 function findOpenCall(items: TimelineItem[], callId: string | null): ToolCallItem | WorkerItem | undefined {
   const reversed = [...items].reverse();
   const isCall = (item: TimelineItem): item is ToolCallItem | WorkerItem => item.kind === "tool-call" || item.kind === "worker";
@@ -624,9 +555,3 @@ function looksLikeId(value: string): boolean {
 export function toolDisplayName(name: string): string {
   return name.replace(/[_-]+/g, " ").trim();
 }
-
-/** Compact, single-line preview of tool arguments/outputs for collapsed rows. */
-export function compactPayloadPreview(value: unknown, maxLength = 120): string {
-  const text = stringifyPayload(value).replace(/\s+/g, " ").trim();
-  return text.length > maxLength ? `${text.slice(0, maxLength - 1)}…` : text;
-}

package/src/timeline/registry.ts

@@ -0,0 +1,96 @@
+import type { ComponentType } from "react";
+import type { ToolCallItem } from "./types";
+
+/* ----------------------------------------------------------------------------
+   Tool renderer registry
+
+   The extension point. A `ToolRenderer` is a React component fed one projected
+   `ToolCallItem`; the registry resolves which renderer handles a given call,
+   keyed on the tool `name` and (secondarily) its provider-native `raw.type`.
+
+   Resolution order (most → least specific):
+     1. exact match on `raw.type`        (e.g. "apply_patch_call", "computer_call")
+     2. exact match on the tool `name`   (e.g. "exec_command", "web_search_call")
+     3. the registry's generic fallback
+
+   A consumer extends the defaults without forking by passing overrides to
+   `createToolRegistry` — e.g. a custom renderer for their own MCP tool, or a
+   replacement for a built-in one. The registry is immutable and fully typed.
+   -------------------------------------------------------------------------- */
+
+export type ToolRendererProps = {
+  item: ToolCallItem;
+};
+
+export type ToolRenderer = ComponentType<ToolRendererProps>;
+
+/** A registry entry: which key it matches and the component that renders it. */
+export type ToolRegistryEntry =
+  | { match: "rawType"; type: string; render: ToolRenderer }
+  | { match: "name"; name: string; render: ToolRenderer };
+
+export type ToolRegistry = {
+  /** Resolve the renderer for a call (never null — falls back to generic). */
+  resolve: (item: ToolCallItem) => ToolRenderer;
+  /** The generic fallback renderer. */
+  fallback: ToolRenderer;
+};
+
+export type CreateToolRegistryOptions = {
+  /**
+   * Entries that take precedence over the built-ins. Earlier entries win, so a
+   * consumer can shadow a default renderer for the same key.
+   */
+  entries?: ToolRegistryEntry[] | undefined;
+  /** Replace the generic fallback used for unmatched tools. */
+  fallback?: ToolRenderer | undefined;
+};
+
+/** The `raw.type` of a projected tool call, when the provider item carries one. */
+export function rawTypeOf(item: ToolCallItem): string | null {
+  const raw = item.raw;
+  if (raw && typeof raw === "object" && typeof (raw as { type?: unknown }).type === "string") {
+    return (raw as { type: string }).type;
+  }
+  return null;
+}
+
+/**
+ * Build a tool registry from a set of entries and a fallback. The returned
+ * registry resolves in priority order: `raw.type` entries first, then `name`
+ * entries, then the fallback. Consumer `entries` are consulted before the
+ * built-in `baseEntries`, so they shadow defaults cleanly.
+ */
+export function createToolRegistry(
+  baseEntries: ToolRegistryEntry[],
+  baseFallback: ToolRenderer,
+  options: CreateToolRegistryOptions = {},
+): ToolRegistry {
+  const entries = [...(options.entries ?? []), ...baseEntries];
+  const fallback = options.fallback ?? baseFallback;
+
+  const byRawType = new Map<string, ToolRenderer>();
+  const byName = new Map<string, ToolRenderer>();
+  for (const entry of entries) {
+    if (entry.match === "rawType") {
+      if (!byRawType.has(entry.type)) {
+        byRawType.set(entry.type, entry.render);
+      }
+    } else if (!byName.has(entry.name)) {
+      byName.set(entry.name, entry.render);
+    }
+  }
+
+  const resolve = (item: ToolCallItem): ToolRenderer => {
+    const rawType = rawTypeOf(item);
+    if (rawType) {
+      const byType = byRawType.get(rawType);
+      if (byType) {
+        return byType;
+      }
+    }
+    return byName.get(item.name) ?? fallback;
+  };
+
+  return { resolve, fallback };
+}