@datalayer/agent-runtimes 1.0.4 → 1.0.6

package/scripts/codegen/generate_events.py

@@ -43,18 +43,22 @@ def load_specs(specs_dir: Path) -> list[dict[str, Any]]:
 
 
 def _py_field(f: dict[str, Any]) -> str:
-    """Format an EventField as a Python dict literal."""
+    """Format an EventField dict body.
+
+    Returns the lines inside ``EventField(\n    **{\n        ...\n    }\n)``
+    so that the generated output matches ``ruff format`` exactly.
+    """
     parts = [
-        f'"name": "{f["name"]}"',
-        f'"label": "{f["label"]}"',
-        f'"type": "{f["type"]}"',
-        f'"required": {str(f["required"])}',
+        f'                "name": "{f["name"]}"',
+        f'                "label": "{f["label"]}"',
+        f'                "type": "{f["type"]}"',
+        f'                "required": {str(f["required"])}',
     ]
     if "description" in f:
-        parts.append(f'"description": "{_esc_dq(f["description"])}"')
+        parts.append(f'                "description": "{_esc_dq(f["description"])}"')
     if "placeholder" in f:
-        parts.append(f'"placeholder": "{_esc_dq(f["placeholder"])}"')
-    return "{" + ", ".join(parts) + "}"
+        parts.append(f'                "placeholder": "{_esc_dq(f["placeholder"])}"')
+    return ",\n".join(parts)
 
 
 def _ts_field(f: dict[str, Any]) -> str:
@@ -90,7 +94,6 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         "",
         "from agent_runtimes.types import EventField, EventSpec",
         "",
-        "",
         "# " + "=" * 76,
         "# Event Definitions",
         "# " + "=" * 76,
@@ -118,10 +121,18 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             ]
         )
         if fields:
-            field_strs = [_py_field(f) for f in fields]
             lines.append("    fields=[")
-            for fs in field_strs:
-                lines.append(f"        EventField(**{fs}),")
+            for f in fields:
+                field_body = _py_field(f)
+                lines.extend(
+                    [
+                        "        EventField(",
+                        "            **{",
+                        field_body + ",",
+                        "            }",
+                        "        ),",
+                    ]
+                )
             lines.append("    ],")
         lines.extend([")", ""])
 
@@ -149,10 +160,17 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "# Event kind constants for programmatic use",
         ]
     )
+
+    spec_kinds = {spec.get("kind", spec["id"]) for spec in specs}
+
     for spec in specs:
         kind = spec.get("kind", spec["id"])
         const = kind.upper().replace("-", "_")
         lines.append(f'EVENT_KIND_{const} = "{kind}"')
