aury-agent 0.0.4__py3-none-any.whl

aury/agents/workflow/expression.py

@@ -0,0 +1,136 @@
+"""Expression evaluator for workflow DSL."""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+class ExpressionError(Exception):
+    """Expression evaluation error."""
+    pass
+
+
+class DotDict(dict):
+    """Dict that supports dot notation access.
+    
+    Allows expressions like `inputs.json_data` instead of `inputs["json_data"]`.
+    """
+    
+    def __getattr__(self, key: str) -> Any:
+        try:
+            value = self[key]
+            # Recursively wrap nested dicts
+            if isinstance(value, dict) and not isinstance(value, DotDict):
+                return DotDict(value)
+            return value
+        except KeyError:
+            raise AttributeError(f"'{type(self).__name__}' has no attribute '{key}'")
+    
+    def __setattr__(self, key: str, value: Any) -> None:
+        self[key] = value
+    
+    def __delattr__(self, key: str) -> None:
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"'{type(self).__name__}' has no attribute '{key}'")
+
+
+class ExpressionEvaluator:
+    """Expression evaluator for ${{ ... }} syntax."""
+    
+    EXPR_PATTERN = re.compile(r'\$\{\{\s*(.+?)\s*\}\}')
+    
+    def evaluate(
+        self,
+        expression: str,
+        context: dict[str, Any],
+    ) -> Any:
+        """Evaluate expression.
+        
+        Supports:
+        - Full expressions: ${{ inputs.name }}
+        - Template strings: "Hello ${{ inputs.name }}!"
+        - Comparisons: ${{ inputs.count > 10 }}
+        """
+        if expression.startswith("${{") and expression.endswith("}}"):
+            inner = expression[3:-2].strip()
+            return self._eval_inner(inner, context)
+        
+        def replace(match: re.Match) -> str:
+            inner = match.group(1)
+            result = self._eval_inner(inner, context)
+            return str(result) if result is not None else ""
+        
+        return self.EXPR_PATTERN.sub(replace, expression)
+    
+    def _eval_inner(self, expr: str, context: dict[str, Any]) -> Any:
+        """Evaluate inner expression.
+        
+        Uses DotDict to allow dot notation access like `inputs.json_data`.
+        """
+        # Wrap dicts in DotDict to support dot notation
+        inputs_data = context.get("inputs", {})
+        state_data = context.get("state", {})
+        
+        safe_context = {
+            "inputs": DotDict(inputs_data) if isinstance(inputs_data, dict) else inputs_data,
+            "state": DotDict(state_data.to_dict() if hasattr(state_data, 'to_dict') else state_data) if state_data else DotDict({}),
+            "true": True,
+            "false": False,
+            "null": None,
+            "True": True,
+            "False": False,
+            "None": None,
+        }
+        
+        # Add extra context variables (also wrap dicts)
+        for key, value in context.items():
+            if key not in ("inputs", "state"):
+                if isinstance(value, dict):
+                    safe_context[key] = DotDict(value)
+                else:
+                    safe_context[key] = value
+        
+        try:
+            return eval(expr, {"__builtins__": {}}, safe_context)
+        except Exception as e:
+            raise ExpressionError(f"Failed to evaluate: {expr}") from e
+    
+    def evaluate_condition(self, expr: str | None, context: dict[str, Any]) -> bool:
+        """Evaluate condition expression."""
+        if not expr:
+            return True
+        result = self.evaluate(expr, context)
+        return bool(result)
+    
+    def has_expression(self, value: str) -> bool:
+        """Check if string contains expression."""
+        if not isinstance(value, str):
+            return False
+        return bool(self.EXPR_PATTERN.search(value))
+    
+    def resolve_inputs(
+        self,
+        inputs: dict[str, Any],
+        context: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Resolve all expressions in inputs dict."""
+        resolved = {}
+        
+        for key, value in inputs.items():
+            if isinstance(value, str) and self.has_expression(value):
+                resolved[key] = self.evaluate(value, context)
+            elif isinstance(value, dict):
+                resolved[key] = self.resolve_inputs(value, context)
+            elif isinstance(value, list):
+                resolved[key] = [
+                    self.evaluate(v, context)
+                    if isinstance(v, str) and self.has_expression(v)
+                    else v
+                    for v in value
+                ]
+            else:
+                resolved[key] = value
+        
+        return resolved

aury/agents/workflow/parser.py

@@ -0,0 +1,182 @@
+"""Workflow DSL parser."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .types import (
+    NodeType,
+    Position,
+    NodeSpec,
+    EdgeSpec,
+    WorkflowSpec,
+    Workflow,
+)
+
+
+class WorkflowValidationError(Exception):
+    """Workflow validation error."""
+    
+    def __init__(self, errors: list[str]):
+        self.errors = errors
+        super().__init__(f"Workflow validation failed: {'; '.join(errors)}")
+
+
+class WorkflowParser:
+    """Workflow DSL parser."""
+    
+    def parse(self, source: str | Path) -> Workflow:
+        """Parse YAML file or string."""
+        raw = self._load_yaml(source)
+        spec = self._parse_spec(raw)
+        
+        errors = self.validate(spec)
+        if errors:
+            raise WorkflowValidationError(errors)
+        
+        return self._build_workflow(spec)
+    
+    def _load_yaml(self, source: str | Path) -> dict[str, Any]:
+        """Load YAML from file or string."""
+        if isinstance(source, Path):
+            with open(source, 'r') as f:
+                return yaml.safe_load(f)
+        elif isinstance(source, str):
+            if source.endswith('.yaml') or source.endswith('.yml'):
+                with open(source, 'r') as f:
+                    return yaml.safe_load(f)
+            else:
+                return yaml.safe_load(source)
+        raise ValueError(f"Invalid source type: {type(source)}")
+    
+    def _parse_spec(self, raw: dict[str, Any]) -> WorkflowSpec:
+        """Parse raw dict to WorkflowSpec."""
+        nodes = []
+        for n in raw.get("nodes", []):
+            pos_data = n.get("position", {"x": 0, "y": 0})
+            position = Position(x=pos_data.get("x", 0), y=pos_data.get("y", 0))
+            
+            node = NodeSpec(
+                id=n["id"],
+                type=NodeType(n["type"]),
+                position=position,
+                agent=n.get("agent"),
+                config=n.get("config", {}),
+                inputs=n.get("inputs", {}),
+                output=n.get("output"),
+                when=n.get("when"),
+                branches=n.get("branches"),
+                steps=n.get("steps"),
+                expression=n.get("expression"),
+                then_node=n.get("then"),
+                else_node=n.get("else"),
+            )
+            nodes.append(node)
+        
+        edges = []
+        for e in raw.get("edges", []):
+            edge = EdgeSpec(
+                from_node=e["from"],
+                to_node=e["to"],
+                when=e.get("when"),
+            )
+            edges.append(edge)
+        
+        return WorkflowSpec(
+            name=raw["name"],
+            version=raw.get("version", "1.0"),
+            description=raw.get("description"),
+            state=raw.get("state", {}),
+            inputs=raw.get("inputs", {}),
+            nodes=nodes,
+            edges=edges,
+        )
+    
+    def validate(self, spec: WorkflowSpec) -> list[str]:
+        """Validate workflow spec."""
+        errors = []
+        node_ids = {n.id for n in spec.nodes}
+        
+        # Check edge references
+        for edge in spec.edges:
+            if edge.from_node not in node_ids:
+                errors.append(f"Edge references unknown node: {edge.from_node}")
+            if edge.to_node not in node_ids:
+                errors.append(f"Edge references unknown node: {edge.to_node}")
+        
+        # Check for trigger node
+        triggers = [n for n in spec.nodes if n.type == NodeType.TRIGGER]
+        if not triggers:
+            errors.append("Workflow must have at least one trigger node")
+        
+        # Check for cycles
+        if self._has_cycle(spec):
+            errors.append("Workflow contains cycles")
+        
+        # Check agent nodes
+        for node in spec.nodes:
+            if node.type == NodeType.AGENT and not node.agent:
+                errors.append(f"Agent node '{node.id}' must specify 'agent' type")
+        
+        # Check condition nodes
+        for node in spec.nodes:
+            if node.type == NodeType.CONDITION:
+                if not node.expression:
+                    errors.append(f"Condition node '{node.id}' must have 'expression'")
+                if not node.then_node:
+                    errors.append(f"Condition node '{node.id}' must have 'then'")
+        
+        return errors
+    
+    def _has_cycle(self, spec: WorkflowSpec) -> bool:
+        """Detect cycles using DFS."""
+        visited: set[str] = set()
+        rec_stack: set[str] = set()
+        
+        adj: dict[str, list[str]] = {n.id: [] for n in spec.nodes}
+        for edge in spec.edges:
+            adj[edge.from_node].append(edge.to_node)
+        
+        def dfs(node_id: str) -> bool:
+            visited.add(node_id)
+            rec_stack.add(node_id)
+            
+            for neighbor in adj.get(node_id, []):
+                if neighbor not in visited:
+                    if dfs(neighbor):
+                        return True
+                elif neighbor in rec_stack:
+                    return True
+            
+            rec_stack.remove(node_id)
+            return False
+        
+        for node in spec.nodes:
+            if node.id not in visited:
+                if dfs(node.id):
+                    return True
+        
+        return False
+    
+    def _build_workflow(self, spec: WorkflowSpec) -> Workflow:
+        """Build executable workflow."""
+        node_map = {n.id: n for n in spec.nodes}
+        
+        incoming_edges: dict[str, list[str]] = {n.id: [] for n in spec.nodes}
+        outgoing_edges: dict[str, list[str]] = {n.id: [] for n in spec.nodes}
+        edge_conditions: dict[tuple[str, str], str | None] = {}
+        
+        for edge in spec.edges:
+            incoming_edges[edge.to_node].append(edge.from_node)
+            outgoing_edges[edge.from_node].append(edge.to_node)
+            edge_conditions[(edge.from_node, edge.to_node)] = edge.when
+        
+        return Workflow(
+            spec=spec,
+            node_map=node_map,
+            incoming_edges=incoming_edges,
+            outgoing_edges=outgoing_edges,
+            edge_conditions=edge_conditions,
+        )

