agentlisp 2.0.0__py3-none-any.whl

agentlisp_runtime/cli.py

@@ -0,0 +1,145 @@
+"""Command Line Interface for Agent Lisp Runtime."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import structlog
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from . import __version__
+from .engine import AgentEngine
+from .loader import AgentLoader
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit(code=0)
+
+
+app = typer.Typer(
+    name="agentlisp",
+    help="Agent Lisp Runtime - Execute Scheme-defined agent workflows",
+    no_args_is_help=True,
+)
+console = Console()
+logger = structlog.get_logger()
+
+
+@app.callback()
+def main(
+    version: bool | None = typer.Option(
+        None,
+        "--version",
+        "-V",
+        help="Show the Agent Lisp Runtime version and exit.",
+        is_eager=True,
+        callback=_version_callback,
+    ),
+) -> None:
+    """Agent Lisp Runtime CLI entrypoint."""
+    return None
+
+
+@app.command("validate")
+def validate(
+    agent_file: Path = typer.Argument(  # noqa: B008
+        ..., exists=True, readable=True, help="Agent definition file"
+    ),
+    format: str = typer.Option("json", "--format", "-f", help="Input format: json|yaml|scheme"),
+) -> None:
+    """Validate an agent definition file."""
+    try:
+        agent = _load_agent(agent_file, format)
+        console.print(
+            Panel.fit(
+                f"[bold green]✓ Agent '{agent.name}' is valid[/bold green]\n"
+                f"Purpose: {agent.purpose or '(none)'}\n"
+                f"Tools: {len(agent.tools)}\n"
+                f"Workflows: {len(agent.workflows)}",
+                title="Validation Result",
+                border_style="green",
+            )
+        )
+        if agent.workflows:
+            table = Table(title="Workflows")
+            table.add_column("Name")
+            table.add_column("Steps")
+            table.add_column("Triggers")
+            for wf in agent.workflows:
+                table.add_row(wf.name, str(len(wf.steps)), ", ".join(wf.triggers) or "-")
+            console.print(table)
+    except Exception as exc:
+        console.print(f"[bold red]✗ Validation failed:[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+
+@app.command("run")
+def run_workflow(
+    agent_file: Path = typer.Argument(  # noqa: B008
+        ..., exists=True, readable=True, help="Agent definition file"
+    ),
+    workflow: str = typer.Argument(..., help="Workflow name to execute"),
+    format: str = typer.Option("json", "--format", "-f", help="Input format: json|yaml|scheme"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Write result to file"),  # noqa: B008
+) -> None:
+    """Execute a workflow defined in the agent file."""
+    import asyncio
+
+    async def _run() -> None:
+        agent = _load_agent(agent_file, format)
+        engine = AgentEngine(agent)
+        result = await engine.run_workflow(workflow)
+        result_dict = result.model_dump(mode="json")
+
+        result_text = json.dumps(result_dict, indent=2, ensure_ascii=False, default=str)
+
+        if output:
+            output.write_text(result_text, encoding="utf-8")
+            console.print(f"[green]Result written to {output}[/green]")
+        else:
+            console.print_json(result_text)
+
+        if not result.success:
+            raise typer.Exit(code=2)
+
+    asyncio.run(_run())
+
+
+@app.command("export")
+def export(
+    scheme_file: Path = typer.Argument(..., exists=True, readable=True, help="Scheme .rkt file"),  # noqa: B008
+    output: Path = typer.Option(Path("agent.json"), "--output", "-o", help="Output JSON file"),  # noqa: B008
+    racket_exe: str = typer.Option("racket", "--racket", help="Racket executable path"),
+) -> None:
+    """Export a Scheme agent definition to JSON."""
+    try:
+        agent = AgentLoader.from_scheme(scheme_file, racket_exe=racket_exe)
+        output.write_text(
+            agent.model_dump_json(indent=2),
+            encoding="utf-8",
+        )
+        console.print(f"[bold green]✓ Exported agent '{agent.name}' to {output}[/bold green]")
+    except Exception as exc:
+        console.print(f"[bold red]✗ Export failed:[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+
+def _load_agent(path: Path, fmt: str):
+    fmt = fmt.lower()
+    if fmt == "json":
+        return AgentLoader.from_json(path)
+    if fmt in {"yaml", "yml"}:
+        return AgentLoader.from_yaml(path)
+    if fmt in {"scheme", "racket", "rkt"}:
+        return AgentLoader.from_scheme(path)
+    raise typer.BadParameter(f"Unsupported format: {fmt}")
+
+
+if __name__ == "__main__":
+    app()

agentlisp_runtime/engine.py

@@ -0,0 +1,253 @@
+"""Agent Engine - core execution engine that runs workflows defined via DSL."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Callable
+from typing import Any
+
+import structlog
+
+from .models import (
+    Agent,
+    AtomicAction,
+    ExecutionContext,
+    ExecutionResult,
+    ExecutionStatus,
+    Step,
+    StepExecutionResult,
+    Workflow,
+)
+
+logger = structlog.get_logger()
+
+
+class AgentEngine:
+    def __init__(
+        self,
+        agent: Agent,
+        tool_handlers: dict[str, Callable[..., Any]] | None = None,
+    ) -> None:
+        self._agent = agent
+        self._tool_handlers: dict[str, Callable[..., Any]] = tool_handlers or {}
+        self._register_agent_tools()
+
+    def _register_agent_tools(self) -> None:
+        for tool in self._agent.tools:
+            if tool.handler is not None and tool.name not in self._tool_handlers:
+                self._tool_handlers[tool.name] = tool.handler
+
+    def register_tool_handler(self, tool_name: str, handler: Callable[..., Any]) -> None:
+        self._tool_handlers[tool_name] = handler
+
+    async def run_workflow(
+        self,
+        workflow_name: str,
+        context: ExecutionContext | None = None,
+    ) -> ExecutionResult:
+        start_time = time.perf_counter()
+        context = context or ExecutionContext()
+
+        workflow = self._agent.get_workflow(workflow_name)
+        if workflow is None:
+            return ExecutionResult(
+                run_id=context.run_id,
+                agent_name=self._agent.name,
+                workflow_name=workflow_name,
+                status=ExecutionStatus.FAILED,
+                error=f"Workflow '{workflow_name}' not found",
+            )
+
+        logger.info(
+            "workflow.start",
+            agent=self._agent.name,
+            workflow=workflow_name,
+            run_id=str(context.run_id),
+        )
+
+        result = ExecutionResult(
+            run_id=context.run_id,
+            agent_name=self._agent.name,
+            workflow_name=workflow_name,
+            status=ExecutionStatus.RUNNING,
+        )
+
+        try:
+            await self._execute_steps(workflow, context, result)
+            result.status = ExecutionStatus.SUCCESS
+        except Exception as exc:
+            logger.exception("workflow.error", error=str(exc))
+            result.status = ExecutionStatus.FAILED
+            result.error = str(exc)
+
+        result.total_duration_ms = (time.perf_counter() - start_time) * 1000
+        logger.info(
+            "workflow.end",
+            agent=self._agent.name,
+            workflow=workflow_name,
+            status=result.status.value,
+            duration_ms=result.total_duration_ms,
+        )
+        return result
+
+    async def _execute_steps(
+        self,
+        workflow: Workflow,
+        context: ExecutionContext,
+        result: ExecutionResult,
+    ) -> None:
+        step_map: dict[str, Step] = {s.id: s for s in workflow.steps}
+
+        if not workflow.steps:
+            return
+
+        current_step_id: str | None = workflow.steps[0].id
+        visited: set[str] = set()
+
+        while current_step_id is not None:
+            if current_step_id in visited:
+                raise RuntimeError(f"Cycle detected in workflow at step: {current_step_id}")
+            visited.add(current_step_id)
+
+            step = step_map.get(current_step_id)
+            if step is None:
+                raise RuntimeError(f"Step not found: {current_step_id}")
+
+            step_result = await self._execute_step(step, context)
+            result.steps.append(step_result)
+
+            if step_result.status == ExecutionStatus.FAILED:
+                raise RuntimeError(f"Step '{step.id}' failed: {step_result.error}")
+
+            if step.next is None or step.next is False:
+                break
+
+            current_step_id = step.next if isinstance(step.next, str) else None
+
+    async def _execute_step(
+        self,
+        step: Step,
+        context: ExecutionContext,
+    ) -> StepExecutionResult:
+        start_time = time.perf_counter()
+
+        if not self._evaluate_condition(step.condition, context):
+            return StepExecutionResult(
+                step_id=step.id,
+                status=ExecutionStatus.SKIPPED,
+                duration_ms=(time.perf_counter() - start_time) * 1000,
+            )
+
+        logger.debug("step.start", step=step.id)
+
+        try:
+            action = step.action
+            if isinstance(action, AtomicAction):
+                output = await self._execute_atomic_action(action, context)
+            elif isinstance(action, dict):
+                atomic = AtomicAction(**action)
+                output = await self._execute_atomic_action(atomic, context)
+            else:
+                output = None
+
+            context.set_result(step.id, output)
+
+            return StepExecutionResult(
+                step_id=step.id,
+                status=ExecutionStatus.SUCCESS,
+                output=output,
+                duration_ms=(time.perf_counter() - start_time) * 1000,
+            )
+        except Exception as exc:
+            logger.exception("step.error", step=step.id, error=str(exc))
+            return StepExecutionResult(
+                step_id=step.id,
+                status=ExecutionStatus.FAILED,
+                error=str(exc),
+                duration_ms=(time.perf_counter() - start_time) * 1000,
+            )
+
+    def _evaluate_condition(
+        self,
+        condition: bool | str,
+        context: ExecutionContext,
+    ) -> bool:
+        if isinstance(condition, bool):
+            return condition
+        if isinstance(condition, str):
+            try:
+                return bool(eval(condition, {"context": context}))
+            except Exception:
+                logger.warning("condition.eval_failed", condition=condition)
+                return False
+        return True
+
+    async def _execute_atomic_action(
+        self,
+        action: AtomicAction,
+        context: ExecutionContext,
+    ) -> Any:
+        handler = self._tool_handlers.get(action.target)
+        if handler is None:
+            logger.warning(
+                "handler.not_found",
+                target=action.target,
+                method=action.method,
+            )
+            return {
+                "_status": "no_handler",
+                "target": action.target,
+                "method": action.method,
+                "params": action.params,
+            }
+
+        resolved_params = self._resolve_params(action.params, context)
+        method_fn = getattr(handler, action.method, None) if not callable(handler) else handler
+
+        if method_fn is not None and callable(method_fn):
+            if asyncio.iscoroutinefunction(method_fn):
+                return await method_fn(*resolved_params)
+            return method_fn(*resolved_params)
+
+        if callable(handler):
+            if asyncio.iscoroutinefunction(handler):
+                return await handler(action.method, *resolved_params)
+            return handler(action.method, *resolved_params)
+
+        raise RuntimeError(
+            f"No callable handler for target='{action.target}', method='{action.method}'"
+        )
+
+    def _resolve_params(self, params: list[Any], context: ExecutionContext) -> list[Any]:
+        resolved: list[Any] = []
+        for p in params:
+            if isinstance(p, str) and p.startswith("$."):
+                var_path = p[2:]
+                value = self._resolve_path(var_path, context)
+                resolved.append(value)
+            else:
+                resolved.append(p)
+        return resolved
+
+    @staticmethod
+    def _resolve_path(path: str, context: ExecutionContext) -> Any:
+        parts = path.split(".")
+        if not parts:
+            return None
+        root = parts[0]
+        rest = parts[1:]
+        data: Any = None
+        if root == "results":
+            data = context.results
+        elif root == "vars" or root == "variables":
+            data = context.variables
+        elif root == "meta" or root == "metadata":
+            data = context.metadata
+        else:
+            return None
+        for part in rest:
+            data = data.get(part) if isinstance(data, dict) else getattr(data, part, None)
+            if data is None:
+                break
+        return data

