@datalayer/agent-runtimes 1.3.84 → 1.3.86

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

@@ -0,0 +1,29 @@
+/**
+ * The transcript of a scene, drawn (LOOP A-06): the lines
+ * {@link transcriptOfSpans} or {@link transcriptOfRecord} built, each with
+ * its time, who speaks or acts and to whom, and the words or the tool —
+ * and *Copy as text*, which copies them with their times
+ * ({@link transcriptText}).
+ *
+ * @module components/teams/SceneTranscript
+ */
+import type { JSX } from 'react';
+import type { OtelLiveTracer } from '@datalayer/core/lib/otel/live';
+import { type SceneTranscriptLine, type SceneTranscriptMember } from './sceneTranscript';
+/** The transcript of a tracer's spans, kept current as they change. */
+export declare function useSceneTranscript(tracer: OtelLiveTracer | null | undefined, members: readonly SceneTranscriptMember[]): SceneTranscriptLine[];
+export type SceneTranscriptProps = {
+    /** The lines, in order. */
+    lines: readonly SceneTranscriptLine[];
+    /** What is said while there is no line yet. */
+    emptyText?: string;
+    /** How tall it grows before it scrolls, in pixels. */
+    maxHeight?: number;
+    /** Whether *Copy as text* is offered (it is, when there is a line). */
+    copy?: boolean;
+    /** The clipboard: `navigator.clipboard.writeText` unless a test gives one. */
+    writeText?: (text: string) => Promise<void>;
+};
+/** The transcript as a list of lines, newest last, with *Copy as text*. */
+export declare function SceneTranscript({ lines, emptyText, maxHeight, copy, writeText, }: SceneTranscriptProps): JSX.Element;
+export default SceneTranscript;