aury/agents/workflow/state.py

@@ -0,0 +1,145 @@
+"""Workflow state management with branch isolation."""
+from __future__ import annotations
+
+from collections import ChainMap
+from typing import Any, Callable, Iterator, Protocol
+
+
+class MergeStrategy(Protocol):
+    """Merge strategy protocol."""
+    
+    def merge(self, results: list[Any]) -> Any:
+        """Merge parallel results."""
+        ...
+
+
+class CollectListStrategy:
+    """Collect results as list."""
+    
+    def merge(self, results: list[Any]) -> list[Any]:
+        return [r for r in results if r is not None]
+
+
+class CollectDictStrategy:
+    """Collect results as dict."""
+    
+    def __init__(self, key_fn: Callable[[Any], str] | None = None):
+        self.key_fn = key_fn or (lambda x: str(id(x)))
+    
+    def merge(self, results: list[Any]) -> dict[str, Any]:
+        return {self.key_fn(r): r for r in results if r is not None}
+
+
+class FirstSuccessStrategy:
+    """Take first non-None result."""
+    
+    def merge(self, results: list[Any]) -> Any:
+        return next((r for r in results if r is not None), None)
+
+
+class CustomMergeStrategy:
+    """Custom merge function."""
+    
+    def __init__(self, merge_fn: Callable[[list[Any]], Any]):
+        self.merge_fn = merge_fn
+    
+    def merge(self, results: list[Any]) -> Any:
+        return self.merge_fn(results)
+
+
+class WorkflowState:
+    """Workflow state with branch isolation.
+    
+    Uses ChainMap for copy-on-write semantics.
+    """
+    
+    def __init__(self, parent: WorkflowState | None = None):
+        self._local: dict[str, Any] = {}
+        self._parent = parent
+        
+        if parent:
+            self._chain: ChainMap[str, Any] = ChainMap(self._local, parent._chain)
+        else:
+            self._chain = ChainMap(self._local)
+    
+    def __getitem__(self, key: str) -> Any:
+        return self._chain[key]
+    
+    def __setitem__(self, key: str, value: Any) -> None:
+        self._local[key] = value
+    
+    def __contains__(self, key: str) -> bool:
+        return key in self._chain
+    
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._chain)
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._chain.get(key, default)
+    
+    def keys(self) -> Any:
+        return self._chain.keys()
+    
+    def values(self) -> Any:
+        return self._chain.values()
+    
+    def items(self) -> Any:
+        return self._chain.items()
+    
+    def create_branch(self) -> WorkflowState:
+        """Create branch for parallel execution."""
+        return WorkflowState(parent=self)
+    
+    def get_local_changes(self) -> dict[str, Any]:
+        """Get local changes."""
+        return dict(self._local)
+    
+    def merge_from(
+        self,
+        other: WorkflowState,
+        strategy: str = "overwrite",
+    ) -> None:
+        """Merge changes from another state."""
+        changes = other.get_local_changes()
+        
+        for key, value in changes.items():
+            if strategy == "overwrite":
+                self._local[key] = value
+            elif strategy == "append":
+                if key in self._local:
+                    existing = self._local[key]
+                    if isinstance(existing, list):
+                        existing.append(value)
+                    else:
+                        self._local[key] = [existing, value]
+                else:
+                    self._local[key] = [value]
+    
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to regular dict."""
+        return dict(self._chain)
+    
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "WorkflowState":
+        """Create from dict."""
+        state = cls()
+        state._local.update(data)
+        return state
+    
+    def clear(self) -> None:
+        """Clear local state."""
+        self._local.clear()
+
+
+def get_merge_strategy(strategy: str, **kwargs: Any) -> MergeStrategy:
+    """Get merge strategy by name."""
+    match strategy:
+        case "collect_list":
+            return CollectListStrategy()
+        case "collect_dict":
+            key_fn = kwargs.get("key_fn")
+            return CollectDictStrategy(key_fn=key_fn)
+        case "first_success":
+            return FirstSuccessStrategy()
+        case _:
+            return CollectListStrategy()

aury/agents/workflow/types.py

@@ -0,0 +1,86 @@
+"""Workflow DSL types."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..middleware import Middleware, MiddlewareChain
+
+
+class NodeType(Enum):
+    """Workflow node types."""
+    TRIGGER = "trigger"
+    AGENT = "agent"
+    PARALLEL = "parallel"
+    SEQUENCE = "sequence"
+    CONDITION = "condition"
+    TERMINAL = "terminal"
+
+
+@dataclass
+class Position:
+    """Node position for visual editors."""
+    x: float = 0.0
+    y: float = 0.0
+
+
+@dataclass
+class NodeSpec:
+    """Node specification."""
+    id: str
+    type: NodeType
+    position: Position = field(default_factory=Position)
+    agent: str | None = None
+    config: dict[str, Any] = field(default_factory=dict)
+    inputs: dict[str, Any] = field(default_factory=dict)
+    output: str | None = None
+    when: str | None = None  # Conditional expression
+    
+    # For parallel/sequence nodes
+    branches: list[dict[str, Any]] | None = None
+    steps: list[str] | None = None
+    
+    # For condition nodes
+    expression: str | None = None
+    then_node: str | None = None
+    else_node: str | None = None
+    
+    # Node-level middleware (overrides/extends workflow middleware)
+    middleware: list["Middleware"] | None = None
+
+
+@dataclass
+class EdgeSpec:
+    """Edge specification."""
+    from_node: str
+    to_node: str
+    when: str | None = None  # Conditional edge
+
+
+@dataclass
+class WorkflowSpec:
+    """Workflow specification from DSL."""
+    name: str
+    version: str = "1.0"
+    description: str | None = None
+    state: dict[str, str] = field(default_factory=dict)
+    inputs: dict[str, dict[str, Any]] = field(default_factory=dict)
+    nodes: list[NodeSpec] = field(default_factory=list)
+    edges: list[EdgeSpec] = field(default_factory=list)
+    
+    # Workflow-level middleware (applied to all nodes)
+    middleware: "MiddlewareChain | None" = None
+
+
+@dataclass
+class Workflow:
+    """Parsed executable workflow."""
+    spec: WorkflowSpec
+    
+    # Computed properties
+    node_map: dict[str, NodeSpec] = field(default_factory=dict)
+    incoming_edges: dict[str, list[str]] = field(default_factory=dict)
+    outgoing_edges: dict[str, list[str]] = field(default_factory=dict)
+    edge_conditions: dict[tuple[str, str], str | None] = field(default_factory=dict)