+
+    # Backward-compat constants used by older runtime code paths.
+    if "agent-assigned" not in spec_kinds:
+        lines.append('EVENT_KIND_AGENT_ASSIGNED = "agent-assigned"')
     lines.extend(
         [
             "",
@@ -162,8 +180,8 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "    spec = EVENT_CATALOG.get(event_id)",
             "    if spec is not None:",
             "        return spec",
-            "    base, _, ver = event_id.rpartition(':')",
-            "    if base and '.' in ver:",
+            '    base, _, ver = event_id.rpartition(":")',
+            '    if base and "." in ver:',
             "        return EVENT_CATALOG.get(base)",
             "    return None",
             "",
@@ -233,11 +251,14 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         lines.extend(["};", ""])
 
     # Event kind constants
+    spec_kinds = {spec.get("kind", spec["id"]) for spec in specs}
     lines.append("// Event kind constants for programmatic use")
     for spec in specs:
         kind = spec.get("kind", spec["id"])
         const = kind.upper().replace("-", "_")
         lines.append(f"export const EVENT_KIND_{const} = '{kind}';")
+    if "agent-assigned" not in spec_kinds:
+        lines.append("export const EVENT_KIND_AGENT_ASSIGNED = 'agent-assigned';")
     lines.append("")
 
     lines.extend(

package/scripts/codegen/generate_personas.py

@@ -0,0 +1,319 @@
+#!/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 persona specifications.
+
+Usage:
+    python generate_personas.py \\
+      --specs-dir agentspecs/agentspecs/personas \\
+      --python-output agent_runtimes/specs/personas.py \\
+      --typescript-output src/specs/personas.ts
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+from versioning import ensure_spec_version, version_suffix
+
+
+def _make_const_name(persona_id: str) -> str:
+    """Convert a persona ID to a constant name (e.g., 'tutor' -> 'TUTOR_PERSONA')."""
+    return f"{persona_id.upper().replace('-', '_')}_PERSONA"
+
+
+def _make_enum_name(persona_id: str) -> str:
+    """Convert a persona ID to an enum member name (e.g., 'tutor' -> 'TUTOR')."""
+    return persona_id.upper().replace("-", "_")
+
+
+def _fmt_str_list_py(items: list[str]) -> str:
+    if not items:
+        return "[]"
+    return "[" + ", ".join(f'"{item}"' for item in items) + "]"
+
+
+def _fmt_str_list_ts(items: list[str]) -> str:
+    if not items:
+        return "[]"
+    return "[" + ", ".join(f"'{item}'" for item in items) + "]"
+
+
+def _clean(text: str) -> str:
+    return text.replace("\n", " ").replace("  ", " ").strip()
+
+
+def load_persona_specs(specs_dir: Path) -> list[dict[str, Any]]:
+    """Load all persona YAML specifications from a directory."""
+    specs = []
+    for yaml_file in sorted(specs_dir.glob("*.yaml")):
+        with open(yaml_file) as f:
+            spec = yaml.safe_load(f)
+            ensure_spec_version(spec)
+            specs.append(spec)
+    return specs
+
+
+def generate_python_code(specs: list[dict[str, Any]]) -> str:
+    """Generate Python code from persona specifications."""
+    lines = [
+        "# Copyright (c) 2025-2026 Datalayer, Inc.",
+        "# Distributed under the terms of the Modified BSD License.",
+        '"""',
+        "Persona Catalog.",
+        "",
+        "Predefined Persona configurations built on top of agent specs.",
+        "",
+        "This file is AUTO-GENERATED from YAML specifications.",
+        "DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+        '"""',
+        "",
+        "from enum import Enum",
+        "from typing import Optional",
+        "",
+        "from agent_runtimes.types import PersonaSpec",
+        "",
+        "# " + "=" * 76,
+        "# Personas Enum",
+        "# " + "=" * 76,
+        "",
+        "",
+        "class Personas(str, Enum):",
+        '    """Enumeration of available personas."""',
+        "",
+    ]
+
+    for spec in specs:
+        lines.append(f'    {_make_enum_name(spec["id"])} = "{spec["id"]}"')
+
+    lines.extend(
+        [
+            "",
+            "",
+            "# " + "=" * 76,
+            "# Persona Definitions",
+            "# " + "=" * 76,
+            "",
+        ]
+    )
+
+    for spec in specs:
+        version = spec["version"]
+        const_name = _make_const_name(spec["id"]) + version_suffix(version)
+        description = _clean(spec.get("description", "")).replace('"', '\\"')
+        tags = _fmt_str_list_py(spec.get("tags", []) or [])
+        icon = spec.get("icon")
+        emoji = spec.get("emoji")
+        agent = spec.get("agent")
+
+        body = [
+            f"{const_name} = PersonaSpec(",
+            f'    id="{spec["id"]}",',
+            f'    version="{version}",',
+            f'    name="{spec["name"]}",',
+            f'    description="{description}",',
+            f"    tags={tags},",
+        ]
+        if icon is not None:
+            body.append(f'    icon="{icon}",')
+        if emoji is not None:
+            body.append(f'    emoji="{emoji}",')
+        if agent is not None:
+            body.append(f'    agent="{agent}",')
+        body.append(")")
+        body.append("")
+        lines.extend(body)
+
+    lines.extend(
+        [
+            "",
+            "# " + "=" * 76,
+            "# Persona Catalog",
+            "# " + "=" * 76,
+            "",
+            "PERSONA_CATALOGUE: dict[str, PersonaSpec] = {",
+        ]
+    )
+
+    for spec in specs:
+        const_name = _make_const_name(spec["id"]) + version_suffix(spec["version"])
+        lines.append(f'    "{spec["id"]}": {const_name},')
+
+    lines.extend(
+        [
+            "}",
+            "",
+            "",
+            "def get_persona(persona_id: str) -> Optional[PersonaSpec]:",
+            '    """Get a persona specification by ID (accepts bare or versioned refs)."""',
+            "    persona = PERSONA_CATALOGUE.get(persona_id)",
+            "    if persona is not None:",
+            "        return persona",
+            '    base, _, ver = persona_id.rpartition(":")',
+            '    if base and "." in ver:',
+            "        return PERSONA_CATALOGUE.get(base)",
+            "    return None",
+            "",
+            "",
+            "def list_personas() -> list[PersonaSpec]:",
+            '    """List all available personas."""',
+            "    return list(PERSONA_CATALOGUE.values())",
+            "",
+        ]
+    )
+
+    return "\n".join(lines)
+
+
+def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
+    """Generate TypeScript code from persona specifications."""
+    lines = [
+        "/*",
+        " * Copyright (c) 2025-2026 Datalayer, Inc.",
+        " * Distributed under the terms of the Modified BSD License.",
+        " */",
+        "",
+        "/**",
+        " * Persona Catalog",
+        " *",
+        " * Predefined Persona configurations built on top of agent specs.",
+        " *",
+        " * This file is AUTO-GENERATED from YAML specifications.",
+        " * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
+        " */",
+        "",
+        "import type { PersonaSpec } from '../types';",
+        "",
+        "// " + "=" * 76,
+        "// Personas Enum",
+        "// " + "=" * 76,
+        "",
+        "export const Personas = {",
+    ]
+
+    for spec in specs:
+        lines.append(f"  {_make_enum_name(spec['id'])}: '{spec['id']}',")
+
+    lines.extend(
+        [
+            "} as const;",
+            "",
+            "export type PersonaId = (typeof Personas)[keyof typeof Personas];",
+            "",
+            "// " + "=" * 76,
+            "// Persona Definitions",
+            "// " + "=" * 76,
+            "",
+        ]
+    )
+
+    for spec in specs:
+        version = spec["version"]
+        const_name = _make_const_name(spec["id"]) + version_suffix(version)
+        description = _clean(spec.get("description", "")).replace("'", "\\'")
+        name = spec["name"].replace("'", "\\'")
+        tags = _fmt_str_list_ts(spec.get("tags", []) or [])
+        icon = spec.get("icon")
+        emoji = spec.get("emoji")
+        agent = spec.get("agent")
+
+        block = [
+            f"export const {const_name}: PersonaSpec = {{",
+            f"  id: '{spec['id']}',",
+            f"  version: '{version}',",
+            f"  name: '{name}',",
+            f"  description: '{description}',",
+            f"  tags: {tags},",
+        ]
+        if icon is not None:
+            block.append(f"  icon: '{icon}',")
+        if emoji is not None:
+            block.append(f"  emoji: '{emoji}',")
+        if agent is not None:
+            block.append(f"  agent: '{agent}',")
+        block.append("};")
+        block.append("")
+        lines.extend(block)
+
+    lines.extend(
+        [
+            "// " + "=" * 76,
+            "// Persona Catalog",
+            "// " + "=" * 76,
+            "",
+            "export const PERSONA_CATALOGUE: Record<string, PersonaSpec> = {",
+        ]
+    )
+
+    for spec in specs:
+        const_name = _make_const_name(spec["id"]) + version_suffix(spec["version"])
+        lines.append(f"  '{spec['id']}': {const_name},")
+
+    lines.extend(
+        [
+            "};",
+            "",
+            "function resolvePersonaId(personaId: string): string {",
+            "  if (personaId in PERSONA_CATALOGUE) return personaId;",
+            "  const idx = personaId.lastIndexOf(':');",
+            "  if (idx > 0) {",
+            "    const base = personaId.slice(0, idx);",
+            "    if (base in PERSONA_CATALOGUE) return base;",
+            "  }",
+            "  return personaId;",
+            "}",
+            "",
+            "/** Get a persona specification by ID. */",
+            "export function getPersona(personaId: string): PersonaSpec | undefined {",
+            "  return PERSONA_CATALOGUE[resolvePersonaId(personaId)];",
+            "}",
+            "",
+            "/** List all available personas. */",
+            "export function listPersonas(): PersonaSpec[] {",
+            "  return Object.values(PERSONA_CATALOGUE);",
+            "}",
+            "",
+        ]
+    )
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate Python and TypeScript code from YAML persona 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 does not exist: {args.specs_dir}")
+        sys.exit(1)
+
+    print(f"Loading persona specs from {args.specs_dir}...")
+    specs = load_persona_specs(args.specs_dir)
+    print(f"Loaded {len(specs)} persona specifications")
+
+    print("Generating Python code...")
+    python_code = generate_python_code(specs)
+    args.python_output.parent.mkdir(parents=True, exist_ok=True)
+    args.python_output.write_text(python_code)
+    print(f"✓ Generated {args.python_output}")
+
+    print("Generating TypeScript code...")
+    typescript_code = generate_typescript_code(specs)
+    args.typescript_output.parent.mkdir(parents=True, exist_ok=True)
+    args.typescript_output.write_text(typescript_code)
+    print(f"✓ Generated {args.typescript_output}")
+
+    print(f"\n✓ Successfully generated code from {len(specs)} persona specs")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/codegen/generate_skills.py

@@ -130,7 +130,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "# Skill Catalog",
             "# " + "=" * 76,
             "",
-            "SKILL_CATALOG: Dict[str, SkillSpec] = {",
+            "SKILLS_CATALOG: Dict[str, SkillSpec] = {",
         ]
     )
 
@@ -172,12 +172,12 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "    Returns:",
             "        The SkillSpec, or None if not found.",
             '    """',
-            "    spec = SKILL_CATALOG.get(skill_id)",
+            "    spec = SKILLS_CATALOG.get(skill_id)",
             "    if spec is not None:",
             "        return spec",
             "    base, _, ver = skill_id.rpartition(':')",
             "    if base and '.' in ver:",
-            "        return SKILL_CATALOG.get(base)",
+            "        return SKILLS_CATALOG.get(base)",
             "    return None",
             "",
             "",
@@ -188,7 +188,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "    Returns:",
             "        List of all SkillSpec configurations.",
             '    """',
-            "    return list(SKILL_CATALOG.values())",
+            "    return list(SKILLS_CATALOG.values())",
             "",
         ]
     )