package/lib/components/teams/SceneTranscript.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { Button, Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { useOtelLiveSpans } from '@datalayer/core/lib/otel/live';
+import { lineHeading, timeText, transcriptOfSpans, transcriptText, } from './sceneTranscript';
+/** The transcript of a tracer's spans, kept current as they change. */
+export function useSceneTranscript(tracer, members) {
+    const spans = useOtelLiveSpans(tracer);
+    return useMemo(() => transcriptOfSpans(spans, members), [spans, members]);
+}
+/** How long *Copied* stays, in milliseconds. */
+const COPIED_MS = 1500;
+/** The transcript as a list of lines, newest last, with *Copy as text*. */
+export function SceneTranscript({ lines, emptyText = 'What the scene says and does shows here, line by line.', maxHeight, copy = true, writeText, }) {
+    const [copied, setCopied] = useState(false);
+    const onCopy = async () => {
+        const write = writeText ??
+            (text => globalThis.navigator?.clipboard?.writeText(text) ?? Promise.resolve());
+        try {
+            await write(transcriptText(lines));
+            setCopied(true);
+            setTimeout(() => setCopied(false), COPIED_MS);
+        }
+        catch {
+            // The clipboard refused: nothing to say but the text, still on screen.
+        }
+    };
+    return (_jsxs(Box, { "data-scene-transcript": "", "data-scene-lines": lines.length, children: [lines.length === 0 ? (_jsx(Text, { as: "p", sx: { color: 'fg.muted', fontSize: 1, m: 0 }, children: emptyText })) : (_jsx(Box, { as: "ol", "aria-label": "Transcript", sx: {
+                    listStyle: 'none',
+                    m: 0,
+                    p: 0,
+                    fontSize: 1,
+                    ...(maxHeight ? { maxHeight, overflowY: 'auto' } : {}),
+                }, children: lines.map(line => (_jsxs(Box, { as: "li", "data-transcript-line": line.kind, "data-transcript-from": line.from, "data-transcript-to": line.to, "aria-busy": line.open ? 'true' : undefined, sx: {
+                        display: 'grid',
+                        gridTemplateColumns: 'auto 1fr',
+                        gap: 2,
+                        py: 1,
+                        borderBottom: '1px solid',
+                        borderColor: 'border.muted',
+                        opacity: line.open ? 0.75 : 1,
+                    }, children: [_jsx(Text, { as: "time", sx: {
+                                color: 'fg.muted',
+                                fontFamily: 'mono',
+                                fontSize: 0,
+                                pt: '2px',
+                                whiteSpace: 'nowrap',
+                            }, dateTime: new Date(line.at).toISOString(), children: timeText(line.at) }), _jsxs(Box, { sx: { minWidth: 0, overflowWrap: 'anywhere' }, children: [_jsxs(Text, { sx: { fontWeight: 600 }, children: [lineHeading(line), ": "] }), _jsxs(Text, { sx: {
+                                        fontFamily: line.kind === 'called' ? 'mono' : undefined,
+                                        color: line.failed ? 'danger.fg' : undefined,
+                                    }, children: [line.text, line.open ? '…' : '', line.failed ? ' (failed)' : ''] })] })] }, line.key))) })), copy && lines.length > 0 && (_jsx(Box, { sx: { mt: 2 }, children: _jsx(Button, { size: "small", onClick: () => void onCopy(), "data-transcript-copy": "", children: copied ? 'Copied' : 'Copy as text' }) }))] }));
+}
+export default SceneTranscript;

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

@@ -0,0 +1,41 @@
+/**
+ * A scene on a page: its graph (`A2ATeamGraph`) and its transcript
+ * ({@link SceneTranscript}), one shown at a time behind a *Graph · Transcript*
+ * toggle (LOOP A-06). The graph stays mounted while the transcript shows, so
+ * that what its members were doing is still there when it comes back.
+ *
+ * The lines come from the Agent Inspector's tracer the graph's members
+ * record into (`tracer`, with the `members` to name them), or are given
+ * (`lines`: a finished run's, from its record).
+ *
+ * @module components/teams/SceneView
+ */
+import type { JSX, ReactNode } from 'react';
+import type { OtelLiveTracer } from '@datalayer/core/lib/otel/live';
+import type { SceneTranscriptLine, SceneTranscriptMember } from './sceneTranscript';
+/** Which of the two the scene shows. */
+export type SceneViewChoice = 'graph' | 'transcript';
+export type SceneViewProps = {
+    /** The graph: an `A2ATeamGraph`, or whatever draws the scene. */
+    children: ReactNode;
+    /** The members, to name the spans' services and their connections. */
+    members?: readonly SceneTranscriptMember[];
+    /** The tracer the members record into: the transcript is read from it. */
+    tracer?: OtelLiveTracer | null;
+    /** The lines, given: a finished run's. Wins over `tracer`. */
+    lines?: readonly SceneTranscriptLine[];
+    /** What shows first: the graph unless said. */
+    defaultView?: SceneViewChoice;
+    /** The choice, held by the page; with `onViewChange`. */
+    view?: SceneViewChoice;
+    onViewChange?: (view: SceneViewChoice) => void;
+    /** What the transcript says while there is no line yet. */
+    emptyText?: string;
+    /** How tall the transcript grows before it scrolls, in pixels. */
+    maxHeight?: number;
+    /** Something of the page's beside the toggle: a clock, a line. */
+    aside?: ReactNode;
+};
+/** The graph and the transcript of a scene, behind a *Graph · Transcript* toggle. */
+export declare function SceneView({ children, members, tracer, lines, defaultView, view, onViewChange, emptyText, maxHeight, aside, }: SceneViewProps): JSX.Element;
+export default SceneView;

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,7 @@ export * from './usePeerSandbox';
 export * from './A2ATeamGraph';
 export * from './TeamNotebook';
 export * from './NotebookPreview';
+export * from './sceneTranscript';
+export * from './SceneTranscript';
+export * from './SceneView';
+export * from './sceneStage';

package/lib/components/teams/index.js

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

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

@@ -0,0 +1,120 @@
+/**
+ * A scene as a page stages it (LOOP A-13, A-15), read from the scene spec
+ * and its team: who is on stage and where each one stands, who asks whom
+ * over A2A, what the entry suggests, and where the members on a runtime are
+ * reached when the scene plays against local servers.
+ *
+ * Pure, so the examples app, the landing and the tests read a scene the
+ * same way.
+ *
+ * @module components/teams/sceneStage
+ */
+import type { AppSpec } from '../../types/agentspecs';
+import type { SceneCastMemberSpec, SceneSpec } from '../../types/scenes';
+import type { TeamSpec } from '../../types/teams';
+/** Who talks to whom over A2A: an edge of the team's graph. */
+export type A2ATeamLink = {
+    /** The member that asks, by its id. */
+    from: string;
+    /** The member asked. */
+    to: string;
+};
+/** A reference without its version: `accounting:0.0.1` is `accounting`. */
+export declare function refId(ref: string): string;
+/** The application a cast member is, from the catalogue, or undefined. */
+export declare function appOfMember(member: Pick<SceneCastMemberSpec, 'app'>): AppSpec | undefined;
+/**
+ * The links of a team over A2A, in the order its members say them: each
+ * member's `talks_to … over: a2a`. A link to a server (over `mcp`) is a
+ * connection, drawn under the member, not an edge between members.
+ */
+export declare function teamLinksOf(team: Pick<TeamSpec, 'agents'> | Pick<SceneSpec, 'cast'>): A2ATeamLink[];
+/** A suggestion the entry offers: a label on its chip, and what is sent. */
+export type SceneSuggestion = {
+    label: string;
+    prompt: string;
+};
+/**
+ * The entry's suggestions: the script's cues, each labelled by the starter
+ * of the entry's Appspec that says the same words, or by its first words.
+ * Without a scene, the starters themselves.
+ */
+export declare function sceneCuesOf(scene: Pick<SceneSpec, 'script'> | undefined, starters: readonly {
+    label: string;
+    message: string;
+}[]): SceneSuggestion[];
+/** One member of a scene, as a page stages it. */
+export type SceneStageMember = {
+    /** Its id in the cast. */
+    id: string;
+    /** The application it is. */
+    app: AppSpec;
+    cast: SceneCastMemberSpec;
+    /** Whether it is the member the audience talks to. */
+    entry: boolean;
+    /** Where its loop turns. */
+    runsIn: 'browser' | 'runtime';
+    /** The variable its address is read from, when it runs on a runtime. */
+    addressVariable?: string;
+    /** Where it stands: fractions of the box, from the stage directions. */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** What its application needs that is not set up, in sentences. */
+    setup: string[];
+};
+/** A scene as a page stages it. */
+export type SceneStage = {
+    scene: SceneSpec;
+    entry: SceneStageMember;
+    /** The members the entry asks over A2A, in the cast's order. */
+    peers: SceneStageMember[];
+    /** Every member, the entry first. */
+    members: SceneStageMember[];
+    /** The edges between members: the team's `talks_to` over A2A. */
+    links: A2ATeamLink[];
+    /** Where each member stands, by its id. */
+    positions: Record<string, {
+        x: number;
+        y: number;
+    }>;
+    /** Whose balloon opens first. */
+    opensFirst: string;
+    /** What the audience is told: the line under the title. */
+    assumes: string;
+};
+/**
+ * Read a scene's stage: its members with their applications, who the entry
+ * is and whom it asks, the links, the positions. Refused when a cast member
+ * is an application the catalogue does not have, or the entry is not in the
+ * cast: a page cannot stage what it cannot draw.
+ */
+export declare function sceneStageOf(scene: SceneSpec): SceneStage;
+/** The port the examples serve Accounting on, as `npm run examples` starts it. */
+export declare const ACCOUNTING_PORT = 8767;
+/** The first port `serve_scenes.py` starts a runtime on for the other members. */
+export declare const SCENE_PORTS_FROM = 8768;
+/**
+ * The members on a runtime across the catalogue's scenes, each once, in
+ * the catalogue's order (a scene's cast in its order): what
+ * `examples/sales-accounting-a2a/serve_scenes.py` serves, in that order.
+ */
+export declare function sceneRuntimeMembers(scenes?: readonly SceneSpec[]): string[];
+/**
+ * The port each runtime member is served on locally: Accounting on
+ * {@link ACCOUNTING_PORT}, the others from {@link SCENE_PORTS_FROM} on, in
+ * the order of {@link sceneRuntimeMembers}. `serve_scenes.py` gives the
+ * same ports by the same rule.
+ */
+export declare function sceneRuntimePorts(scenes?: readonly SceneSpec[]): Record<string, number>;
+/** The variable the examples read a member's local address from: `VITE_A2A_CHANGE_DETECTION_URL`. */
+export declare function sceneAddressVariable(appId: string): string;
+/** Where a member is served over A2A on a local runtime at `port`. */
+export declare function localA2AUrl(appId: string, port: number): string;
+/**
+ * Where a member on a runtime is reached by the examples: its variable
+ * (`VITE_A2A_<MEMBER>_URL`) when set in `env`, else the local runtime
+ * `serve_scenes.py` serves it on.
+ */
+export declare function sceneMemberUrl(appId: string, env: Record<string, string | undefined>, ports?: Record<string, number>): string;

package/lib/components/teams/sceneStage.js

@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { APP_CATALOGUE } from '../../specs/apps';
+import { listSceneSpecs } from '../../specs/scenes';
+/** A reference without its version: `accounting:0.0.1` is `accounting`. */
+export function refId(ref) {
+    const at = ref.lastIndexOf(':');
+    return at > 0 && ref.slice(at + 1).includes('.') ? ref.slice(0, at) : ref;
+}
+/** The application a cast member is, from the catalogue, or undefined. */
+export function appOfMember(member) {
+    const id = refId(member.app);
+    return id && Object.prototype.hasOwnProperty.call(APP_CATALOGUE, id)
+        ? APP_CATALOGUE[id]
+        : undefined;
+}
+/**
+ * The links of a team over A2A, in the order its members say them: each
+ * member's `talks_to … over: a2a`. A link to a server (over `mcp`) is a
+ * connection, drawn under the member, not an edge between members.
+ */
+export function teamLinksOf(team) {
+    const members = 'cast' in team
+        ? team.cast.map(member => ({
+            id: member.member,
+            talksTo: member.talksTo,
+        }))
+        : team.agents;
+    return members.flatMap(member => (member.talksTo ?? [])
+        .filter(link => link.over === 'a2a')
+        .map(link => ({ from: member.id, to: link.member })));
+}
+/**
+ * The entry's suggestions: the script's cues, each labelled by the starter
+ * of the entry's Appspec that says the same words, or by its first words.
+ * Without a scene, the starters themselves.
+ */
+export function sceneCuesOf(scene, starters) {
+    const fromStarters = starters.map(starter => ({
+        label: starter.label,
+        prompt: starter.message,
+    }));
+    if (!scene) {
+        return fromStarters;
+    }
+    return scene.script
+        .map(beat => beat.cue.say.trim())
+        .filter(Boolean)
+        .map(prompt => ({
+        label: fromStarters.find(starter => starter.prompt === prompt)?.label ??
+            prompt.split(/\s+/).slice(0, 4).join(' '),
+        prompt,
+    }));
+}
+/**
+ * Read a scene's stage: its members with their applications, who the entry
+ * is and whom it asks, the links, the positions. Refused when a cast member
+ * is an application the catalogue does not have, or the entry is not in the
+ * cast: a page cannot stage what it cannot draw.
+ */
+export function sceneStageOf(scene) {
+    const members = scene.cast
+        .filter(member => member.app)
+        .map((member) => {
+        const app = appOfMember(member);
+        if (!app) {
+            throw new Error(`The scene ${scene.id} casts ${member.member} as ${member.app}, which the catalogue does not have.`);
+        }
+        const position = scene.stage.positions[member.member];
+        const variable = scene.deployment.addresses[member.member];
+        return {
+            id: member.member,
+            app,
+            cast: member,
+            entry: member.member === scene.entry,
+            runsIn: member.runsIn ?? 'runtime',
+            ...(variable ? { addressVariable: variable } : {}),
+            ...(position ? { position } : {}),
+            setup: app.setup ?? [],
+        };
+    });
+    const entry = members.find(member => member.entry);
+    if (!entry) {
+        throw new Error(`The scene ${scene.id} says its entry is ${scene.entry}, which is not in its cast.`);
+    }
+    const links = teamLinksOf(scene);
+    const asked = links
+        .filter(link => link.from === entry.id)
+        .map(link => link.to);
+    const peers = members.filter(member => !member.entry && asked.includes(member.id));
+    return {
+        scene,
+        entry,
+        peers,
+        members: [entry, ...members.filter(member => !member.entry)],
+        links,
+        positions: scene.stage.positions,
+        opensFirst: scene.stage.opensFirst || entry.id,
+        assumes: scene.setting.assumes,
+    };
+}
+/** The port the examples serve Accounting on, as `npm run examples` starts it. */
+export const ACCOUNTING_PORT = 8767;
+/** The first port `serve_scenes.py` starts a runtime on for the other members. */
+export const SCENE_PORTS_FROM = 8768;
+/**
+ * The members on a runtime across the catalogue's scenes, each once, in
+ * the catalogue's order (a scene's cast in its order): what
+ * `examples/sales-accounting-a2a/serve_scenes.py` serves, in that order.
+ */
+export function sceneRuntimeMembers(scenes = listSceneSpecs()) {
+    const seen = [];
+    for (const scene of scenes) {
+        for (const member of scene.cast) {
+            const id = refId(member.app);
+            if (id &&
+                (member.runsIn ?? 'runtime') === 'runtime' &&
+                !seen.includes(id)) {
+                seen.push(id);
+            }
+        }
+    }
+    return seen;
+}
+/**
+ * The port each runtime member is served on locally: Accounting on
+ * {@link ACCOUNTING_PORT}, the others from {@link SCENE_PORTS_FROM} on, in
+ * the order of {@link sceneRuntimeMembers}. `serve_scenes.py` gives the
+ * same ports by the same rule.
+ */
+export function sceneRuntimePorts(scenes = listSceneSpecs()) {
+    const ports = {};
+    let next = SCENE_PORTS_FROM;
+    for (const id of sceneRuntimeMembers(scenes)) {
+        if (id === 'accounting') {
+            ports[id] = ACCOUNTING_PORT;
+        }
+        else {
+            ports[id] = next;
+            next += 1;
+        }
+    }
+    return ports;
+}
+/** The variable the examples read a member's local address from: `VITE_A2A_CHANGE_DETECTION_URL`. */
+export function sceneAddressVariable(appId) {
+    return `VITE_A2A_${appId.replace(/-/g, '_').toUpperCase()}_URL`;
+}
+/** Where a member is served over A2A on a local runtime at `port`. */
+export function localA2AUrl(appId, port) {
+    return `http://127.0.0.1:${port}/api/v1/a2a/agents/${appId}`;
+}
+/**
+ * Where a member on a runtime is reached by the examples: its variable
+ * (`VITE_A2A_<MEMBER>_URL`) when set in `env`, else the local runtime
+ * `serve_scenes.py` serves it on.
+ */
+export function sceneMemberUrl(appId, env, ports = sceneRuntimePorts()) {
+    const port = ports[appId];
+    const set = env[sceneAddressVariable(appId)];
+    if (set) {
+        return set;
+    }
+    if (port === undefined) {
+        throw new Error(`${appId} runs on no local runtime the examples serve: set ${sceneAddressVariable(appId)}.`);
+    }
+    return localA2AUrl(appId, port);
+}

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;