agentlisp_runtime/loader.py

@@ -0,0 +1,126 @@
+"""Agent Loader - loads agent definitions from JSON/YAML/Scheme sources."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .models import (
+    ActionType,
+    Agent,
+    AtomicAction,
+    Step,
+    Tool,
+    Workflow,
+)
+
+
+class AgentLoader:
+    @staticmethod
+    def _normalize_action(action: dict[str, Any] | AtomicAction | Any) -> AtomicAction | Any:
+        if isinstance(action, AtomicAction):
+            return action
+        if isinstance(action, dict):
+            kind = action.get("type")
+            if kind in {None, ActionType.ATOMIC, "atomic"}:
+                return AtomicAction(
+                    name=action.get("name", ""),
+                    target=action.get("target", ""),
+                    method=action.get("method", ""),
+                    params=list(action.get("params", [])),
+                    type=ActionType.ATOMIC,
+                )
+            return action
+        return action
+
+    @classmethod
+    def _build_step(cls, step_data: dict[str, Any]) -> Step:
+        normalized = dict(step_data)
+        if "action" in normalized:
+            normalized["action"] = cls._normalize_action(normalized["action"])
+        return Step(**normalized)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Agent:
+        tools = [Tool(**t) for t in data.get("tools", [])]
+        workflows = [
+            Workflow(
+                name=wf["name"],
+                triggers=wf.get("triggers", []),
+                steps=[cls._build_step(s) for s in wf.get("steps", [])],
+            )
+            for wf in data.get("workflows", [])
+        ]
+        return Agent(
+            name=data["name"],
+            purpose=data.get("purpose", ""),
+            tools=tools,
+            workflows=workflows,
+        )
+
+    @classmethod
+    def from_json(cls, path: str | Path) -> Agent:
+        path = Path(path)
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> Agent:
+        path = Path(path)
+        with path.open("r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_scheme(
+        cls,
+        path: str | Path,
+        racket_exe: str = "racket",
+        scheme_root: str | Path | None = None,
+    ) -> Agent:
+        path = Path(path)
+        script_dir = path.parent
+        script = f"""
+#lang racket/base
+(require json
+         racket/runtime-path
+         (file "{path.name}"))
+(require (lib "agent-dsl/reader.rkt"))
+(display (jsexpr->string (serialize-agent {cls._infer_agent_name(path)})))
+"""
+        tmp_script = script_dir / "_agent_export_tmp.rkt"
+        tmp_script.write_text(script, encoding="utf-8")
+
+        try:
+            env_cmd: list[str] = [racket_exe, str(tmp_script)]
+            cwd = Path(scheme_root) if scheme_root else script_dir
+            result = subprocess.run(
+                env_cmd,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            if result.returncode != 0:
+                raise RuntimeError(
+                    f"Racket execution failed (exit {result.returncode}):\n"
+                    f"STDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+                )
+            data = json.loads(result.stdout.strip())
+            return cls.from_dict(data)
+        finally:
+            if tmp_script.exists():
+                tmp_script.unlink()
+
+    @staticmethod
+    def _infer_agent_name(path: Path) -> str:
+        stem = path.stem
+        if "-" in stem:
+            parts = stem.split("-")
+            return "".join(p for p in parts)
+        return stem

agentlisp_runtime/models.py

@@ -0,0 +1,129 @@
+"""Data models for Agent DSL runtime."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from enum import Enum
+from typing import Any
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class ActionType(str, Enum):  # noqa: UP042
+    ATOMIC = "atomic"
+    COMPOSITE = "composite"
+    CUSTOM = "custom"
+
+
+class ExecutionStatus(str, Enum):  # noqa: UP042
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    CANCELLED = "cancelled"
+
+
+class AtomicAction(BaseModel):
+    name: str
+    target: str
+    method: str
+    params: list[Any] = Field(default_factory=list)
+    type: ActionType = ActionType.ATOMIC
+
+
+class Tool(BaseModel):
+    name: str
+    description: str = ""
+    input_schema: dict[str, Any] = Field(default_factory=dict)
+    output_schema: dict[str, Any] = Field(default_factory=dict)
+    handler: Callable[..., Awaitable[Any] | Any] | None = Field(default=None, exclude=True)
+
+    @field_validator("name")
+    @classmethod
+    def name_not_empty(cls, v: str) -> str:
+        if not v.strip():
+            raise ValueError("Tool name cannot be empty")
+        return v
+
+
+class Step(BaseModel):
+    id: str
+    action: AtomicAction | dict[str, Any]
+    next: str | None = None
+    condition: bool | str = True
+
+    @field_validator("id")
+    @classmethod
+    def id_not_empty(cls, v: str) -> str:
+        if not v.strip():
+            raise ValueError("Step id cannot be empty")
+        return v
+
+
+class Workflow(BaseModel):
+    name: str
+    steps: list[Step] = Field(default_factory=list)
+    triggers: list[str] = Field(default_factory=list)
+
+
+class Agent(BaseModel):
+    name: str
+    purpose: str = ""
+    tools: list[Tool] = Field(default_factory=list)
+    workflows: list[Workflow] = Field(default_factory=list)
+
+    @field_validator("name")
+    @classmethod
+    def name_not_empty(cls, v: str) -> str:
+        if not v.strip():
+            raise ValueError("Agent name cannot be empty")
+        return v
+
+    def get_tool(self, tool_name: str) -> Tool | None:
+        for tool in self.tools:
+            if tool.name == tool_name:
+                return tool
+        return None
+
+    def get_workflow(self, workflow_name: str) -> Workflow | None:
+        for wf in self.workflows:
+            if wf.name == workflow_name:
+                return wf
+        return None
+
+
+class ExecutionContext(BaseModel):
+    run_id: UUID = Field(default_factory=uuid4)
+    variables: dict[str, Any] = Field(default_factory=dict)
+    results: dict[str, Any] = Field(default_factory=dict)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    def set_result(self, step_id: str, value: Any) -> None:
+        self.results[step_id] = value
+
+    def get_result(self, step_id: str, default: Any = None) -> Any:
+        return self.results.get(step_id, default)
+
+
+class StepExecutionResult(BaseModel):
+    step_id: str
+    status: ExecutionStatus
+    output: Any = None
+    error: str | None = None
+    duration_ms: float = 0.0
+
+
+class ExecutionResult(BaseModel):
+    run_id: UUID
+    agent_name: str
+    workflow_name: str | None
+    status: ExecutionStatus
+    steps: list[StepExecutionResult] = Field(default_factory=list)
+    total_duration_ms: float = 0.0
+    error: str | None = None
+
+    @property
+    def success(self) -> bool:
+        return self.status == ExecutionStatus.SUCCESS

host/__init__.py

@@ -0,0 +1,5 @@
+"""AgentLisp v2 host glue package."""
+
+from __future__ import annotations
+
+__all__: list[str] = []