@@ -294,7 +294,7 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
             "// Skill Catalog",
             "// " + "=" * 76,
             "",
-            "export const SKILL_CATALOG: Record<string, SkillSpec> = {",
+            "export const SKILLS_CATALOG: Record<string, SkillSpec> = {",
         ]
     )
 
@@ -311,21 +311,21 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
             "};",
             "",
             "export function getSkillSpecs(): SkillSpec[] {",
-            "  return Object.values(SKILL_CATALOG);",
+            "  return Object.values(SKILLS_CATALOG);",
             "}",
             "",
             "function resolveSkillId(skillId: string): string {",
-            "  if (skillId in SKILL_CATALOG) return skillId;",
+            "  if (skillId in SKILLS_CATALOG) return skillId;",
             "  const idx = skillId.lastIndexOf(':');",
             "  if (idx > 0) {",
             "    const base = skillId.slice(0, idx);",
-            "    if (base in SKILL_CATALOG) return base;",
+            "    if (base in SKILLS_CATALOG) return base;",
             "  }",
             "  return skillId;",
             "}",
             "",
             "export function getSkillSpec(skillId: string): SkillSpec | undefined {",
-            "  return SKILL_CATALOG[resolveSkillId(skillId)];",
+            "  return SKILLS_CATALOG[resolveSkillId(skillId)];",
             "}",
             "",
         ]

