AbstractRuntime 0.2.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

abstractruntime/visualflow_compiler/__init__.py

@@ -0,0 +1,29 @@
+"""abstractruntime.visualflow_compiler
+
+VisualFlow JSON → WorkflowSpec compiler (single semantics engine).
+
+This module compiles the VisualFlow authoring DSL (JSON) into an in-memory
+`WorkflowSpec` (Python callables) that AbstractRuntime can execute durably.
+
+Note: `WorkflowSpec` is not a portable artifact format (it contains callables).
+"""
+
+from .flow import Flow, FlowEdge, FlowNode
+from .compiler import compile_flow, compile_visualflow, compile_visualflow_tree
+from .visual.models import VisualEdge, VisualFlow, VisualNode, load_visualflow_json
+from .visual.executor import visual_to_flow
+
+__all__ = [
+    "Flow",
+    "FlowNode",
+    "FlowEdge",
+    "VisualFlow",
+    "VisualNode",
+    "VisualEdge",
+    "load_visualflow_json",
+    "visual_to_flow",
+    "compile_flow",
+    "compile_visualflow",
+    "compile_visualflow_tree",
+]
+

abstractruntime/visualflow_compiler/adapters/__init__.py

@@ -0,0 +1,11 @@
+"""AbstractFlow adapters for converting handlers to workflow nodes."""
+
+from .function_adapter import create_function_node_handler
+from .agent_adapter import create_agent_node_handler
+from .subflow_adapter import create_subflow_node_handler
+
+__all__ = [
+    "create_function_node_handler",
+    "create_agent_node_handler",
+    "create_subflow_node_handler",
+]

abstractruntime/visualflow_compiler/adapters/agent_adapter.py