aury_agent-0.0.4.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: aury-agent
+Version: 0.0.4
+Summary: Aury Agent Framework - React Agent and Workflow orchestration
+Author: Aury Team
+License: MIT
+Keywords: agent,llm,react,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: aury-ai-model[all]
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == 'anthropic'
+Provides-Extra: memory
+Requires-Dist: chromadb>=0.4.0; extra == 'memory'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# Aury Agents
+
+A flexible Agent framework supporting both React Agent (autonomous loop) and Workflow (DAG orchestration) patterns.
+
+## Features
+
+- **React Agent**: Autonomous agent with tool calling loop
+- **Workflow**: DAG-based orchestration for complex pipelines
+- **Session Management**: Event-sourced session with snapshot and revert
+- **Permission System**: Fine-grained tool execution control
+- **Memory System**: Semantic memory with vector storage
+- **Compaction**: Token-efficient session history management
+
+## Installation
+
+```bash
+pip install aury-agent
+```
+
+## Quick Start
+
+```python
+from aury.agents import ReactAgent, Tool
+
+# Define a tool
+@tool
+def search(query: str) -> str:
+    """Search the web."""
+    return f"Results for: {query}"
+
+# Create agent
+agent = ReactAgent(
+    tools=[search],
+    llm_provider=your_llm_provider,
+)
+
+# Run
+result = await agent.run("What is the weather today?")
+```
+
+## Development
+
+```bash
+# Install dev dependencies
+uv sync
+
+# Run tests
+pytest
+
+# Type check
+mypy aury
+
+# Lint
+ruff check aury
+```
+
+## License
+
+MIT