= {
+ running: '›',
+ success: '✓',
+ error: '✗',
+ interrupted: '?',
+};
+
+/** Spoken equivalent of the glyph. The glyph itself is decorative, and a
+ * fast call renders no duration, so without this a completed row would
+ * announce no outcome at all. */
+const STATUS_LABEL_KEYS: Record
= {
+ running: 'com_ui_ptc_trace_running',
+ success: 'com_ui_ptc_trace_done',
+ error: 'com_ui_ptc_trace_failed',
+ interrupted: 'com_ui_ptc_trace_interrupted',
+};
+
+/**
+ * One line of the trace. Reads as a shell transcript — status glyph, the tool
+ * being called, its arguments, and how long it took — with the failure message
+ * printed underneath the call that produced it, the way a CLI reports errors.
+ */
+function PtcTraceLine({ entry }: { entry: PtcTraceEntry }) {
+ const localize = useLocalize();
+ const { i18n } = useTranslation();
+ const mcpServerNames = useMCPServerNames();
+ const parsed = parseToolName(entry.name, mcpServerNames);
+ const running = entry.status === 'running';
+ const failed = entry.status === 'error';
+ const duration = isReportableRunStepDuration(entry.durationMs)
+ ? getRunStepDurationLabels(entry.durationMs as number, i18n.language)
+ : undefined;
+
+ return (
+
+
+
+ {STATUS_GLYPH[entry.status]}
+
+ {localize(STATUS_LABEL_KEYS[entry.status])}
+
+ {parsed.mcpServer && (
+ <>
+ {parsed.mcpServer}
+ ·
+
+ )}
+ {parsed.friendlyKey ? localize(parsed.friendlyKey) : parsed.toolName}
+
+ {entry.args ?? ''}
+ {duration ? (
+ <>
+
+ {localize(duration.key, duration.values)}
+
+
+ {localize(duration.announcedKey, duration.announcedValues)}
+
+
+ ) : (
+ /* The sr-only status above already speaks this cell's meaning. */
+
+ {running ? localize('com_ui_ptc_trace_running') : ''}
+
+ )}
+
+ {failed && (
+
+
+
+ {entry.error ?? localize('com_ui_ptc_trace_failed')}
+
+
+ )}
+
+ );
+}
+
+/**
+ * Live trace of the tool calls a programmatic tool-calling program makes from
+ * inside the sandbox, rendered under the code that is making them. Those inner
+ * calls open no run step and get no card of their own, so without this the
+ * card shows one running spinner for the whole program.
+ *
+ * Renders nothing when the tool call made no inner calls, which is every
+ * non-PTC code execution — callers don't need to know which kind they hold.
+ */
+export default function PtcToolTrace({
+ toolCallId,
+ expanded = false,
+ className,
+}: {
+ toolCallId?: string;
+ /** The host card's disclosure state — a collapsed pane must not be scrolled
+ * invisibly, or it opens at the tail instead of the first call. */
+ expanded?: boolean;
+ className?: string;
+}) {
+ const localize = useLocalize();
+ /** Scope to this card's own message: providers reuse `tool_call_id` across
+ * turns, so the raw id alone would show a later program's calls here. */
+ const { messageId } = useMessageContext();
+ const trace = useRecoilValue(
+ ptcTraceByToolCallId(toolCallId && messageId ? ptcTraceKey(messageId, toolCallId) : ''),
+ );
+
+ /** One character per row, so the pin re-fires both when a call is appended
+ * and when one settles — a settle can add an error line and change height. */
+ const followKey = `${trace.dropped}:${trace.entries.map((entry) => entry.status[0]).join('')}`;
+ const running = trace.entries.some((entry) => entry.status === 'running');
+ const { ref: listRef, onScroll } = useFollowScroll(
+ followKey,
+ running,
+ expanded,
+ );
+
+ if (trace.entries.length === 0) {
+ return null;
+ }
+
+ /** No background of its own: the pane inherits the card's surface in both
+ * themes, which is what the sibling output pane resolves to anyway. A
+ * `dark:` override here would step outside the semantic roles and lose the
+ * intended separation under a custom theme. */
+ return (
+
+
+ {localize('com_ui_ptc_trace_title')}
+
+
+ {/* The retained tail is a window, not the whole program — say so
+ rather than let the reader assume these are all the calls. */}
+ {trace.dropped > 0 && (
+ -
+ {localize('com_ui_ptc_trace_earlier', { count: trace.dropped })}
+
+ )}
+ {trace.entries.map((entry) => (
+
+ ))}
+
+