@@ -0,0 +1,126 @@
+"""Adapter for using AbstractAgent agents as flow nodes."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from abstractruntime.core.models import RunState, StepPlan
+    from abstractagent.agents.base import BaseAgent
+
+
+def create_agent_node_handler(
+    node_id: str,
+    agent: "BaseAgent",
+    next_node: Optional[str],
+    input_key: Optional[str] = None,
+    output_key: Optional[str] = None,
+) -> Callable:
+    """Create a node handler that runs an agent as a subworkflow.
+
+    Agent nodes execute the full agent workflow (ReAct loop, CodeAct, etc.)
+    as a subworkflow. The agent runs to completion before transitioning.
+
+    Args:
+        node_id: Unique identifier for this node
+        agent: The agent instance to run
+        next_node: ID of the next node to transition to (None for terminal)
+        input_key: Key in run.vars to read task/input from
+        output_key: Key in run.vars to write agent output to
+
+    Returns:
+        A node handler function compatible with AbstractRuntime
+
+    Example:
+        >>> from abstractagent import create_react_agent
+        >>> planner = create_react_agent(provider="ollama", model="qwen3:4b")
+        >>> handler = create_agent_node_handler("plan", planner, "search")
+    """
+    from abstractruntime.core.models import Effect, EffectType, StepPlan
+
+    def handler(run: "RunState", ctx: Any) -> "StepPlan":
+        """Start the agent as a subworkflow."""
+        # Determine task for the agent
+        task = ""
+
+        if input_key:
+            input_data = run.vars.get(input_key, {})
+            if isinstance(input_data, dict):
+                task = input_data.get("task", "") or input_data.get("query", "")
+                if not task:
+                    # Use the whole input as context
+                    task = str(input_data)
+            else:
+                task = str(input_data)
+
+        # Fallback to flow's main task
+        if not task:
+            context = run.vars.get("context", {})
+            if isinstance(context, dict):
+                task = context.get("task", "")
+
+        if not task:
+            task = f"Execute {node_id} step"
+
+        # Build initial vars for the agent subworkflow
+        max_iterations = getattr(agent, "_max_iterations", 25)
+        max_history_messages = getattr(agent, "_max_history_messages", -1)
+        max_tokens = getattr(agent, "_max_tokens", None)
+        if not isinstance(max_tokens, int) or max_tokens <= 0:
+            from abstractruntime.core.vars import DEFAULT_MAX_TOKENS
+
+            try:
+                runtime = getattr(agent, "runtime", None)
+                config = getattr(runtime, "config", None)
+                base = config.to_limits_dict() if config is not None else {}
+                max_tokens = int(base.get("max_tokens", DEFAULT_MAX_TOKENS) or DEFAULT_MAX_TOKENS)
+            except Exception:
+                max_tokens = DEFAULT_MAX_TOKENS
+
+        agent_vars = {
+            "context": {
+                "task": task,
+                "messages": [],
+            },
+            "scratchpad": {
+                "iteration": 0,
+                "max_iterations": max_iterations,
+                "max_history_messages": max_history_messages,
+            },
+            "_runtime": {"inbox": []},
+            "_temp": {},
+            # Canonical _limits namespace for runtime awareness
+            "_limits": {
+                "max_iterations": max_iterations,
+                "current_iteration": 0,
+                "max_tokens": max_tokens,
+                "max_history_messages": max_history_messages,
+                "estimated_tokens_used": 0,
+                "warn_iterations_pct": 80,
+                "warn_tokens_pct": 80,
+            },
+        }
+
+        # Inject any additional context from the flow
+        if input_key and isinstance(run.vars.get(input_key), dict):
+            # Merge additional context
+            for k, v in run.vars.get(input_key, {}).items():
+                if k not in ("task", "query"):
+                    agent_vars["context"][k] = v
+
+        # Use START_SUBWORKFLOW effect to run agent durably
+        return StepPlan(
+            node_id=node_id,
+            effect=Effect(
+                type=EffectType.START_SUBWORKFLOW,
+                payload={
+                    "workflow_id": agent.workflow.workflow_id,
+                    "vars": agent_vars,
+                    "async": False,  # Sync: wait for completion
+                },
+                result_key=output_key or f"_flow.{node_id}.result",
+            ),
+            next_node=next_node,
+        )
+
+    return handler

abstractruntime/visualflow_compiler/adapters/context_adapter.py

@@ -0,0 +1,109 @@
+"""Context node adapters (active context helpers).
+
+These nodes mutate `run.vars["context"]` durably so pause/resume works and other
+nodes (Agent/Subflow/LLM_CALL with use_context) can read the updated history.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+
+def _persist_node_output(run_vars: Dict[str, Any], node_id: str, value: Dict[str, Any]) -> None:
+    temp = run_vars.get("_temp")
+    if not isinstance(temp, dict):
+        temp = {}
+        run_vars["_temp"] = temp
+    persisted = temp.get("node_outputs")
+    if not isinstance(persisted, dict):
+        persisted = {}
+        temp["node_outputs"] = persisted
+    persisted[node_id] = value
+
+
+def create_add_message_node_handler(
+    *,
+    node_id: str,
+    next_node: Optional[str],
+    data_aware_handler: Optional[Callable[[Any], Any]],
+    flow: Any,
+) -> Callable:
+    """Create a handler for `add_message` visual nodes.
+
+    Contract:
+    - Inputs:
+      - `role`: message role
+      - `content`: message content
+    - Behavior:
+      - builds a canonical message object (timestamp + metadata.message_id)
+      - appends it to `run.vars.context.messages` (durable)
+      - does NOT clobber `_last_output` (pass-through)
+    """
+    from abstractruntime.core.models import StepPlan
+    from ..compiler import _sync_effect_results_to_node_outputs
+
+    def handler(run: Any, ctx: Any) -> "StepPlan":
+        del ctx
+        if flow is not None and hasattr(flow, "_node_outputs") and hasattr(flow, "_data_edge_map"):
+            _sync_effect_results_to_node_outputs(run, flow)
+
+        last_output = run.vars.get("_last_output", {})
+        resolved = data_aware_handler(last_output) if callable(data_aware_handler) else {}
+        payload = resolved if isinstance(resolved, dict) else {}
+
+        message = payload.get("message")
+        if not isinstance(message, dict):
+            # Fallback: build a minimal message object if the visual handler did not.
+            role = payload.get("role")
+            role_str = role if isinstance(role, str) else str(role or "user")
+            content = payload.get("content")
+            content_str = content if isinstance(content, str) else str(content or "")
+
+            try:
+                from datetime import datetime, timezone
+
+                timestamp = datetime.now(timezone.utc).isoformat()
+            except Exception:
+                from datetime import datetime
+
+                timestamp = datetime.utcnow().isoformat() + "Z"
+
+            import uuid
+
+            message = {
+                "role": role_str,
+                "content": content_str,
+                "timestamp": timestamp,
+                "metadata": {"message_id": f"msg_{uuid.uuid4().hex}"},
+            }
+
+        ctx_ns = run.vars.get("context")
+        if not isinstance(ctx_ns, dict):
+            ctx_ns = {}
+            run.vars["context"] = ctx_ns
+
+        msgs = ctx_ns.get("messages")
+        if not isinstance(msgs, list):
+            msgs = []
+            ctx_ns["messages"] = msgs
+
+        msgs.append(message)
+
+        # Persist node outputs for pause/resume and data-edge reads.
+        _persist_node_output(
+            run.vars,
+            node_id,
+            {
+                "message": message,
+                "context": ctx_ns,
+                "task": ctx_ns.get("task") if isinstance(ctx_ns.get("task"), str) else str(ctx_ns.get("task") or ""),
+                "messages": list(msgs),
+            },
+        )
+
+        if next_node:
+            return StepPlan(node_id=node_id, next_node=next_node)
+        return StepPlan(node_id=node_id, complete_output={"success": True, "message": message})
+
+    return handler
+