@datalayer/agent-runtimes 1.3.75 → 1.3.78

package/lib/types/agentspecs.d.ts

@@ -89,10 +89,12 @@ export interface ComponentSpec {
     category: string;
     /** Its face on the palette. */
     emoji: string;
-    /** Its properties are its protocol's own. */
+    /** Its version in the catalog. */
+    version: string;
+    /** Named and drawn as its protocol says (A2UI's basic catalog). */
     standard: boolean;
-    /** Its properties as a JSON Schema, when it is Datalayer's own. */
-    properties?: Record<string, unknown>;
+    /** Its properties as a JSON Schema: what a builder sets (C-13). */
+    properties: Record<string, unknown>;
     /** What it can be bound to: what it shows, what it sends. */
     bindings?: {
         shows: string[];

package/lib/types/chat.d.ts

@@ -153,6 +153,11 @@ export interface ToolCallMessage {
     };
     /** Exit code when code called sys.exit() */
     exitCode?: number | null;
+    /**
+     * What the tool does, in its runtime's own words (`Asking Accounting…`):
+     * shown in place of its arguments' summary.
+     */
+    summary?: string;
 }
 /**
  * Union type for all displayable items in the chat

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.75",
+    "version": "1.3.78",
     "type": "module",
     "workspaces": [
         ".",
@@ -151,7 +151,7 @@
         "@datalayer/decks": "^1.0.4",
         "@datalayer/icons-react": "^1.0.16",
         "@datalayer/jupyter-lexical": "^2.0.18",
-        "@datalayer/jupyter-react": "^2.0.18",
+        "@datalayer/jupyter-react": "^2.0.19",
         "@datalayer/jupyter-server-nbmodel": "^0.2.8",
         "@datalayer/lexical-loro": "^1.0.6",
         "@datalayer/primer-addons": "^1.0.23",

package/scripts/codegen/generate_ui_plugins.py

@@ -19,6 +19,7 @@ Usage:
 
 import argparse
 import json
+import re
 import sys
 from pathlib import Path
 from typing import Any
@@ -62,7 +63,7 @@ def _py_component(component: dict[str, Any]) -> str:
         f"id={_py(component['id'])}, name={json.dumps(component['name'], ensure_ascii=False)}, "
         f"description={json.dumps(component['description'].strip(), ensure_ascii=False)}, "
         f"category={_py(component['category'])}, emoji={json.dumps(component['emoji'], ensure_ascii=False)}, "
-        f"standard={bool(component['standard'])}, "
+        f"version={_py(str(component['version']))}, standard={bool(component['standard'])}, "
         f"properties={component.get('properties')!r}, "
         + (
             f"bindings=ComponentBindingsSpec(shows={bindings['shows']!r}, sends={bindings['sends']!r}), "
@@ -73,6 +74,114 @@ def _py_component(component: dict[str, Any]) -> str:
     )
 
 
+def call_name(component_id: str) -> str:
+    """The Python call of a component: ``Table`` → ``table``, ``TextField`` → ``text_field``."""
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", component_id).lower()
+
+
+def _py_type(prop: dict[str, Any]) -> str:
+    """The Python type of a property of a component's JSON Schema."""
+    if "enum" in prop:
+        return "Literal[" + ", ".join(json.dumps(value) for value in prop["enum"]) + "]"
+    kind = prop.get("type")
+    if kind == "array":
+        return f"List[{_py_type(prop.get('items') or {})}]"
+    return {
+        "string": "str",
+        "integer": "int",
+        "number": "float",
+        "boolean": "bool",
+        "object": "Dict[str, Any]",
+    }.get(str(kind), "Any")
+
+
+def _py_calls(specs: list[dict[str, Any]]) -> list[str]:
+    """The catalog's components as typed calls (LOOP C-15), one method each."""
+    lines = [
+        "",
+        "",
+        "# " + "=" * 76,
+        "# The components as typed calls (LOOP C-15)",
+        "# " + "=" * 76,
+        "",
+        "#: A property bound to what the application publishes or takes: ``{\"path\": \"/runs\"}``.",
+        "Bound = Mapping[str, str]",
+        "",
+        "",
+        "class SurfaceComponents:",
+        '    """Every component of the catalog as a typed call: ``app.ui.table(\"runs\", columns=[...])``.',
+        "",
+        "    Each places the node the Canvas and the YAML write, through",
+        "    `Application.component`, which checks it against the same JSON Schema; an",
+        "    IDE completes its properties, and a type checker refuses a wrong value",
+        "    before the application runs. A property may be bound instead",
+        '    (``{\"path\": ...}``); a property left as ``None`` is not written.',
+        '    """',
+        "",
+        "    def __init__(self, place: Callable[..., Dict[str, Any]]) -> None:",
+        "        self._place = place",
+    ]
+    for spec in specs:
+        if not spec.get("enabled", True):
+            continue
+        for component in spec.get("components") or []:
+            schema = component.get("properties") or {}
+            required = set(schema.get("required") or [])
+            fields = dict(schema.get("properties") or {})
+            bindings = component.get("bindings") or {}
+            extra = [
+                name
+                for name in dict.fromkeys([*(bindings.get("shows") or []), *(bindings.get("sends") or [])])
+                if name not in fields
+            ]
+            params = ["        self,", "        id: str,", "        *,"]
+            ordered = [n for n in fields if n in required] + [n for n in fields if n not in required]
+            for name in ordered:
+                kind = f"Union[{_py_type(fields[name])}, Bound]"
+                params.append(
+                    f"        {name}: {kind}," if name in required else f"        {name}: Optional[{kind}] = None,"
+                )
+            for name in extra:
+                params.append(f"        {name}: Optional[Bound] = None,")
+            if component.get("events") and "action" not in fields:
+                params.append("        action: Optional[Dict[str, Any]] = None,")
+            params.append("        visible_when: Optional[Bound] = None,")
+            params.append("        weight: Optional[float] = None,")
+            doc = [
+                f'        """{component["name"]}, version {component["version"]}: {component["description"].strip()}',
+                "",
+                "        Parameters",
+                "        ----------",
+                "        id : str",
+                "            Its id on the surface, unique; ``root`` is where the surface starts.",
+            ]
+            for name in ordered:
+                field = fields[name]
+                doc += [f"        {name} : {_py_type(field)} or Bound", f"            {field.get('title', name)}: {field.get('description', '')}"]
+            for name in extra:
+                said = "What it shows" if name in (bindings.get("shows") or []) else "Where what a person does is written"
+                doc += [f"        {name} : Bound", f"            {said}."]
+            doc += ['        """']
+            names = [*ordered, *extra]
+            if component.get("events") and "action" not in fields:
+                names.append("action")
+            names += ["visible_when", "weight"]
+            lines += [
+                "",
+                f"    def {call_name(component['id'])}(",
+                *params,
+                "    ) -> Dict[str, Any]:",
+                *[d.replace('\\', '\\\\') for d in doc],
+                "        given = {",
+                *[f"            {json.dumps(name)}: {name}," for name in names],
+                "        }",
+                "        return self._place(",
+                f"            id, {_py(component['id'])}, **{{name: value for name, value in given.items() if value is not None}}",
+                "        )",
+            ]
+    return lines
+
+
 def generate_python_code(specs: list[dict[str, Any]]) -> str:
     """Generate Python code from UI-plugin specifications."""
     lines = [
@@ -87,7 +196,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         "DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
         '"""',
         "",
-        "from typing import Dict",
+        "from typing import Any, Callable, Dict, List, Literal, Mapping, Optional, Union",
         "",
         "from agent_runtimes.types import ComponentBindingsSpec, ComponentSpec, UIPluginSpec",
         "",
@@ -160,6 +269,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "",
             "def list_components() -> list[ComponentSpec]:",
             "    return list(COMPONENT_CATALOGUE.values())",
+            *_py_calls(specs),
             "",
         ]
     )