package/scripts/sync-jupyter.sh

@@ -20,12 +20,29 @@ NC='\033[0m' # No Color
 
 # Get the script directory and project root
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-CORE_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
-JUPYTER_UI_ROOT="$( cd "$CORE_ROOT/../jupyter-ui" && pwd )"
+AGENT_RUNTIMES_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+DATALAYER_CORE_ROOT="$( cd "$AGENT_RUNTIMES_ROOT/../core" && pwd )"
+JUPYTER_UI_ROOT="$( cd "$AGENT_RUNTIMES_ROOT/../jupyter-ui" && pwd )"
 
 # Function to perform the sync
 sync_packages() {
-  echo -e "${BLUE}🔄 Syncing jupyter-ui packages to @datalayer/agent-runtimes...${NC}"
+  echo -e "${BLUE}🔄 Syncing local packages to @datalayer/agent-runtimes...${NC}"
+
+  # Build and sync @datalayer/core
+  echo -e "${BLUE}📦 Building @datalayer/core...${NC}"
+  cd "$DATALAYER_CORE_ROOT"
+  npm run build:lib
+
+  echo -e "${BLUE}📋 Copying core to agent-runtimes/node_modules...${NC}"
+  cd "$AGENT_RUNTIMES_ROOT"
+  rm -rf node_modules/@datalayer/core/lib
+  mkdir -p node_modules/@datalayer/core/lib
+  cp -r "$DATALAYER_CORE_ROOT/lib/." node_modules/@datalayer/core/lib/
+  if [ -d "$DATALAYER_CORE_ROOT/style" ]; then
+    rm -rf node_modules/@datalayer/core/style
+    cp -r "$DATALAYER_CORE_ROOT/style" node_modules/@datalayer/core/
+  fi
+  cp "$DATALAYER_CORE_ROOT/package.json" node_modules/@datalayer/core/
 
   # Build jupyter-react FIRST (lexical depends on it)
   echo -e "${BLUE}📦 Building @datalayer/jupyter-react...${NC}"
@@ -49,9 +66,9 @@ sync_packages() {
   fi
   echo -e "${YELLOW}[DEBUG] lib directory verified!${NC}"
 
-  # Copy react to core's node_modules for patch-package
-  echo -e "${BLUE}📋 Copying react to core/node_modules...${NC}"
-  cd "$CORE_ROOT"
+  # Copy react to agent-runtimes' node_modules for patch-package
+  echo -e "${BLUE}📋 Copying react to agent-runtimes/node_modules...${NC}"
+  cd "$AGENT_RUNTIMES_ROOT"
   # Only replace lib/ directory, preserving LICENSE, README.md, etc.
   rm -rf node_modules/@datalayer/jupyter-react/lib
   mkdir -p node_modules/@datalayer/jupyter-react/lib
@@ -73,7 +90,7 @@ sync_packages() {
 
   # Copy lexical to node_modules
   echo -e "${BLUE}📋 Copying lexical to node_modules...${NC}"
-  cd "$CORE_ROOT"
+  cd "$AGENT_RUNTIMES_ROOT"
   # Only replace lib/ directory, preserving LICENSE, README.md, etc.
   rm -rf node_modules/@datalayer/jupyter-lexical/lib
   mkdir -p node_modules/@datalayer/jupyter-lexical/lib
@@ -103,6 +120,7 @@ if [[ "$1" == "--watch" ]]; then
 
   echo -e "${BLUE}👁️  Watch mode enabled. Monitoring jupyter-ui packages for changes...${NC}"
   echo -e "${YELLOW}📁 Watching:${NC}"
+  echo -e "${YELLOW}   - $DATALAYER_CORE_ROOT/src${NC}"
   echo -e "${YELLOW}   - $JUPYTER_UI_ROOT/packages/lexical/src${NC}"
   echo -e "${YELLOW}   - $JUPYTER_UI_ROOT/packages/react/src${NC}"
   echo -e "${YELLOW}Press Ctrl+C to stop${NC}"
@@ -118,6 +136,7 @@ if [[ "$1" == "--watch" ]]; then
   # -l 1: latency 1 second (debounce rapid changes)
   fswatch -r -l 1 \
     -e ".*" -i "\\.tsx?$" -i "\\.jsx?$" -i "\\.css$" \
+    "$DATALAYER_CORE_ROOT/src" \
     "$JUPYTER_UI_ROOT/packages/lexical/src" \
     "$JUPYTER_UI_ROOT/packages/react/src" | while read -r file; do
     echo -e "\n${YELLOW}📝 Change detected in: $(basename "$file")${NC}"

package/lib/api/tool-approvals.d.ts

@@ -1,62 +0,0 @@
-import type { ToolApproval, ToolApprovalFilters } from '../types';
-/**
- * List tool approvals with optional filters.
- * @param token - Authentication token
- * @param filters - Optional filters (agentId, status, toolName, limit, offset)
- * @param baseUrl - Base URL
- * @returns Promise resolving to list of tool approvals
- */
-export declare const getToolApprovals: (token: string, filters?: ToolApprovalFilters, baseUrl?: string) => Promise<ToolApproval[]>;
-/**
- * Get a specific tool approval by ID.
- * @param token - Authentication token
- * @param id - Tool approval ID
- * @param baseUrl - Base URL
- */
-export declare const getToolApproval: (token: string, id: string, baseUrl?: string) => Promise<ToolApproval>;
-/**
- * Approve a pending tool request.
- * @param token - Authentication token
- * @param id - Tool approval ID
- * @param note - Optional note explaining the approval
- * @param baseUrl - Base URL
- */
-export declare const approveToolRequest: (token: string, id: string, note?: string, baseUrl?: string) => Promise<void>;
-/**
- * Reject a pending tool request.
- * @param token - Authentication token
- * @param id - Tool approval ID
- * @param note - Optional note explaining the rejection
- * @param baseUrl - Base URL
- */
-export declare const rejectToolRequest: (token: string, id: string, note?: string, baseUrl?: string) => Promise<void>;
-/**
- * Mark a tool approval as read.
- * @param token - Authentication token
- * @param id - Tool approval ID
- * @param baseUrl - Base URL
- */
-export declare const markToolApprovalRead: (token: string, id: string, baseUrl?: string) => Promise<void>;
-/**
- * Mark a tool approval as unread.
- * @param token - Authentication token
- * @param id - Tool approval ID
- * @param baseUrl - Base URL
- */
-export declare const markToolApprovalUnread: (token: string, id: string, baseUrl?: string) => Promise<void>;
-/**
- * Delete a tool approval.
- * @param token - Authentication token
- * @param id - Tool approval ID
- * @param baseUrl - Base URL
- */
-export declare const deleteToolApproval: (token: string, id: string, baseUrl?: string) => Promise<void>;
-/**
- * Get count of pending tool approvals.
- * @param token - Authentication token
- * @param baseUrl - Base URL
- * @returns Promise resolving to pending count
- */
-export declare const getPendingApprovalCount: (token: string, baseUrl?: string) => Promise<{
-    count: number;
-}>;