abstractflow 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

abstractflow/__init__.py

@@ -1,104 +1,84 @@
+"""AbstractFlow - Multi-agent orchestration layer for the Abstract Framework.
+
+AbstractFlow enables composition of agents into pipelines and coordinates
+their execution via AbstractRuntime. It provides:
+
+- Flow: Declarative flow definition with nodes and edges
+- FlowRunner: High-level interface for running flows
+- compile_flow: Convert Flow to WorkflowSpec for direct runtime usage
+
+Example:
+    >>> from abstractflow import Flow, FlowRunner
+    >>>
+    >>> # Define a simple flow
+    >>> flow = Flow("my_pipeline")
+    >>> flow.add_node("step1", lambda x: x * 2, input_key="value", output_key="doubled")
+    >>> flow.add_node("step2", lambda x: x + 10, input_key="doubled", output_key="result")
+    >>> flow.add_edge("step1", "step2")
+    >>> flow.set_entry("step1")
+    >>>
+    >>> # Run the flow
+    >>> runner = FlowRunner(flow)
+    >>> result = runner.run({"value": 5})
+    >>> print(result)  # {'result': 20, 'success': True}
+
+For agent-based flows:
+    >>> from abstractflow import Flow, FlowRunner
+    >>> from abstractagent import create_react_agent
+    >>>
+    >>> planner = create_react_agent(provider="ollama", model="qwen3:4b")
+    >>> executor = create_react_agent(provider="ollama", model="qwen3:4b")
+    >>>
+    >>> flow = Flow("plan_and_execute")
+    >>> flow.add_node("plan", planner, output_key="plan")
+    >>> flow.add_node("execute", executor, input_key="plan")
+    >>> flow.add_edge("plan", "execute")
+    >>> flow.set_entry("plan")
+    >>>
+    >>> runner = FlowRunner(flow)
+    >>> result = runner.run({"context": {"task": "Build a REST API"}})
 """
-AbstractFlow - Diagram-based AI workflow generation.
 
-Built on top of AbstractCore for unified LLM provider access.
-"""
-
-__version__ = "0.1.0"
-__author__ = "AbstractFlow Team"
-__email__ = "contact@abstractflow.ai"
+__version__ = "0.3.0"
+__author__ = "Laurent-Philippe Albou"
+__email__ = "contact@abstractcore.ai"
 __license__ = "MIT"
 
-# Core imports that will be available when the package is fully implemented
-__all__ = [
-    "__version__",
-    "WorkflowBuilder",
-    "Node", 
-    "LLMNode",
-    "TextNode",
-    "ConditionalNode",
-    "TransformNode",
-]
-
-# Placeholder implementations - these will be replaced with actual implementations
-class WorkflowBuilder:
-    """
-    Visual workflow builder for creating AI-powered diagrams.
-    
-    This is a placeholder implementation. The full version will provide:
-    - Drag-and-drop workflow creation
-    - Real-time execution monitoring  
-    - Multi-provider LLM support via AbstractCore
-    - Export to various formats
-    """
-    
-    def __init__(self):
-        """Initialize a new workflow builder."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
-
-
-class Node:
-    """Base class for all workflow nodes."""
-    
-    def __init__(self, node_id: str):
-        """Initialize a workflow node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
+# Core classes
+from .core.flow import Flow, FlowNode, FlowEdge
 
+# Compiler
+from .compiler import compile_flow
 
-class LLMNode(Node):
-    """Node for LLM-based text generation and processing."""
-    
-    def __init__(self, provider: str, model: str, **kwargs):
-        """Initialize an LLM node with AbstractCore provider."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
+# Runner
+from .runner import FlowRunner
 
+# Adapters (for advanced usage)
+from .adapters import (
+    create_function_node_handler,
+    create_agent_node_handler,
+    create_subflow_node_handler,
+)
 
-class TextNode(Node):
-    """Node for text input/output operations."""
-    
-    def __init__(self, text_id: str):
-        """Initialize a text node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
-
-
-class ConditionalNode(Node):
-    """Node for conditional branching in workflows."""
-    
-    def __init__(self, condition: str):
-        """Initialize a conditional node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
-
-
-class TransformNode(Node):
-    """Node for data transformation operations."""
-    
-    def __init__(self, transform_func: str):
-        """Initialize a transform node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
+__all__ = [
+    # Version info
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    # Core classes
+    "Flow",
+    "FlowNode",
+    "FlowEdge",
+    # Compiler
+    "compile_flow",
+    # Runner
+    "FlowRunner",
+    # Adapters
+    "create_function_node_handler",
+    "create_agent_node_handler",
+    "create_subflow_node_handler",
+]
 
 
 def get_version() -> str:
@@ -107,5 +87,5 @@ def get_version() -> str:
 
 
 def is_development_version() -> bool:
-    """Check if this is a development/placeholder version."""
-    return True  # This will be False in the actual implementation
+    """Check if this is a development version."""
+    return False  # Now implemented!

abstractflow/__main__.py

@@ -8,3 +8,5 @@ from .cli import main
 
 if __name__ == "__main__":
     exit(main())
+
+

abstractflow/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",
+]

abstractflow/adapters/agent_adapter.py

@@ -0,0 +1,124 @@
+"""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:
+            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", 32768) or 32768)
+            except Exception:
+                max_tokens = 32768
+
+        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