@datalayer/agent-runtimes 1.3.84 → 1.3.85

package/lib/components/teams/SceneView.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { SegmentedControl } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { SceneTranscript, useSceneTranscript } from './SceneTranscript';
+const NO_MEMBERS = [];
+/** The graph and the transcript of a scene, behind a *Graph · Transcript* toggle. */
+export function SceneView({ children, members = NO_MEMBERS, tracer, lines, defaultView = 'graph', view, onViewChange, emptyText, maxHeight = 360, aside, }) {
+    const [own, setOwn] = useState(defaultView);
+    const shown = view ?? own;
+    const choose = (next) => {
+        setOwn(next);
+        onViewChange?.(next);
+    };
+    const live = useSceneTranscript(lines ? null : tracer, members);
+    const transcript = lines ?? live;
+    return (_jsxs(Box, { "data-scene-view": shown, children: [_jsxs(Box, { sx: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'space-between',
+                    gap: 2,
+                    flexWrap: 'wrap',
+                    mb: 2,
+                }, children: [_jsxs(SegmentedControl, { "aria-label": "Scene view", size: "small", children: [_jsx(SegmentedControl.Button, { selected: shown === 'graph', onClick: () => choose('graph'), "data-scene-choice": "graph", children: "Graph" }), _jsx(SegmentedControl.Button, { selected: shown === 'transcript', onClick: () => choose('transcript'), "data-scene-choice": "transcript", children: transcript.length
+                                    ? `Transcript (${transcript.length})`
+                                    : 'Transcript' })] }), aside] }), _jsx(Box, { hidden: shown !== 'graph', "data-scene-graph": "", children: children }), shown === 'transcript' && (_jsx(SceneTranscript, { lines: transcript, emptyText: emptyText, maxHeight: maxHeight }))] }));
+}
+export default SceneView;

package/lib/components/teams/index.d.ts

@@ -13,3 +13,6 @@ export * from './usePeerSandbox';
 export * from './A2ATeamGraph';
 export * from './TeamNotebook';
 export * from './NotebookPreview';
+export * from './sceneTranscript';
+export * from './SceneTranscript';
+export * from './SceneView';

package/lib/components/teams/index.js

@@ -17,3 +17,6 @@ export * from './usePeerSandbox';
 export * from './A2ATeamGraph';
 export * from './TeamNotebook';
 export * from './NotebookPreview';
+export * from './sceneTranscript';
+export * from './SceneTranscript';
+export * from './SceneView';

