@datalayer/agent-runtimes 1.3.84 → 1.3.86

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.84",
+    "version": "1.3.86",
     "type": "module",
     "workspaces": [
         ".",
@@ -69,7 +69,7 @@
         "clean:dist": "rimraf dist",
         "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
         "create:patches": "bash scripts/create-patches.sh",
-        "examples": "run-p server:start server:start:codemode server:start:accounting server:accounting jupyter:start examples:vite",
+        "examples": "run-p server:start server:start:codemode server:start:accounting server:scenes jupyter:start examples:vite",
         "examples2": "run-p server:start server:start:codemode jupyter:start examples2:vite",
         "example-local": "make example-local",
         "examples:fresh": "npm run clean:cache && npm run examples",
@@ -99,7 +99,7 @@
         "server:start:agent-node": "AGENT_NODE_JUPYTER_URL=${AGENT_NODE_JUPYTER_URL:-http://127.0.0.1:8888/api/jupyter-server} AGENT_NODE_JUPYTER_TOKEN=${AGENT_NODE_JUPYTER_TOKEN:-60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6} PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info DATALAYER_EVALS_MODE=interactive DATALAYER_EVALS_EMIT_LIVE_EVENTS=true AGENT_RUNTIMES_INFERENCE_PROVIDER_OVERRIDE=${AGENT_RUNTIMES_INFERENCE_PROVIDER_OVERRIDE:-datalayer} python -m agent_runtimes serve --node --port 8765 --log-level info",
         "server:start:codemode": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info DATALAYER_EVALS_MODE=interactive DATALAYER_EVALS_EMIT_LIVE_EVENTS=true python -m agent_runtimes serve --port 8766 --log-level info",
         "server:start:accounting": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info python -m agent_runtimes serve --port 8767 --log-level info",
-        "server:accounting": "python examples/sales-accounting-a2a/serve_accounting.py --url http://127.0.0.1:8767 --wait 300 || echo 'Accounting was not served on 8767: the Agent A2A Team example will say it is not reachable.'",
+        "server:scenes": "python examples/sales-accounting-a2a/serve_scenes.py --url http://127.0.0.1:8767 --wait 300 || echo 'The scenes were not served: the Agent A2A Team and Scenes examples will say which member is not reachable.'",
         "examples:codemode": "run-p server:start server:start:codemode examples:vite",
         "start": "vite",
         "start:acp": "run-p server:start start:acp:vite",
@@ -147,7 +147,7 @@
         "@ai-sdk/react": "4.0.93",
         "@anthropic-ai/sdk": "^0.52.0",
         "@datalayer/agent-teams": "^1.0.0",
-        "@datalayer/core": "^1.2.14",
+        "@datalayer/core": "^1.2.18",
         "@datalayer/decks": "^1.0.4",
         "@datalayer/icons-react": "^1.0.16",
         "@datalayer/jupyter-lexical": "^2.0.18",

package/scripts/codegen/generate_agents.py

@@ -1647,6 +1647,7 @@ export * from './gates';
 export * from './tracks';
 export * from './ops';
 export * from './apps';
+export * from './scenes';
 export * from './actions';
 export * from './appspecSchema';
 """

package/scripts/codegen/generate_apps.py

@@ -55,6 +55,7 @@ CAMEL = {
     "backend_tools": "backendTools",
     "character_alone": "characterAlone",
     "settings_ui": "settingsUi",
+    "custom_components": "customComponents",
 }
 
 #: The keys whose value is carried as it is written: a component tree, weights by name.
@@ -126,6 +127,9 @@ def load_specs(specs_dir: Path) -> tuple[list[dict[str, Any]], dict[str, Any]]:
         for case in spec["tests"]["cases"]:
             if not case.get("code"):
                 case.pop("code", None)
+        # Components of its own: said only when it has some.
+        if not spec["interface"].get("custom_components"):
+            spec["interface"].pop("custom_components", None)
         for key in ("description", "instructions", "goal"):
             spec[key] = _flat(spec.get(key))
         spec["interface"]["welcome"] = _flat(spec["interface"].get("welcome"))
@@ -492,8 +496,6 @@ def generate_schema_typescript_code() -> str:
             " * @module specs/appspecSchema",
             " */",
             "",
-            "/* eslint-disable */",
-            "",
             "export type JsonSchema = {",
             "  [key: string]: unknown;",
             "  type?: string;",

package/scripts/codegen/generate_scenes.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Generate Python and TypeScript code from YAML scene specifications.
+
+A scene (agentspecs >= 0.0.61, LOOP A-11) stages a team: the team says who
+is on stage, the scene says what happens there — the setting, the script,
+the stage directions, the audience, the rehearsal and where it plays. One
+YAML per scene under ``agentspecs/scenes``.
+
+Each scene is validated here, by ``agentspecs`` itself (``scene_problems``),
+and arrives with its cast resolved — every member of the team, its persona
+filled from its application (``cast_of``) — its ``entry`` said, what each
+beat ``shows`` said, and what it names that is not enabled (``setup``).
+Empty optional lists are dropped, as ``generate_apps.py`` drops them.
+
+Usage:
+    python generate_scenes.py \\
+      --specs-dir agentspecs/agentspecs/scenes \\
+      --python-output agent_runtimes/specs/scenes.py \\
+      --typescript-output src/specs/scenes.ts
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from agentspecs_clone import import_from_clone
+from versioning import ensure_spec_version, version_suffix
+
+#: The keys of a scene spec, as TypeScript spells them.
+CAMEL = {
+    "runs_in": "runsIn",
+    "talks_to": "talksTo",
+    "opens_first": "opensFirst",
+    "rests_after": "restsAfter",
+    "ceiling_per_ask": "ceilingPerAsk",
+    "asks_a_day": "asksADay",
+    "must_say": "mustSay",
+    "must_not_say": "mustNotSay",
+}
+
+#: The lists written only when they hold something: TypeScript reads them as optional.
+OPTIONAL_LISTS = (
+    "talks_to",
+    "frames",
+    "contents",
+    "branch",
+    "withhold",
+    "must_say",
+    "must_not_say",
+)
+
+
+def _flat(text: Any) -> str:
+    """A text on one line."""
+    return " ".join(str(text or "").split())
+
+
+def _trim(value: Any, key: str = "") -> Any:
+    """A value without the empty optional lists and the keys that hold nothing."""
+    if isinstance(value, dict):
+        trimmed = {}
+        for name, item in value.items():
+            if item is None or (name in OPTIONAL_LISTS and item == []):
+                continue
+            trimmed[name] = _trim(item, name)
+        return trimmed
+    if isinstance(value, list):
+        return [_trim(item) for item in value]
+    return value
+
+
+def load_specs(specs_dir: Path) -> list[dict[str, Any]]:
+    """Every scene, validated, as plain data: its cast resolved, its entry said."""
+    scenes_module = import_from_clone(specs_dir, "scenes")
+    scenes = scenes_module.load_scenes(specs_dir)
+    specs: list[dict[str, Any]] = []
+    for identity in sorted(scenes):
+        scene = scenes[identity]
+        spec = scene.model_dump(mode="json", by_alias=True)
+        spec["entry"] = scene.entry_of()
+        spec["cast"] = [
+            member.model_dump(mode="json", by_alias=True) for member in scene.cast_of()
+        ]
+        for beat, data in zip(scene.script, spec["script"]):
+            data["shows"] = [kind.value for kind in beat.shown]
+        spec["setup"] = scenes_module.scene_setup(scene)
+        for key in ("description",):
+            spec[key] = _flat(spec.get(key))
+        spec["setting"]["assumes"] = _flat(spec["setting"].get("assumes"))
+        for member in spec["cast"]:
+            member["brief"] = _flat(member.get("brief"))
+        for beat in spec["script"]:
+            beat["expect"] = _flat(beat.get("expect"))
+            for branch in beat.get("branch") or []:
+                branch["expect"] = _flat(branch.get("expect"))
+        ensure_spec_version(spec)
+        specs.append(_trim(spec))
+    return specs
+
+
+def _const_name(spec: dict[str, Any]) -> str:
+    """`sales-and-accounting` 0.0.1 → `SALES_AND_ACCOUNTING_SCENE_0_0_1`."""
+    base = spec["id"].upper().replace("-", "_").replace(".", "_")
+    return f"{base}_SCENE" + version_suffix(spec["version"])
+
+
+def _typescript_value(value: Any) -> Any:
+    """A scene as the TypeScript interfaces read it."""
+    if isinstance(value, dict):
+        return {
+            CAMEL.get(key, key): _typescript_value(item) for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [_typescript_value(item) for item in value]
+    return value
+
+
+HEADER = [
+    "This file is AUTO-GENERATED from YAML specifications.",
+    "DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+]
+
+ABOUT = [
+    "Scene Catalog.",
+    "",
+    "A team, staged: the setting, the script, the stage directions, the",
+    "audience, the rehearsal and where it plays. The cast is resolved.",
+]
+
+
+def generate_python_code(specs: list[dict[str, Any]]) -> str:
+    """Generate the Python scene catalogue."""
+    lines = [
+        "# Copyright (c) 2025-2026 Datalayer, Inc.",
+        "# Distributed under the terms of the Modified BSD License.",
+        '"""',
+        *ABOUT,
+        "",
+        *HEADER,
+        '"""',
+        "",
+        "from typing import Dict",
+        "",
+        "from agent_runtimes.types import SceneSpec",
+        "",
+        "# " + "=" * 76,
+        "# Scene Definitions",
+        "# " + "=" * 76,
+        "",
+    ]
+    for spec in specs:
+        lines.extend(
+            [
+                f"{_const_name(spec)} = SceneSpec.model_validate(",
+                f"    {spec!r}",
+                ")",
+                "",
+            ]
+        )
+    lines.extend(
+        [
+            "",
+            "# " + "=" * 76,
+            "# Scene Catalog",
+            "# " + "=" * 76,
+            "",
+            "SCENE_CATALOGUE: Dict[str, SceneSpec] = {",
+        ]
+    )
+    for spec in specs:
+        lines.append(f"    {spec['id']!r}: {_const_name(spec)},")
+    lines.extend(
+        [
+            "}",
+            "",
+            "",
+            "def get_scene_spec(scene_id: str) -> SceneSpec | None:",
+            '    """A scene, by `id` or `id:version`, or None."""',
+            "    found = SCENE_CATALOGUE.get(scene_id)",
+            "    if found is not None:",
+            "        return found",
+            '    base, _, version = scene_id.rpartition(":")',
+            '    return SCENE_CATALOGUE.get(base) if base and "." in version else None',
+            "",
+            "",
+            "def list_scene_specs(tag: str | None = None) -> list[SceneSpec]:",
+            '    """Every scene of the catalogue, or those carrying a tag."""',
+            "    return [",
+            "        scene for scene in SCENE_CATALOGUE.values() if tag is None or tag in scene.tags",
+            "    ]",
+            "",
+            "",
+            "def scenes_staging(team_id: str) -> list[SceneSpec]:",
+            '    """Every scene that stages a team, by its id with or without a version."""',
+            '    wanted = team_id.split(":")[0]',
+            "    return [",
+            "        scene",
+            "        for scene in SCENE_CATALOGUE.values()",
+            '        if scene.team and scene.team.split(":")[0] == wanted',
+            "    ]",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
+    """Generate the TypeScript scene catalogue."""
+    lines = [
+        "/*",
+        " * Copyright (c) 2025-2026 Datalayer, Inc.",
+        " * Distributed under the terms of the Modified BSD License.",
+        " */",
+        "",
+        "/**",
+        *[f" * {line}".rstrip() for line in ABOUT],
+        " *",
+        *[f" * {line}" for line in HEADER],
+        " */",
+        "",
+        "import type { SceneSpec } from '../types/scenes';",
+        "",
+    ]
+    for spec in specs:
+        body = json.dumps(_typescript_value(spec), indent=2, ensure_ascii=False)
+        lines.extend([f"export const {_const_name(spec)}: SceneSpec = {body};", ""])
+    lines.append("export const SCENE_CATALOGUE: Record<string, SceneSpec> = {")
+    for spec in specs:
+        lines.append(f"  {json.dumps(spec['id'])}: {_const_name(spec)},")
+    lines.extend(
+        [
+            "};",
+            "",
+            "/** A scene, by `id` or `id:version`, or undefined. */",
+            "export function getSceneSpec(ref: string): SceneSpec | undefined {",
+            "  // Own entries only: `constructor` and `toString` are not scenes.",
+            "  const own = (id: string): SceneSpec | undefined =>",
+            "    Object.prototype.hasOwnProperty.call(SCENE_CATALOGUE, id)",
+            "      ? SCENE_CATALOGUE[id]",
+            "      : undefined;",
+            "  const at = ref.lastIndexOf(':');",
+            "  return (",
+            "    own(ref) ??",
+            "    (at > 0 && ref.slice(at + 1).includes('.')",
+            "      ? own(ref.slice(0, at))",
+            "      : undefined)",
+            "  );",
+            "}",
+            "",
+            "/** Every scene of the catalogue, in the catalogue's order, or those carrying a tag. */",
+            "export function listSceneSpecs(tag?: string): SceneSpec[] {",
+            "  return Object.values(SCENE_CATALOGUE).filter(",
+            "    scene => tag === undefined || scene.tags.includes(tag),",
+            "  );",
+            "}",
+            "",
+            "/** Every scene that stages a team, by its id with or without a version. */",
+            "export function scenesStaging(teamId: string): SceneSpec[] {",
+            "  const wanted = teamId.split(':')[0];",
+            "  return Object.values(SCENE_CATALOGUE).filter(",
+            "    scene => scene.team !== '' && scene.team.split(':')[0] === wanted,",
+            "  );",
+            "}",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def main() -> None:
+    """Generate the scene catalogue."""
+    parser = argparse.ArgumentParser(
+        description="Generate Python and TypeScript code from YAML scene specifications"
+    )
+    parser.add_argument("--specs-dir", type=Path, required=True)
+    parser.add_argument("--python-output", type=Path, required=True)
+    parser.add_argument("--typescript-output", type=Path, required=True)
+    args = parser.parse_args()
+
+    if not args.specs_dir.exists():
+        print(f"Error: Specs directory not found: {args.specs_dir}", file=sys.stderr)
+        sys.exit(1)
+    specs = load_specs(args.specs_dir)
+    for path, text in (
+        (args.python_output, generate_python_code(specs)),
+        (args.typescript_output, generate_typescript_code(specs)),
+    ):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+        print(f"Generated: {path}")
+    print(f"\n✓ Successfully generated code from {len(specs)} scene specs")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/codegen/generate_teams.py

@@ -151,6 +151,8 @@ def _generate_team_agent_py(agent: Dict[str, Any]) -> str:
     # emitted only when said, as a team of agents says none of them.
     if agent.get("app"):
         lines.append(f'            app="{agent["app"]}",')
+    if agent.get("server"):
+        lines.append(f'            server="{agent["server"]}",')
     if agent.get("runs_in"):
         lines.append(f'            runs_in="{agent["runs_in"]}",')
     links = agent.get("talks_to") or []
@@ -220,6 +222,7 @@ def _generate_team_agent_ts(agent: Dict[str, Any]) -> str:
     links = agent.get("talks_to") or []
     application = (
         (f"\n      app: '{agent['app']}'," if agent.get("app") else "")
+        + (f"\n      server: '{agent['server']}'," if agent.get("server") else "")
         + (f"\n      runsIn: '{agent['runs_in']}'," if agent.get("runs_in") else "")
         + (
             "\n      talksTo: ["
@@ -484,10 +487,14 @@ from agent_runtimes.types import (
             # `shared` by default: routing only makes sense if the member
             # receiving the work can see what was already said.
             context = spec.get("context") or {}
+            # The Frames of its shared context (LOOP A-04): written only when
+            # it names some, as the parser reads it.
+            frames = context.get("frames") or []
             code += (
                 "    context=TeamContextSpec("
                 f'sharing="{context.get("sharing", "shared")}"'
-                "),\n"
+                + (f", frames={_fmt_list(frames)}" if frames else "")
+                + "),\n"
             )
             code += f"    validation={validation_code},\n"
             code += f"    agents={agents_code},\n"
@@ -778,7 +785,13 @@ import type {{ TeamSpec }} from '{types_import_path}';
                 " },\n"
             )
             context = spec.get("context") or {}
-            code += f"  context: {{ sharing: '{context.get('sharing', 'shared')}' }},\n"
+            frames = context.get("frames") or []
+            frames_ts = (
+                ", frames: [" + ", ".join(f"'{frame}'" for frame in frames) + "]"
+                if frames
+                else ""
+            )
+            code += f"  context: {{ sharing: '{context.get('sharing', 'shared')}'{frames_ts} }},\n"
             code += f"  validation: {validation_ts},\n"
             code += f"  agents: {agents_ts},\n"
             if rr_ts is not None:

package/lib/components/inspector/JsonTree.d.ts

@@ -1,24 +0,0 @@
-/**
- * A JSON value as a tree: objects and arrays fold and unfold, each value
- * coloured by its type (theme colours, light and dark), long strings cut
- * until asked for whole, and the whole value copied as JSON.
- *
- * @module components/inspector/JsonTree
- */
-import type { JSX } from 'react';
-export type JsonTreeProps = {
-    value: unknown;
-    /** The root's name, shown as its key. */
-    name?: string;
-    /** How many levels open at first. */
-    expandDepth?: number;
-    /** Offer *Copy JSON* above the tree. */
-    copyable?: boolean;
-    /** Longer strings are cut until clicked. */
-    stringLimit?: number;
-};
-/** A value's type, as the tree colours it. */
-export declare function jsonType(value: unknown): 'string' | 'number' | 'boolean' | 'null' | 'array' | 'object' | 'undefined';
-/** A JSON value, as a tree. */
-export declare function JsonTree({ value, name, expandDepth, copyable, stringLimit, }: JsonTreeProps): JSX.Element;
-export default JsonTree;

package/lib/components/inspector/JsonTree.js

@@ -1,89 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Button, Text } from '@primer/react';
-import { Box } from '@datalayer/primer-addons';
-import { CopyIcon, CheckIcon } from '@primer/octicons-react';
-const MONO = 'ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace';
-/** A value's type, as the tree colours it. */
-export function jsonType(value) {
-    if (value === null) {
-        return 'null';
-    }
-    if (Array.isArray(value)) {
-        return 'array';
-    }
-    const type = typeof value;
-    if (type === 'string' || type === 'number' || type === 'boolean') {
-        return type;
-    }
-    if (type === 'bigint') {
-        return 'number';
-    }
-    return type === 'undefined' ? 'undefined' : 'object';
-}
-const COLOURS = {
-    string: 'success.fg',
-    number: 'accent.fg',
-    boolean: 'done.fg',
-    null: 'fg.muted',
-    undefined: 'fg.muted',
-};
-function Leaf({ value, stringLimit, }) {
-    const type = jsonType(value);
-    const [whole, setWhole] = useState(false);
-    if (type === 'string') {
-        const text = value;
-        const cut = !whole && text.length > stringLimit;
-        return (_jsxs(Text, { "data-json-type": "string", sx: {
-                color: COLOURS.string,
-                whiteSpace: 'pre-wrap',
-                wordBreak: 'break-word',
-            }, children: [JSON.stringify(cut ? text.slice(0, stringLimit) : text), cut && (_jsxs(Box, { as: "button", type: "button", onClick: () => setWhole(true), sx: {
-                        ml: 1,
-                        p: 0,
-                        border: 0,
-                        bg: 'transparent',
-                        color: 'accent.fg',
-                        cursor: 'pointer',
-                        font: 'inherit',
-                    }, children: ["\u2026 ", text.length - stringLimit, " more"] }))] }));
-    }
-    return (_jsx(Text, { "data-json-type": type, sx: { color: COLOURS[type] ?? 'fg.default' }, children: type === 'undefined' ? 'undefined' : String(value) }));
-}
-function Node({ name, value, depth, expandDepth, stringLimit, }) {
-    const type = jsonType(value);
-    const branch = type === 'array' || type === 'object';
-    const [open, setOpen] = useState(depth < expandDepth);
-    const key = name !== undefined ? (_jsxs(Text, { sx: { color: 'fg.default', fontWeight: 600 }, children: [name, ": "] })) : null;
-    if (!branch) {
-        return (_jsxs(Box, { role: "treeitem", "data-json-node": "", sx: { pl: 3 }, children: [key, _jsx(Leaf, { value: value, stringLimit: stringLimit })] }));
-    }
-    const items = type === 'array'
-        ? value.map((item, index) => [String(index), item])
-        : Object.entries(value);
-    const [openMark, closeMark] = type === 'array' ? ['[', ']'] : ['{', '}'];
-    return (_jsxs(Box, { role: "treeitem", "aria-expanded": open, "data-json-node": "", sx: { pl: depth ? 3 : 0 }, children: [_jsxs(Box, { as: "button", type: "button", onClick: () => setOpen(!open), "aria-label": `${open ? 'Fold' : 'Unfold'} ${name ?? 'the value'}`, "data-json-toggle": "", sx: {
-                    p: 0,
-                    border: 0,
-                    bg: 'transparent',
-                    color: 'inherit',
-                    font: 'inherit',
-                    cursor: 'pointer',
-                    textAlign: 'left',
-                }, children: [_jsx(Text, { sx: { color: 'fg.muted', display: 'inline-block', width: '1em' }, children: open ? '▾' : '▸' }), key, _jsx(Text, { sx: { color: 'fg.muted' }, children: open
-                            ? openMark
-                            : `${openMark} ${items.length} ${type === 'array' ? (items.length === 1 ? 'item' : 'items') : items.length === 1 ? 'key' : 'keys'} ${closeMark}` })] }), open && (_jsxs(Box, { role: "group", children: [items.map(([itemName, item]) => (_jsx(Node, { name: itemName, value: item, depth: depth + 1, expandDepth: expandDepth, stringLimit: stringLimit }, itemName))), _jsx(Text, { sx: { color: 'fg.muted', pl: 3 }, children: closeMark })] }))] }));
-}
-/** A JSON value, as a tree. */
-export function JsonTree({ value, name, expandDepth = 1, copyable = true, stringLimit = 240, }) {
-    const [copied, setCopied] = useState(false);
-    const copy = () => {
-        const text = JSON.stringify(value, null, 2) ?? 'undefined';
-        void navigator.clipboard?.writeText(text).then(() => {
-            setCopied(true);
-            setTimeout(() => setCopied(false), 1500);
-        }, () => undefined);
-    };
-    return (_jsxs(Box, { "data-json-tree": "", sx: { fontFamily: MONO, fontSize: 0, lineHeight: 1.6, minWidth: 0 }, children: [copyable && (_jsx(Button, { size: "small", variant: "invisible", leadingVisual: copied ? CheckIcon : CopyIcon, onClick: copy, "data-json-copy": "", sx: { float: 'right' }, children: copied ? 'Copied' : 'Copy JSON' })), _jsx(Box, { role: "tree", "aria-label": name ?? 'JSON', children: _jsx(Node, { name: name, value: value, depth: 0, expandDepth: expandDepth, stringLimit: stringLimit }) })] }));
-}
-export default JsonTree;

package/lib/components/inspector/a2aInspect.d.ts

@@ -1,56 +0,0 @@
-/**
- * The A2A traffic between two agents, as the Agent Inspector records it: a
- * fetch that hands every request on and records what went (the JSON-RPC
- * request: its method, its message) and what came back — a JSON-RPC
- * response, or each server-sent event of a stream (the task, its status
- * updates, its artifact updates, a message) — with its task, context and
- * state, whole.
- *
- * It sits under the A2A SDK (`ClientFactory`'s `JsonRpcTransportFactory`
- * takes a `fetchImpl`): the SDK reads the response it is handed, and the
- * inspector reads a copy of its body. Nothing it records changes what the
- * SDK sees, and a key sent as a header is never recorded.
- *
- * A peer served by agent-runtimes tells each tool call of its agent on a
- * `working` status (`{tool_call}`, then `{tool_result}`): each call is
- * recorded besides as one entry of its own, the peer's, from its start to
- * its end, linked to the two statuses — an MCP call, a skill, or a tool its
- * runtime runs, by who claims its name. The text chunks of one artifact are
- * one entry, their count kept.
- *
- * {@link linkA2APeerEvent} attaches what the asker made of an event (an
- * `A2APeerEvent`) to the entry it came from.
- *
- * @module components/inspector/a2aInspect
- */
-import type { A2APeerEvent } from '../../runtimes/browser/a2aPeer';
-import { type AgentInspectorEntry, type AgentInspectorSink, type ToolClass } from './agentInspector';
-export type A2AInspectOptions = {
-    sink: AgentInspectorSink;
-    /** The agent that asks: `Sales`. */
-    asker: string;
-    /** The agent asked: `Accounting`. */
-    peer: string;
-    /**
-     * Where a peer's tool call comes from — an MCP server's, a skill, … — and
-     * its mark (`classifyToolCall`, or a team's `teamToolClassifier`).
-     * Without it, a tool the peer's runtime runs (`backend-tool`).
-     */
-    classifyTool?: (name: string, args?: Record<string, unknown>) => ToolClass;
-};
-/** The text of an A2A 1.0 message's or artifact's parts, as JSON carries them. */
-export declare function partsText(parts: unknown): string;
-/** `TASK_STATE_WORKING` is `working`. */
-export declare function stateWord(state: unknown): string;
-/**
- * A fetch that records the A2A traffic it carries into `options.sink`, and
- * hands the SDK what the network gave.
- */
-export declare function inspectA2AFetch(base: typeof globalThis.fetch, options: A2AInspectOptions): typeof globalThis.fetch;
-/**
- * The linker the A2A capture adds to its sink: an `A2APeerEvent` noted
- * (`sink.note`) is attached to the entry it came from.
- */
-export declare function a2aEventLinker(event: unknown): ((entry: AgentInspectorEntry) => boolean) | undefined;
-/** Attach what the asker made of an event to the A2A entry it came from. */
-export declare function linkA2APeerEvent(sink: AgentInspectorSink, event: A2APeerEvent): void;