@datalayer/agent-runtimes 1.3.114 → 1.4.0

package/lib/types/messages.d.ts

@@ -4,6 +4,7 @@
  *
  * @module types/messages
  */
+import type { Display } from '@datalayer/reactor/ui';
 /**
  * Message role enumeration
  */
@@ -121,6 +122,12 @@ export interface ChatMessage {
     note?: 'waiting' | 'failed' | 'stopped';
     /** Optional metadata */
     metadata?: Record<string, unknown>;
+    /**
+     * What the message shows besides its words: the displays sent under it
+     * (`reactor.ui`, REACTOR_UI RU-2), in the order they came; each drawn by
+     * the renderer a plugin contributed for its type.
+     */
+    displays?: Display[];
     /** Tool calls for assistant messages */
     toolCalls?: ToolCallContentPart[];
     /** For activity messages (A2A, A2UI, etc.) */

package/lib/types/protocol.d.ts

@@ -44,6 +44,14 @@ export interface ProtocolConfig {
     enableConfigQuery?: boolean;
     /** Config endpoint URL for non-Jupyter protocols (if not set, uses Jupyter requestAPI) */
     configEndpoint?: string;
+    /**
+     * The ui channel's WebSocket (`ws://` or `wss://`, REACTOR_UI RU-W): an
+     * application's session says on it what its messages show, its steps, its
+     * elements, its authors and its window messages, and takes the presses of
+     * what they offered. Set for an application's agent; one connection per
+     * conversation, its thread the scope.
+     */
+    uiSocket?: string;
     /** Additional protocol options */
     options?: Record<string, unknown>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.114",
+    "version": "1.4.0",
     "type": "module",
     "workspaces": [
         ".",
@@ -161,7 +161,7 @@
         "@datalayer/primer-addons": "^1.0.39",
         "@datalayer/primer-rjsf": "^1.0.3",
         "@datalayer/personal-agent-protocol": "^0.6.0",
-        "@datalayer/reactor": "^1.0.4",
+        "@datalayer/reactor": "^1.2.0",
         "@datalayer/reactor-commands": "^1.0.4",
         "@datalayer/reactor-manager": "^1.0.4",
         "@datalayer/reactor-shell": "^1.0.4",

package/scripts/codegen/generate_agents.py

@@ -235,7 +235,10 @@ def load_fragments(specs_dir: Path) -> List[Dict[str, Any]]:
 
 
 def refuse_tools_field(spec: Dict[str, Any], path: Path) -> None:
-    """Refuse an agent spec that still says `tools`: it is `backend_tools` now."""
+    """Refuse an agent spec that still says `tools` (it is `backend_tools` now) or
+    `ui_plugin` (it is `ui` now, AGENT_PROTOCOLS PS-03)."""
+    if "ui_plugin" in spec:
+        raise SystemExit(f"Error: {path} says `ui_plugin`: the field is `ui`, one of agentspecs/ui")
     if "tools" in spec:
         raise SystemExit(
             f"Error: {path} says `tools`: the field is `backend_tools` — the tools "
@@ -288,9 +291,37 @@ def load_yaml_specs(specs_dir: Path) -> List[tuple[str, Dict[str, Any]]]:
         resolved.append((subfolder, spec))
 
     check_model_additionals(resolved, load_model_ids(specs_dir))
+    check_protocols(resolved, load_protocol_ids(specs_dir))
     return resolved
 
 
+def load_protocol_ids(specs_dir: Path) -> set[str]:
+    """Every id of the protocols catalogue (`agentspecs/protocols`, AGENT_PROTOCOLS PS-01)."""
+    ids: set[str] = set()
+    for yaml_file in sorted((specs_dir.parent / "protocols").glob("*.yaml")):
+        protocol = yaml.safe_load(yaml_file.read_text()) or {}
+        if protocol.get("id"):
+            ids.add(str(protocol["id"]))
+    return ids
+
+
+def check_protocols(specs: List[tuple[str, Dict[str, Any]]], protocol_ids: set[str]) -> None:
+    """Refuse an agent whose `protocols` is not a list of the catalogue's ids, each once (PS-02)."""
+    problems = []
+    for _, spec in specs:
+        said = spec.get("protocols")
+        if said is None:
+            continue
+        if not isinstance(said, list) or len(set(map(str, said))) != len(said):
+            problems.append(f"{spec.get('id')}: protocols is a list of protocol ids, each once")
+            continue
+        unknown = [str(p) for p in said if str(p) not in protocol_ids]
+        if unknown:
+            problems.append(f"{spec.get('id')}: protocols names what the catalogue does not know: {', '.join(unknown)}")
+    if problems:
+        raise SystemExit("\n".join(problems))
+
+
 def load_model_ids(specs_dir: Path) -> set[str]:
     """Every id the models catalogue answers to: its ids and their aliases."""
     ids: set[str] = set()
@@ -508,8 +539,8 @@ from agent_runtimes.types import (
             protocol_val = spec.get("protocol")
             protocol_str = f'"{protocol_val}"' if protocol_val else "None"
             delegable_str = _fmt_py_delegable(spec.get("delegable", []))
-            ui_plugin = spec.get("ui_plugin")
-            ui_plugin_str = f'"{ui_plugin}"' if ui_plugin else "None"
+            ui_id = spec.get("ui")
+            ui_str = f'"{ui_id}"' if ui_id else "None"
             trigger_val = spec.get("trigger")
             model_cfg = spec.get("model_config")
             mcp_srv_tools = spec.get("mcp_server_tools")
@@ -620,7 +651,8 @@ from agent_runtimes.types import (
     goal={goal_str},
     delegable={delegable_str},
     protocol={protocol_str},
-    ui_plugin={ui_plugin_str},
+    ui={ui_str},
+    protocols={_fmt_list([str(p) for p in spec.get("protocols") or []])},
     trigger={_fmt_py_literal(trigger_val)},
     model_configuration={_fmt_py_literal(model_cfg)},
     mcp_server_tools={_fmt_py_literal(mcp_srv_tools)},
@@ -1135,8 +1167,8 @@ const FRONTEND_TOOL_MAP: Record<string, any> = {
             protocol_val = spec.get("protocol")
             protocol_ts = f"'{protocol_val}'" if protocol_val else "undefined"
             delegable_ts = _fmt_ts_delegable(spec.get("delegable", []))
-            ui_plugin = spec.get("ui_plugin")
-            ui_plugin_ts = f"'{ui_plugin}'" if ui_plugin else "undefined"
+            ui_id = spec.get("ui")
+            ui_ts = f"'{ui_id}'" if ui_id else "undefined"
             trigger_val = spec.get("trigger")
             model_cfg = spec.get("model_config")
             mcp_srv_tools = spec.get("mcp_server_tools")
@@ -1195,7 +1227,8 @@ const FRONTEND_TOOL_MAP: Record<string, any> = {
     goal: {goal_ts},
     delegable: {delegable_ts},
     protocol: {protocol_ts},
-    uiPlugin: {ui_plugin_ts},
+    ui: {ui_ts},
+    protocols: {_fmt_ts_literal([str(p) for p in spec.get("protocols") or []])},
     trigger: {_fmt_ts_literal(trigger_val)},
     modelConfig: {_fmt_ts_literal(model_cfg)},
     mcpServerTools: {_fmt_ts_literal(mcp_srv_tools)},
@@ -1635,11 +1668,13 @@ export * from './memory';
 export * from './models';
 export * from './modelProviders';
 export * from './notifications';
+export * from './voices';
 export * from './outputs';
 export * from './skills';
 export * from './backendTools';
 export * from './triggers';
-export * from './uiPlugins';
+export * from './ui';
+export * from './protocols';
 export * from './frames';
 export * from './cogs';
 export * from './guards';

package/scripts/codegen/generate_protocols.py

@@ -0,0 +1,207 @@
+#!/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 the YAML protocol specifications.
+
+One YAML per agent protocol under ``agentspecs/protocols`` (AGENT_PROTOCOLS
+PS-01); an agent spec's or an application's ``protocols`` names the ones it
+speaks (PS-02).
+
+Usage:
+    python generate_protocols.py \\
+      --specs-dir agentspecs/agentspecs/protocols \\
+      --python-output agent_runtimes/specs/protocols.py \\
+      --typescript-output src/specs/protocols.ts
+"""
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+from versioning import ensure_spec_version, version_suffix
+
+LAYERS = ("transport", "consent", "identity", "commerce", "ui")
+STATUSES = ("shipped", "planned")
+BLOCKS = ("pap", "pact", "a2a")
+
+
+def load_protocol_specs(specs_dir: Path) -> list[dict[str, Any]]:
+    """Every protocol spec of a directory, each named for its id, its layer, status and block known."""
+    specs = []
+    for yaml_file in sorted(specs_dir.glob("*.yaml")):
+        spec = yaml.safe_load(yaml_file.read_text()) or {}
+        ensure_spec_version(spec)
+        if spec["id"] != yaml_file.stem:
+            raise ValueError(
+                f"{yaml_file.name}: the file is named for {yaml_file.stem!r}, the spec says {spec['id']!r}"
+            )
+        if spec["layer"] not in LAYERS or spec["status"] not in STATUSES:
+            raise ValueError(
+                f"{yaml_file.name}: layer one of {LAYERS}, status one of {STATUSES}"
+            )
+        if spec.get("appspec_block") not in (None, *BLOCKS):
+            raise ValueError(f"{yaml_file.name}: appspec_block one of {BLOCKS}")
+        specs.append(spec)
+    return specs
+
+
+def _const(spec: dict[str, Any]) -> str:
+    return (
+        spec["id"].replace("-", "_").upper()
+        + "_PROTOCOL"
+        + version_suffix(spec["version"])
+    )
+
+
+def _s(value: Any) -> str:
+    return json.dumps(" ".join(str(value or "").split()), ensure_ascii=False)
+
+
+def generate_python_code(specs: list[dict[str, Any]]) -> str:
+    lines = [
+        "# Copyright (c) 2025-2026 Datalayer, Inc.",
+        "# Distributed under the terms of the Modified BSD License.",
+        '"""',
+        "Protocol Catalog.",
+        "",
+        "The agent protocols Datalayer targets (AGENT_PROTOCOLS PS-01).",
+        "",
+        "This file is AUTO-GENERATED from YAML specifications.",
+        "DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+        '"""',
+        "",
+        "from typing import Dict, List, Optional",
+        "",
+        "from agent_runtimes.types import ProtocolPackagesSpec, ProtocolSpec",
+    ]
+    for spec in specs:
+        packages = spec.get("packages") or {}
+        block = spec.get("appspec_block")
+        lines += [
+            "",
+            f"{_const(spec)} = ProtocolSpec(",
+            f"    id={_s(spec['id'])},",
+            f"    version={_s(spec['version'])},",
+            f"    name={_s(spec['name'])},",
+            f"    description={_s(spec.get('description'))},",
+            f"    publisher={_s(spec.get('publisher'))},",
+            f"    layer={_s(spec['layer'])},",
+            f"    spec_url={_s(spec.get('spec_url'))},",
+            f"    spec_version={_s(spec.get('spec_version'))},",
+            f"    status={_s(spec['status'])},",
+            f"    connects={_s(spec.get('connects'))},",
+            "    packages=ProtocolPackagesSpec(",
+            f"        python={json.dumps(list(packages.get('python') or []))},",
+            f"        typescript={json.dumps(list(packages.get('typescript') or []))},",
+            "    ),",
+            f"    protocol_tools={json.dumps(list(spec.get('protocol_tools') or []))},",
+            f"    appspec_block={_s(block) if block else 'None'},",
+            ")",
+        ]
+    lines += [
+        "",
+        "",
+        "PROTOCOL_CATALOGUE: Dict[str, ProtocolSpec] = {",
+        *[f"    {_s(spec['id'])}: {_const(spec)}," for spec in specs],
+        "}",
+        "",
+        "",
+        "def get_protocol(protocol_id: str) -> Optional[ProtocolSpec]:",
+        '    """A protocol by id, or None."""',
+        "    return PROTOCOL_CATALOGUE.get(protocol_id)",
+        "",
+        "",
+        "def list_protocols() -> List[ProtocolSpec]:",
+        '    """Every protocol of the catalogue."""',
+        "    return list(PROTOCOL_CATALOGUE.values())",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _t(value: Any) -> str:
+    return json.dumps(" ".join(str(value or "").split()), ensure_ascii=False)
+
+
+def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
+    lines = [
+        "/*",
+        " * Copyright (c) 2025-2026 Datalayer, Inc.",
+        " * Distributed under the terms of the Modified BSD License.",
+        " */",
+        "",
+        "/**",
+        " * Protocol Catalog.",
+        " *",
+        " * The agent protocols Datalayer targets (AGENT_PROTOCOLS PS-01).",
+        " *",
+        " * This file is AUTO-GENERATED from YAML specifications.",
+        " * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+        " */",
+        "",
+        "import type { ProtocolSpec } from '../types/agentspecs';",
+    ]
+    for spec in specs:
+        packages = spec.get("packages") or {}
+        block = spec.get("appspec_block")
+        lines += [
+            "",
+            f"export const {_const(spec)}: ProtocolSpec = {{",
+            f"  id: {_t(spec['id'])},",
+            f"  version: {_t(spec['version'])},",
+            f"  name: {_t(spec['name'])},",
+            f"  description: {_t(spec.get('description'))},",
+            f"  publisher: {_t(spec.get('publisher'))},",
+            f"  layer: {_t(spec['layer'])},",
+            f"  specUrl: {_t(spec.get('spec_url'))},",
+            f"  specVersion: {_t(spec.get('spec_version'))},",
+            f"  status: {_t(spec['status'])},",
+            f"  connects: {_t(spec.get('connects'))},",
+            "  packages: {",
+            f"    python: {json.dumps(list(packages.get('python') or []))},",
+            f"    typescript: {json.dumps(list(packages.get('typescript') or []))},",
+            "  },",
+            f"  protocolTools: {json.dumps(list(spec.get('protocol_tools') or []))},",
+            *([f"  appspecBlock: {_t(block)},"] if block else []),
+            "};",
+        ]
+    lines += [
+        "",
+        "export const PROTOCOL_CATALOGUE: Record<string, ProtocolSpec> = {",
+        *[f"  {_t(spec['id'])}: {_const(spec)}," for spec in specs],
+        "};",
+        "",
+        "/** A protocol by id. */",
+        "export function getProtocol(protocolId: string): ProtocolSpec | undefined {",
+        "  return PROTOCOL_CATALOGUE[protocolId];",
+        "}",
+        "",
+        "/** Every protocol of the catalogue. */",
+        "export function listProtocolSpecs(): ProtocolSpec[] {",
+        "  return Object.values(PROTOCOL_CATALOGUE);",
+        "}",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    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()
+    specs = load_protocol_specs(args.specs_dir)
+    args.python_output.write_text(generate_python_code(specs))
+    args.typescript_output.write_text(generate_typescript_code(specs))
+    print(
+        f"Generated {len(specs)} protocols: {args.python_output}, {args.typescript_output}"
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/codegen/generate_sandbox_agents.py

@@ -84,7 +84,7 @@ mcp_servers: []
 
 skills: []
 
-tools: []
+backend_tools: []
 
 frontend_tools: []
 

package/scripts/codegen/{generate_ui_plugins.py → generate_ui.py}

@@ -3,18 +3,18 @@
 # Distributed under the terms of the Modified BSD License.
 
 """
-Generate Python and TypeScript code from YAML UI-plugin specifications.
+Generate Python and TypeScript code from YAML UI specifications.
 
-A UI plugin is how an agent's answer becomes an interface rather than text —
+A UI spec is how an agent's answer becomes an interface rather than text —
 a protocol the host knows how to render (A2UI, MCP Apps, MCP UI). One YAML per
-plugin under ``agentspecs/ui-plugins``; an agent spec's ``ui_plugin`` names
-one. A plugin hosts the visual components it renders (LOOP C-13).
+plugin under ``agentspecs/ui``; an agent spec's ``ui`` names
+one. A UI spec hosts the visual components it renders (LOOP C-13).
 
 Usage:
-    python generate_ui_plugins.py \\
-      --specs-dir agentspecs/agentspecs/ui-plugins \\
-      --python-output agent_runtimes/specs/ui_plugins.py \\
-      --typescript-output src/specs/uiPlugins.ts
+    python generate_ui.py \\
+      --specs-dir agentspecs/agentspecs/ui \\
+      --python-output agent_runtimes/specs/ui.py \\
+      --typescript-output src/specs/ui.ts
 """
 
 import argparse
@@ -29,7 +29,7 @@ from versioning import ensure_spec_version, version_suffix
 
 
 def load_plugin_specs(specs_dir: Path) -> list[dict[str, Any]]:
-    """Load all UI-plugin YAML specifications from a directory."""
+    """Load all UI YAML specifications from a directory."""
     specs = []
     for yaml_file in sorted(specs_dir.glob("*.yaml")):
         with open(yaml_file) as f:
@@ -44,7 +44,7 @@ def load_plugin_specs(specs_dir: Path) -> list[dict[str, Any]]:
 
 
 def _const_name(plugin_id: str) -> str:
-    return plugin_id.replace("-", "_").replace(".", "_").upper() + "_UI_PLUGIN"
+    return plugin_id.replace("-", "_").replace(".", "_").upper() + "_UI"
 
 
 def _py(value: str) -> str:
@@ -196,12 +196,12 @@ def _py_calls(specs: list[dict[str, Any]]) -> list[str]:
 
 
 def generate_python_code(specs: list[dict[str, Any]]) -> str:
-    """Generate Python code from UI-plugin specifications."""
+    """Generate Python code from UI specifications."""
     lines = [
         "# Copyright (c) 2025-2026 Datalayer, Inc.",
         "# Distributed under the terms of the Modified BSD License.",
         '"""',
-        "UI Plugin Catalog.",
+        "UI Catalog.",
         "",
         "How an agent's answer becomes an interface: the protocols a host renders.",
         "",
@@ -211,10 +211,10 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         "",
         "from typing import Any, Callable, Dict, List, Literal, Mapping, Optional, Union",
         "",
-        "from agent_runtimes.types import ComponentBindingsSpec, ComponentSpec, UIPluginSpec",
+        "from agent_runtimes.types import ComponentBindingsSpec, ComponentSpec, UISpec",
         "",
         "# " + "=" * 76,
-        "# UI Plugin Definitions",
+        "# UI Definitions",
         "# " + "=" * 76,
         "",
     ]
@@ -222,7 +222,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         const = _const_name(spec["id"]) + version_suffix(spec["version"])
         lines.extend(
             [
-                f"{const} = UIPluginSpec(",
+                f"{const} = UISpec(",
                 f"    id={_py(spec['id'])},",
                 f"    version={_py(str(spec['version']))},",
                 f"    name={_py(spec['name'])},",
@@ -241,10 +241,10 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         [
             "",
             "# " + "=" * 76,
-            "# UI Plugin Catalog",
+            "# UI Catalog",
             "# " + "=" * 76,
             "",
-            "UI_PLUGIN_CATALOGUE: Dict[str, UIPluginSpec] = {",
+            "UI_CATALOGUE: Dict[str, UISpec] = {",
         ]
     )
     for spec in specs:
@@ -256,20 +256,20 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "}",
             "",
             "",
-            "def get_ui_plugin(plugin_id: str) -> UIPluginSpec | None:",
-            '    """The plugin an agent spec\'s `ui_plugin` names, or None."""',
-            "    return UI_PLUGIN_CATALOGUE.get(plugin_id)",
+            "def get_ui(plugin_id: str) -> UISpec | None:",
+            '    """The UI an agent spec\'s `ui` names, or None."""',
+            "    return UI_CATALOGUE.get(plugin_id)",
             "",
             "",
-            "def list_ui_plugins() -> list[UIPluginSpec]:",
-            "    return list(UI_PLUGIN_CATALOGUE.values())",
+            "def list_ui() -> list[UISpec]:",
+            "    return list(UI_CATALOGUE.values())",
             "",
             "",
-            "#: The visual components the enabled UI plugins render, by the name a",
+            "#: The visual components the enabled UI specs render, by the name a",
             "#: surface gives them (LOOP C-13).",
             "COMPONENT_CATALOGUE: Dict[str, ComponentSpec] = {",
             "    component.id: component",
-            "    for plugin in UI_PLUGIN_CATALOGUE.values()",
+            "    for plugin in UI_CATALOGUE.values()",
             "    if plugin.enabled",
             "    for component in plugin.components",
             "}",
@@ -290,7 +290,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
 
 
 def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
-    """Generate TypeScript code from UI-plugin specifications."""
+    """Generate TypeScript code from UI specifications."""
     lines = [
         "/*",
         " * Copyright (c) 2025-2026 Datalayer, Inc.",
@@ -298,7 +298,7 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         " */",
         "",
         "/**",
-        " * UI Plugin Catalog.",
+        " * UI Catalog.",
         " *",
         " * How an agent's answer becomes an interface: the protocols a host renders.",
         " *",
@@ -306,14 +306,14 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         " * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
         " */",
         "",
-        "import type { ComponentSpec, UIPluginSpec } from '../types/agentspecs';",
+        "import type { ComponentSpec, UISpec } from '../types/agentspecs';",
         "",
     ]
     for spec in specs:
         const = _const_name(spec["id"]) + version_suffix(spec["version"])
         lines.extend(
             [
-                f"export const {const}: UIPluginSpec = {{",
+                f"export const {const}: UISpec = {{",
                 f"  id: {_ts(spec['id'])},",
                 f"  version: {_ts(str(spec['version']))},",
                 f"  name: {_ts(spec['name'])},",
@@ -326,7 +326,7 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
                 "",
             ]
         )
-    lines.append("export const UI_PLUGIN_CATALOGUE: Record<string, UIPluginSpec> = {")
+    lines.append("export const UI_CATALOGUE: Record<string, UISpec> = {")
     for spec in specs:
         lines.append(
             f"  {_ts(spec['id'])}: {_const_name(spec['id']) + version_suffix(spec['version'])},"
@@ -335,18 +335,18 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         [
             "};",
             "",
-            "/** The plugin an agent spec's `uiPlugin` names, or undefined. */",
-            "export function getUIPlugin(pluginId: string): UIPluginSpec | undefined {",
-            "  return UI_PLUGIN_CATALOGUE[pluginId];",
+            "/** The UI an agent spec's `ui` names, or undefined. */",
+            "export function getUI(pluginId: string): UISpec | undefined {",
+            "  return UI_CATALOGUE[pluginId];",
             "}",
             "",
-            "export function listUIPlugins(): UIPluginSpec[] {",
-            "  return Object.values(UI_PLUGIN_CATALOGUE);",
+            "export function listUI(): UISpec[] {",
+            "  return Object.values(UI_CATALOGUE);",
             "}",
             "",
-            "/** The visual components the enabled UI plugins render, by the name a surface gives them (LOOP C-13). */",
+            "/** The visual components the enabled UI specs render, by the name a surface gives them (LOOP C-13). */",
             "export const COMPONENT_CATALOGUE: Record<string, ComponentSpec> = Object.fromEntries(",
-            "  Object.values(UI_PLUGIN_CATALOGUE)",
+            "  Object.values(UI_CATALOGUE)",
             "    .filter(plugin => plugin.enabled)",
             "    .flatMap(plugin => plugin.components.map(component => [component.id, component])),",
             ");",
@@ -367,13 +367,13 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
 
 def main():
     parser = argparse.ArgumentParser(
-        description="Generate Python and TypeScript code from YAML UI-plugin specifications"
+        description="Generate Python and TypeScript code from YAML UI specifications"
     )
     parser.add_argument(
         "--specs-dir",
         type=Path,
         required=True,
-        help="Directory containing UI-plugin YAML files",
+        help="Directory containing UI YAML files",
     )
     parser.add_argument(
         "--python-output", type=Path, required=True, help="Output path for Python file"
@@ -392,7 +392,7 @@ def main():
     specs = load_plugin_specs(args.specs_dir)
     if not specs:
         print(
-            f"Warning: No UI-plugin specifications found in {args.specs_dir}",
+            f"Warning: No UI specifications found in {args.specs_dir}",
             file=sys.stderr,
         )
         return
@@ -402,7 +402,7 @@ def main():
     args.typescript_output.parent.mkdir(parents=True, exist_ok=True)
     args.typescript_output.write_text(generate_typescript_code(specs))
     print(f"Generated TypeScript code: {args.typescript_output}")
-    print(f"\n✓ Successfully generated code from {len(specs)} UI-plugin specs")
+    print(f"\n✓ Successfully generated code from {len(specs)} UI specs")
 
 
 if __name__ == "__main__":

package/scripts/gen_workers.py

@@ -441,9 +441,9 @@ color: "{color}"
 goal: >-
   {goal}
 
-# Protocols & UI Plugins
+# Protocols & UI
 protocol: vercel-ai
-ui_plugin: a2ui
+ui: a2ui
 
 # Model configuration
 model_config:

package/lib/chat/base/loopMessage.d.ts

@@ -1,37 +0,0 @@
-/**
- * A message of an application's code that changed after it was sent
- * (LOOP P-15).
- *
- * The session API says a message's author, or that it was taken away, with a
- * `CUSTOM` event named `loop.message` — `{id, author}` or `{id, removed: true}`
- * — which the AG-UI adapter hands on as an `activity`. A message whose text
- * changed needs nothing here: it is written again under its id, and the chat
- * draws it in place.
- */
-import type { MessageSpeaker } from '../../types/messages';
-/** The `CUSTOM` event's name. */
-export declare const LOOP_MESSAGE = "loop.message";
-/** What changed about a message already in the conversation. */
-export type LoopMessageChange = {
-    id: string;
-    removed: true;
-} | {
-    id: string;
-    author: string;
-};
-/** The change an activity says, or `null` when it says none. */
-export declare function loopMessageChange(activity: {
-    type: string;
-    data: unknown;
-} | undefined): LoopMessageChange | null;
-/** Who a message is by, as the chat draws a named voice. */
-export declare function speakerOf(author: string): MessageSpeaker;
-/**
- * The conversation with the change made: the message taken away, or given its
- * author. Items that are not that message — tool calls among them — are left
- * as they are.
- */
-export declare function withLoopMessage<T extends {
-    id?: string;
-    speaker?: MessageSpeaker;
-}>(items: T[], change: LoopMessageChange): T[];