package/lib/components/teams/sceneTranscript.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The transcript of a scene (LOOP A-06): what happens in it, as lines, in
+ * the order it happened — *Sales: …*, *Sales → Accounting: …*,
+ * *Accounting → Odoo: odoo_accounting_aged_balance* — each with its time.
+ *
+ * One source, read two ways. Live, the lines are read from the OpenTelemetry
+ * spans the Agent Inspector reads (core's live tracer): a turn is an
+ * `invoke_agent` span (what the person asked, what the agent answered), a
+ * tool call an `execute_tool` span (the member and, for an MCP call, the
+ * server it reaches: a connection of the member's), and a request to
+ * another member an `a2a` span (who asked whom, in what words, and what came
+ * back as its events). Once a run is over, the same lines are read from its
+ * record (`RecordEntry`: a `turn`, a `tool_call`), the session's entries as
+ * ai-agents kept them.
+ *
+ * Pure: spans or entries in, lines out, so that a test reads a scripted
+ * scene and a page draws a live one the same way ({@link SceneTranscript}).
+ *
+ * @module components/teams/sceneTranscript
+ */
+import type { OtelSpan } from '@datalayer/core/lib/otel/types';
+import type { RecordEntry } from '../../loop/apps/records';
+import { type A2ATeamConnection } from './a2aTeamFlow';
+/** A member of the scene, as the transcript names it. */
+export type SceneTranscriptMember = {
+    /** Its id in the team: `accounting`. */
+    id: string;
+    /** Its name, the service its spans are done by: `Accounting`. */
+    name: string;
+    /** The MCP servers it reaches: a call to one of their tools is `Member → Server: tool`. */
+    connections?: readonly A2ATeamConnection[];
+};
+/** What a line is: words said, a question asked, a tool called. */
+export type SceneTranscriptKind = 'said' | 'asked' | 'called';
+/** One line of the transcript. */
+export type SceneTranscriptLine = {
+    /** Stable, for a list: the span's or the entry's id, and which of its lines. */
+    key: string;
+    /** When, in milliseconds since the epoch. */
+    at: number;
+    /** Who speaks or acts: a member's name, or the person ({@link PERSON}). */
+    from: string;
+    /** Who is asked or called: a member, or a server (`Odoo`); none when words are said to all. */
+    to?: string;
+    kind: SceneTranscriptKind;
+    /** The words, or the tool's name. */
+    text: string;
+    /** Still happening: the call runs, the answer has not come. */
+    open?: boolean;
+    /** It failed: the span's status, the task's state. */
+    failed?: boolean;
+};
+/** The person in the scene, as the transcript names them. */
+export declare const PERSON = "You";
+/**
+ * The transcript of a scene from the spans recorded while it works (the
+ * Agent Inspector's, one tracer for every member).
+ */
+export declare function transcriptOfSpans(spans: readonly OtelSpan[], members: readonly SceneTranscriptMember[]): SceneTranscriptLine[];
+/**
+ * The transcript of one member's run once it is over, from its record: a
+ * `turn` is what the person asked and what it answered, a `tool_call` what
+ * it called in between. The calls of a turn are recorded before the turn
+ * itself (at its close), so the question is placed where the turn began.
+ */
+export declare function transcriptOfRecord(entries: readonly RecordEntry[], member: SceneTranscriptMember): SceneTranscriptLine[];
+/** A line's time, as a clock reads it: `14:03:27`. */
+export declare function timeText(at: number): string;
+/** Who a line is from and to: `Sales`, `Sales → Accounting`, `Accounting → Odoo`. */
+export declare function lineHeading(line: Pick<SceneTranscriptLine, 'from' | 'to' | 'kind'>): string;
+/** A line in words: `Sales → Accounting: Which invoices are open?`. */
+export declare function lineText(line: SceneTranscriptLine): string;
+/** The transcript as text, one line each with its time: what *Copy as text* copies. */
+export declare function transcriptText(lines: readonly SceneTranscriptLine[]): string;

package/lib/components/teams/sceneTranscript.js

@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { connectionOfTool } from './a2aTeamFlow';
+/** The person in the scene, as the transcript names them. */
+export const PERSON = 'You';
+/** What a tool that is no connection's reaches, by where it comes from. */
+const TOOL_HOMES = {
+    frontend: 'the page',
+    skill: 'a skill',
+    codemode: 'codemode',
+    runtime: 'its runtime',
+};
+const text = (value) => typeof value === 'string' ? value : '';
+/** The text of the first message of a GenAI messages attribute (JSON). */
+function messageText(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return (parsed[0]?.parts ?? [])
+            .map(part => (typeof part.content === 'string' ? part.content : ''))
+            .join('')
+            .trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** A time as the span writes it, in milliseconds. */
+function millis(iso, fallback = 0) {
+    const parsed = iso ? Date.parse(iso) : Number.NaN;
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+/** The member a service name is: by name, then by id; else the name itself. */
+function memberNamed(service, members) {
+    return (members.find(member => member.name === service) ??
+        members.find(member => member.id === service) ?? {
+        id: service,
+        name: service,
+    });
+}
+/** Where a tool call goes: the connection it is of (`Odoo`), else its home by kind. */
+function calledOf(tool, kind, member) {
+    const connection = connectionOfTool(tool, [...(member.connections ?? [])]);
+    return connection?.label ?? TOOL_HOMES[kind] ?? TOOL_HOMES.runtime;
+}
+const isA2A = (span, attributes) => attributes['rpc.service'] === 'a2a' || span.span_name.startsWith('a2a ');
+/** The lines in the order they happened: by time, a tie kept as given. */
+function inOrder(lines) {
+    return lines
+        .map((line, index) => ({ line, index }))
+        .sort((a, b) => a.line.at - b.line.at || a.index - b.index)
+        .map(({ line }) => line);
+}
+/**
+ * The same thing said twice is said once: a member's answer comes back as
+ * the A2A request's events and, on a runtime whose own spans are read, as
+ * its `invoke_agent` span too. The first one stands.
+ */
+function onceEach(lines) {
+    const seen = new Set();
+    return lines.filter(line => {
+        // Words said are the same words whoever they were said to.
+        const said = `${line.kind}\u0000${line.from}\u0000${line.kind === 'said' ? '' : (line.to ?? '')}\u0000${line.text}`;
+        if (seen.has(said)) {
+            return false;
+        }
+        seen.add(said);
+        return true;
+    });
+}
+/**
+ * The transcript of a scene from the spans recorded while it works (the
+ * Agent Inspector's, one tracer for every member).
+ */
+export function transcriptOfSpans(spans, members) {
+    const lines = [];
+    // A tool call under which an A2A request sits is the asking itself: the
+    // request says it, with its words.
+    const asking = new Set();
+    for (const span of spans) {
+        if (span.parent_span_id && isA2A(span, span.attributes ?? {})) {
+            asking.add(span.parent_span_id);
+        }
+    }
+    for (const span of spans) {
+        const attributes = span.attributes ?? {};
+        const start = millis(span.start_time);
+        const end = millis(span.end_time, start);
+        const operation = attributes['gen_ai.operation.name'];
+        const failed = span.status_code === 'ERROR';
+        if (operation === 'invoke_agent') {
+            const agent = memberNamed(text(attributes['gen_ai.agent.name']) || span.service_name, members);
+            const asked = messageText(attributes['gen_ai.input.messages']);
+            // The person's question, at the top of a turn; a turn asked by another
+            // member is told by its A2A request.
+            if (asked && !span.parent_span_id) {
+                lines.push({
+                    key: `${span.span_id}:asked`,
+                    at: start,
+                    from: PERSON,
+                    to: agent.name,
+                    kind: 'asked',
+                    text: asked,
+                });
+            }
+            const said = messageText(attributes['gen_ai.output.messages']);
+            if (said) {
+                lines.push({
+                    key: `${span.span_id}:said`,
+                    at: end,
+                    from: agent.name,
+                    kind: 'said',
+                    text: said,
+                    ...(failed ? { failed } : {}),
+                });
+            }
+            else if (failed) {
+                lines.push({
+                    key: `${span.span_id}:said`,
+                    at: end,
+                    from: agent.name,
+                    kind: 'said',
+                    text: `could not answer${span.status_message ? `: ${span.status_message}` : ''}`,
+                    failed,
+                });
+            }
+            continue;
+        }
+        if (operation === 'execute_tool') {
+            if (asking.has(span.span_id)) {
+                continue;
+            }
+            const agent = memberNamed(text(attributes['gen_ai.agent.name']) || span.service_name, members);
+            const tool = text(attributes['gen_ai.tool.name']) || span.span_name;
+            lines.push({
+                key: `${span.span_id}:called`,
+                at: start,
+                from: agent.name,
+                to: calledOf(tool, text(attributes['datalayer.tool.kind']), agent),
+                kind: 'called',
+                text: tool,
+                ...(span.in_progress ? { open: true } : {}),
+                ...(failed ? { failed } : {}),
+            });
+            continue;
+        }
+        if (isA2A(span, attributes)) {
+            const request = text(attributes['a2a.message.text']).trim();
+            if (!request) {
+                // The agent card, a task read: nothing said.
+                continue;
+            }
+            const asker = memberNamed(span.service_name, members);
+            const peer = memberNamed(text(attributes['peer.service']), members);
+            lines.push({
+                key: `${span.span_id}:asked`,
+                at: start,
+                from: asker.name,
+                to: peer.name,
+                kind: 'asked',
+                text: request,
+                ...(span.in_progress ? { open: true } : {}),
+            });
+            // What came back: the answer, or the last words of its events.
+            let answer = text(attributes['a2a.answer.text']).trim();
+            let answeredAt = end;
+            if (!answer) {
+                for (const event of span.events ?? []) {
+                    if (event.name === 'a2a.message' ||
+                        event.name === 'a2a.artifact_update') {
+                        const words = text(event.attributes?.['a2a.message.text']).trim();
+                        if (words) {
+                            answer = words;
+                            answeredAt = millis(event.timestamp, end);
+                        }
+                    }
+                }
+            }
+            if (answer) {
+                lines.push({
+                    key: `${span.span_id}:said`,
+                    at: answeredAt,
+                    from: peer.name,
+                    to: asker.name,
+                    kind: 'said',
+                    text: answer,
+                    ...(failed ? { failed } : {}),
+                });
+            }
+            else if (failed) {
+                lines.push({
+                    key: `${span.span_id}:said`,
+                    at: end,
+                    from: peer.name,
+                    to: asker.name,
+                    kind: 'said',
+                    text: `could not answer${span.status_message ? `: ${span.status_message}` : ''}`,
+                    failed,
+                });
+            }
+        }
+    }
+    return onceEach(inOrder(lines));
+}
+/**
+ * The transcript of one member's run once it is over, from its record: a
+ * `turn` is what the person asked and what it answered, a `tool_call` what
+ * it called in between. The calls of a turn are recorded before the turn
+ * itself (at its close), so the question is placed where the turn began.
+ */
+export function transcriptOfRecord(entries, member) {
+    const ordered = [...entries].sort((a, b) => millis(a.createdAt) - millis(b.createdAt) || a.version - b.version);
+    const lines = [];
+    let pending = [];
+    let answered = false;
+    for (const entry of ordered) {
+        const at = millis(entry.createdAt);
+        if (entry.kind === 'tool_call') {
+            const tool = text(entry.payload.tool) || entry.summary;
+            pending.push({
+                key: `${entry.uid}:called`,
+                at,
+                from: member.name,
+                to: calledOf(tool, '', member),
+                kind: 'called',
+                text: tool,
+                ...(entry.payload.error ? { failed: true } : {}),
+            });
+        }
+        else if (entry.kind === 'turn') {
+            const asked = text(entry.payload.asked) || entry.summary;
+            const said = text(entry.payload.answered);
+            lines.push({
+                key: `${entry.uid}:asked`,
+                at: pending[0]?.at ?? at,
+                from: PERSON,
+                to: member.name,
+                kind: 'asked',
+                text: asked,
+            });
+            lines.push(...pending);
+            pending = [];
+            if (said) {
+                lines.push({
+                    key: `${entry.uid}:said`,
+                    at,
+                    from: member.name,
+                    kind: 'said',
+                    text: said,
+                });
+            }
+            answered = true;
+        }
+        else if (entry.kind === 'output' && !answered) {
+            // A record kept without its conversations: the answer's summary.
+            pending.push({
+                key: `${entry.uid}:said`,
+                at,
+                from: member.name,
+                kind: 'said',
+                text: entry.summary,
+            });
+        }
+    }
+    lines.push(...pending);
+    return lines;
+}
+/** A line's time, as a clock reads it: `14:03:27`. */
+export function timeText(at) {
+    const date = new Date(at);
+    const two = (value) => String(value).padStart(2, '0');
+    return `${two(date.getHours())}:${two(date.getMinutes())}:${two(date.getSeconds())}`;
+}
+/** Who a line is from and to: `Sales`, `Sales → Accounting`, `Accounting → Odoo`. */
+export function lineHeading(line) {
+    return line.to && line.kind !== 'said'
+        ? `${line.from} → ${line.to}`
+        : line.from;
+}
+/** A line in words: `Sales → Accounting: Which invoices are open?`. */
+export function lineText(line) {
+    const tail = line.open ? '…' : line.failed ? ' (failed)' : '';
+    return `${lineHeading(line)}: ${line.text}${tail}`;
+}
+/** The transcript as text, one line each with its time: what *Copy as text* copies. */
+export function transcriptText(lines) {
+    return lines
+        .map(line => `${timeText(line.at)}  ${lineText(line)}`)
+        .join('\n');
+}

package/lib/components/teams/teamConnections.d.ts

@@ -1,6 +1,6 @@
 import type { AppSpec } from '../../types/agentspecs';
 import { type A2ATeamConnection } from './a2aTeamFlow';
-import type { ToolClass } from '../inspector/agentInspector';
+import type { ToolClass } from '../inspector/agentSpans';
 /**
  * The connections of an application, each with its server's name and mark
  * and its tools. A connection to a server the catalogue does not have is
@@ -8,7 +8,7 @@ import type { ToolClass } from '../inspector/agentInspector';
  */
 export declare function teamConnectionsOf(app: Pick<AppSpec, 'connections'>): A2ATeamConnection[];
 /**
- * Where a member's tool call comes from, for the Agent Inspector: a call to
+ * Where a member's tool call comes from, for its span: a call to
  * one of its connections is an MCP call, with the server's mark; any other
  * is `fallback`'s (`classifyToolCall`, by the catalogues) or a tool its
  * runtime runs (`write_notebook`).

package/lib/components/teams/teamConnections.js

@@ -49,7 +49,7 @@ export function teamConnectionsOf(app) {
     return connections;
 }
 /**
- * Where a member's tool call comes from, for the Agent Inspector: a call to
+ * Where a member's tool call comes from, for its span: a call to
  * one of its connections is an MCP call, with the server's mark; any other
  * is `fallback`'s (`classifyToolCall`, by the catalogues) or a tool its
  * runtime runs (`write_notebook`).
@@ -59,11 +59,11 @@ export function teamToolClassifier(connections, fallback) {
         const connection = connectionOfTool(name, connections);
         if (connection) {
             return {
-                source: 'mcp',
+                kind: 'mcp',
                 ...(connection.icon ? { icon: connection.icon } : {}),
                 ...(connection.emoji ? { emoji: connection.emoji } : {}),
             };
         }
-        return fallback?.(name, args) ?? { source: 'backend-tool' };
+        return fallback?.(name, args) ?? { kind: 'runtime' };
     };
 }

package/lib/components/teams/useA2ATeam.d.ts

@@ -3,7 +3,7 @@ import type { DisplayItem } from '../../types/chat';
 import { type BrowserModelOptions } from '../../runtimes/browser/model';
 import { type A2APeer, type A2APeerArtifact } from '../../runtimes/browser/a2aPeer';
 import type { AppSpec } from '../../types/agentspecs';
-import type { AgentInspectorSink } from '../inspector/agentInspector';
+import type { OtelLiveTracer } from '@datalayer/core/lib/otel/live';
 import { type A2ATeamCall, type A2ATeamConnection, type A2ATeamFlow } from './a2aTeamFlow';
 import { type BalloonToolLine } from '../../chat/assistant/toolLine';
 /** What one member's character does: its state, its balloon, and whether it was sent away. */
@@ -59,10 +59,10 @@ export type UseA2ATeamOptions = {
      */
     accept?: readonly string[];
     /**
-     * The Agent Inspector's sink: the entry's turns and its call to the peer
-     * are recorded there, and what the peer's events were made of.
+     * The Agent Inspector's tracer: the entry's turns and its call to the
+     * peer are recorded there as spans.
      */
-    inspector?: AgentInspectorSink | null;
+    inspector?: OtelLiveTracer | null;
 };
 export type A2ATeam = {
     entryPersona: A2ATeamPersona;

package/lib/components/teams/useA2ATeam.js

@@ -20,10 +20,11 @@
  * peer calls on its connections (its MCP servers), told over A2A as it calls
  * them, are kept as the calls running now ({@link callsAfter}).
  *
- * Given an Agent Inspector's sink (`inspector`), the entry's turns (its
- * model, its tokens), its call to the peer, and what the peer's events were
- * made of are recorded there; the A2A traffic itself is recorded by the
- * peer's fetch (`connectA2APeer`'s `inspect`).
+ * Given the Agent Inspector's tracer (`inspector`), the entry's turns (an
+ * `invoke_agent` span: its model, its tokens) and its call to the peer (an
+ * `execute_tool` span under it) are recorded there as OpenTelemetry spans;
+ * the A2A traffic itself, under that call, is recorded by the peer's fetch
+ * (`traceA2AFetch`).
  *
  * What `A2ATeamGraph` draws, and what a page's composer sends.
  *
@@ -33,6 +34,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { stepCountIs, ToolLoopAgent } from 'ai';
 import { createBrowserModel, } from '../../runtimes/browser/model';
 import { a2aPeerTool, NOTEBOOK_MEDIA_TYPE, } from '../../runtimes/browser/a2aPeer';
+import { endAgentTurn, endToolCall, startAgentTurn, startToolCall, } from '../inspector/agentSpans';
 import { callsAfter, flowAfter, toolOwnName, pruneCalls, } from './a2aTeamFlow';
 import { toolLineOfStep, } from '../../chat/assistant/toolLine';
 const NO_CONNECTIONS = [];
@@ -119,13 +121,10 @@ export function useA2ATeam(options) {
     const callTimer = useRef(undefined);
     const [busy, setBusy] = useState(false);
     const history = useRef([]);
-    const turnCount = useRef(0);
     const abort = useRef(null);
     const flowTimer = useRef(undefined);
     // What the peer does, as it does it: its own state and balloon, and the link.
     const onPeerEvent = useCallback((event) => {
-        // Linked to the A2A entry it came from (the capture's linker).
-        inspector?.note(event);
         const next = flowAfter(event);
         clearTimeout(flowTimer.current);
         setFlow(next.flow);
@@ -204,7 +203,7 @@ export function useA2ATeam(options) {
                 tool: undefined,
             }));
         }
-    }, [peerApp.id, peerConnections, inspector, tell, toolCalled]);
+    }, [peerApp.id, peerConnections, tell, toolCalled]);
     const agent = useMemo(() => {
         if (!peer) {
             return null;
@@ -241,19 +240,16 @@ export function useA2ATeam(options) {
         history.current = [...history.current, { role: 'user', content: asked }];
         abort.current = new AbortController();
         let said = '';
-        // The turn, in the inspector: the entry's model, from the question to
-        // the answer, and its tokens.
-        turnCount.current += 1;
-        const turnKey = `turn:${entry.id}:${turnCount.current}`;
-        inspector?.start({
-            key: turnKey,
-            actor: entry.name,
-            source: 'model',
-            kind: 'turn',
-            name: entry.model || undefined,
-            summary: balloonLine(asked, 160),
-            payload: { prompt: asked, model: entry.model || undefined },
-        });
+        // The turn, as a span: the entry's model, from the question to the
+        // answer, and its tokens; its calls to the peer under it.
+        const turnSpan = inspector
+            ? startAgentTurn(inspector, {
+                agent: entry.name,
+                prompt: asked,
+                model: entry.model || undefined,
+            })
+            : undefined;
+        const toolSpans = new Map();
         try {
             const result = await agent.stream({
                 messages: history.current,
@@ -263,15 +259,16 @@ export function useA2ATeam(options) {
                 if (part.type === 'tool-call' && part.toolName === askTool) {
                     const request = String(part.input?.request ?? '');
                     // Its tool runs here, in the page, and asks the peer over A2A.
-                    inspector?.start({
-                        key: `tool:${part.toolCallId}`,
-                        actor: entry.name,
-                        source: 'frontend-tool',
-                        kind: 'tool-call',
-                        name: askTool,
-                        summary: balloonLine(request, 160),
-                        payload: part.input,
-                    });
+                    if (inspector && turnSpan) {
+                        toolSpans.set(part.toolCallId, startToolCall(inspector, {
+                            agent: entry.name,
+                            name: askTool,
+                            id: part.toolCallId,
+                            args: part.input,
+                            tool: { kind: 'frontend' },
+                            parent: turnSpan.context,
+                        }));
+                    }
                     setEntryPersona(prev => ({
                         ...prev,
                         state: 'waiting',
@@ -290,10 +287,14 @@ export function useA2ATeam(options) {
                 }
                 else if (part.type === 'tool-result' && part.toolName === askTool) {
                     const output = part.output;
-                    inspector?.end(`tool:${part.toolCallId}`, {
-                        result: part.output,
-                        ...(output?.error ? { error: String(output.error) } : {}),
-                    });
+                    const toolSpan = toolSpans.get(part.toolCallId);
+                    if (toolSpan) {
+                        toolSpans.delete(part.toolCallId);
+                        endToolCall(toolSpan, {
+                            result: part.output,
+                            ...(output?.error ? { error: String(output.error) } : {}),
+                        });
+                    }
                     setEntryPersona(prev => ({
                         ...prev,
                         state: 'thinking',
@@ -317,12 +318,15 @@ export function useA2ATeam(options) {
                     }));
                 }
                 else if (part.type === 'tool-error' && part.toolName === askTool) {
-                    inspector?.end(`tool:${part.toolCallId}`, {
-                        status: 'failed',
-                        error: part.error instanceof Error
-                            ? part.error.message
-                            : String(part.error),
-                    });
+                    const toolSpan = toolSpans.get(part.toolCallId);
+                    if (toolSpan) {
+                        toolSpans.delete(part.toolCallId);
+                        endToolCall(toolSpan, {
+                            error: part.error instanceof Error
+                                ? part.error.message
+                                : String(part.error),
+                        });
+                    }
                     setEntryPersona(prev => ({
                         ...prev,
                         state: 'thinking',
@@ -339,12 +343,9 @@ export function useA2ATeam(options) {
                 ...history.current,
                 { role: 'assistant', content: said },
             ];
-            if (inspector) {
+            if (turnSpan) {
                 const usage = await Promise.resolve(result.totalUsage).catch(() => undefined);
-                inspector.end(turnKey, {
-                    result: { text: said, ...(usage ? { usage } : {}) },
-                    summary: `${balloonLine(asked, 60)} → ${balloonLine(said, 80)}${usage?.totalTokens ? ` · ${usage.totalTokens} tokens` : ''}`,
-                });
+                endAgentTurn(turnSpan, { text: said, usage });
             }
             setTurns(prev => [...prev, { role: 'assistant', text: said }]);
             setEntryPersona(prev => ({
@@ -356,7 +357,10 @@ export function useA2ATeam(options) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            inspector?.end(turnKey, { status: 'failed', error: message });
+            toolSpans.forEach(toolSpan => endToolCall(toolSpan, { error: message }));
+            if (turnSpan) {
+                endAgentTurn(turnSpan, { error: message });
+            }
             setTurns(prev => [
                 ...prev,
                 { role: 'assistant', text: `Something went wrong: ${message}` },