lionagi 0.13.3__tar.gz → 0.13.4__tar.gz

{lionagi-0.13.3 → lionagi-0.13.4}/.github/workflows/ci.yml

@@ -6,6 +6,9 @@ on:
   pull_request:
     branches: [ main, develop ]
 
+permissions:
+  contents: read
+
 jobs:
   test:
     runs-on: ubuntu-latest
@@ -52,6 +55,9 @@ jobs:
     needs: test
     runs-on: ubuntu-latest
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    permissions:
+      contents: read
+      packages: write
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python

{lionagi-0.13.3 → lionagi-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.13.3
+Version: 0.13.4
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -225,6 +225,7 @@ Requires-Dist: anyio>=4.8.0
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: json-repair>=0.47.8
+Requires-Dist: matplotlib>=3.9.0
 Requires-Dist: pillow>=11.0.0
 Requires-Dist: psutil>=7.0.0
 Requires-Dist: pydantic-settings>=2.8.0
@@ -273,7 +274,7 @@ Description-Content-Type: text/markdown
 
 # LION - Language InterOperable Network
 
-## An Intelligence Operating System SDK
+## An Agentic Intelligence SDK
 
 LionAGI is a robust framework for orchestrating multi-step AI operations with
 precise control. Bring together multiple models, advanced ReAct reasoning, tool
@@ -409,19 +410,21 @@ LionAGI now supports Anthropic's [Claude Code SDK](https://github.com/anthropics
 from lionagi import iModel, Branch
 
 # Create a Claude Code model
-coder = iModel(
+model = iModel(
     provider="claude_code",
-    endpoint="code",
-    model="claude-sonnet-4-20250514",
+    endpoint="query_cli",
+    model="sonnet",
     allowed_tools=["Write", "Read", "Edit"],  # Control which tools Claude can use
+    permission_mode = "bypassPermissions", # Bypass tool permission checks (use with caution!),
+    verbose_output=True,  # Enable detailed output for debugging
 )
 
 # Start a coding session
-branch = Branch(chat_model=coder)
-response = await branch.chat("Create a Python function to calculate fibonacci numbers")
+branch = Branch(chat_model=model)
+response = await branch.communicate("Explain the architecture of protocols, operations, and branch")
 
 # Claude Code maintains session context automatically
-response2 = await branch.chat("Now optimize it for performance")
+response2 = await branch.communicate("how do these parts form lionagi system")
 ```
 
 Key features:

{lionagi-0.13.3 → lionagi-0.13.4}/README.md

@@ -8,7 +8,7 @@
 
 # LION - Language InterOperable Network
 
-## An Intelligence Operating System SDK
+## An Agentic Intelligence SDK
 
 LionAGI is a robust framework for orchestrating multi-step AI operations with
 precise control. Bring together multiple models, advanced ReAct reasoning, tool
@@ -144,19 +144,21 @@ LionAGI now supports Anthropic's [Claude Code SDK](https://github.com/anthropics
 from lionagi import iModel, Branch
 
 # Create a Claude Code model
-coder = iModel(
+model = iModel(
     provider="claude_code",
-    endpoint="code",
-    model="claude-sonnet-4-20250514",
+    endpoint="query_cli",
+    model="sonnet",
     allowed_tools=["Write", "Read", "Edit"],  # Control which tools Claude can use
+    permission_mode = "bypassPermissions", # Bypass tool permission checks (use with caution!),
+    verbose_output=True,  # Enable detailed output for debugging
 )
 
 # Start a coding session
-branch = Branch(chat_model=coder)
-response = await branch.chat("Create a Python function to calculate fibonacci numbers")
+branch = Branch(chat_model=model)
+response = await branch.communicate("Explain the architecture of protocols, operations, and branch")
 
 # Claude Code maintains session context automatically
-response2 = await branch.chat("Now optimize it for performance")
+response2 = await branch.communicate("how do these parts form lionagi system")
 ```
 
 Key features:

{lionagi-0.13.3 → lionagi-0.13.4}/lionagi/config.py

@@ -68,7 +68,7 @@ class AppSettings(BaseSettings, frozen=True):
     LIONAGI_EMBEDDING_MODEL: str = "text-embedding-3-small"
 
     LIONAGI_CHAT_PROVIDER: str = "openai"
-    LIONAGI_CHAT_MODEL: str = "gpt-4o"
+    LIONAGI_CHAT_MODEL: str = "gpt-4.1-nano"
 
     # default storage
     LIONAGI_AUTO_STORE_EVENT: bool = False

{lionagi-0.13.3 → lionagi-0.13.4}/lionagi/operations/__init__.py

@@ -2,4 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .flow import flow
+from .node import BranchOperations, Operation
 from .types import *

lionagi-0.13.4/lionagi/operations/flow.py

@@ -0,0 +1,436 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+from typing import Any
+
+from lionagi.operations.node import Operation
+from lionagi.protocols.types import Graph, Node
+from lionagi.session.branch import Branch
+from lionagi.session.session import Session
+from lionagi.utils import to_dict
+
+
+async def flow(
+    branch: Branch,
+    graph: Graph,
+    *,
+    context: dict[str, Any] | None = None,
+    parallel: bool = True,
+    max_concurrent: int = 5,
+    verbose: bool = False,
+    session: Session | None = None,
+) -> dict[str, Any]:
+    """
+    Execute a graph-based workflow using the branch's operations.
+
+    For simple graphs, executes directly on the branch.
+    For parallel execution, uses session for coordination.
+
+    Args:
+        branch: The branch to execute operations on
+        graph: The workflow graph containing Operation nodes
+        context: Initial context
+        parallel: Whether to execute independent operations in parallel
+        max_concurrent: Max concurrent operations
+        verbose: Enable verbose logging
+        session: Optional session for multi-branch parallel execution
+
+    Returns:
+        Execution results with completed operations and final context
+    """
+    # Validate graph
+    if not graph.is_acyclic():
+        raise ValueError("Graph must be acyclic for flow execution")
+
+    # Simple sequential execution on single branch
+    if not parallel or max_concurrent == 1:
+        return await _execute_sequential(branch, graph, context, verbose)
+
+    # Parallel execution using session
+    if session is None:
+        # Create temporary session for this flow
+        from lionagi.session.session import Session
+
+        session = Session()
+        session.branches.include(branch)
+        session.default_branch = branch
+
+    return await _execute_parallel(
+        session, graph, context, max_concurrent, verbose
+    )
+
+
+async def _execute_sequential(
+    branch: Branch, graph: Graph, context: dict[str, Any] | None, verbose: bool
+) -> dict[str, Any]:
+    """Execute graph sequentially on a single branch."""
+    completed = []
+    results = {}
+    execution_context = context or {}
+
+    # Get execution order (topological sort)
+    execution_order = _topological_sort(graph)
+
+    for node_id in execution_order:
+        node = graph.internal_nodes[node_id]
+
+        if not isinstance(node, Operation):
+            continue
+
+        # Check dependencies using set for fast lookup
+        completed_set = set(completed)
+
+        # Check if dependencies and conditions are satisfied
+        if not await _dependencies_satisfied_async(
+            node, graph, completed_set, results, execution_context
+        ):
+            continue
+
+        predecessors = graph.get_predecessors(node)
+
+        # Update operation context with predecessors
+        if predecessors:
+            pred_context = {}
+            for pred in predecessors:
+                if pred.id in results:
+                    result = results[pred.id]
+                # Use to_dict for proper serialization of complex types only
+                if result is not None and not isinstance(
+                    result, (str, int, float, bool)
+                ):
+                    result = to_dict(result, recursive=True)
+                pred_context[f"{pred.id}_result"] = result
+
+            if "context" not in node.parameters:
+                node.parameters["context"] = pred_context
+            else:
+                node.parameters["context"].update(pred_context)
+
+        # Add execution context
+        if execution_context:
+            if "context" not in node.parameters:
+                node.parameters["context"] = execution_context.copy()
+            else:
+                node.parameters["context"].update(execution_context)
+
+        # Execute operation
+        if verbose:
+            print(f"Executing operation: {node.id}")
+
+        await node.invoke(branch)
+
+        completed.append(node.id)
+        results[node.id] = node.response
+
+        # Update execution context
+        if isinstance(node.response, dict) and "context" in node.response:
+            execution_context.update(node.response["context"])
+
+    return {
+        "completed_operations": completed,
+        "operation_results": results,
+        "final_context": execution_context,
+    }
+
+
+async def _execute_parallel(
+    session: Session,
+    graph: Graph,
+    context: dict[str, Any] | None,
+    max_concurrent: int,
+    verbose: bool,
+) -> dict[str, Any]:
+    """Execute graph in parallel using multiple branches."""
+    results = {}
+    execution_context = context or {}
+    completed = []  # Track completed operations
+
+    # Get operation nodes in topological order
+    operation_nodes = []
+    execution_order = _topological_sort(graph)
+    for node_id in execution_order:
+        node = graph.internal_nodes.get(node_id)
+        if isinstance(node, Operation):
+            operation_nodes.append(node)
+
+    # Use session branches context manager for safe parallel execution
+    async with session.branches:
+        # Create a pool of worker branches
+        worker_branches = []
+        for i in range(min(max_concurrent, len(operation_nodes))):
+            if i == 0:
+                worker_branches.append(session.default_branch)
+            else:
+                worker_branches.append(session.split(session.default_branch))
+
+        # Process nodes in dependency order
+        remaining_nodes = {node.id for node in operation_nodes}
+        executing_tasks = {}  # node_id -> asyncio.Task
+        blocked_nodes = set()  # Nodes that have been checked and found blocked
+
+        max_iterations = 1000  # Prevent infinite loops
+        iteration = 0
+
+        while (
+            remaining_nodes or executing_tasks
+        ) and iteration < max_iterations:
+            iteration += 1
+
+            # Check for completed tasks
+            completed_in_round = []
+            for node_id, task in list(executing_tasks.items()):
+                if task.done():
+                    try:
+                        result = await task
+                        results[node_id] = result
+                        completed.append(node_id)
+                        completed_in_round.append(node_id)
+                        if verbose:
+                            print(f"Completed operation: {node_id}")
+                    except Exception as e:
+                        if verbose:
+                            print(f"Operation {node_id} failed: {e}")
+                        results[node_id] = {"error": str(e)}
+                        completed.append(node_id)
+                        completed_in_round.append(node_id)
+                    finally:
+                        del executing_tasks[node_id]
+
+            # Remove completed from remaining
+            remaining_nodes -= set(completed_in_round)
+
+            # If new completions, clear blocked nodes to re-check
+            if completed_in_round:
+                blocked_nodes.clear()
+
+            # Find nodes ready to execute (skip already blocked nodes)
+            ready_nodes = []
+            completed_set = set(completed)
+            newly_blocked = []
+
+            for node in operation_nodes:
+                if (
+                    node.id in remaining_nodes
+                    and node.id not in executing_tasks
+                    and node.id not in blocked_nodes
+                    and len(executing_tasks) < max_concurrent
+                ):
+                    if await _dependencies_satisfied_async(
+                        node, graph, completed_set, results, execution_context
+                    ):
+                        ready_nodes.append(node)
+                    else:
+                        newly_blocked.append(node.id)
+
+            # Update blocked nodes
+            blocked_nodes.update(newly_blocked)
+
+            # If no ready nodes but we have remaining and no executing tasks, we're stuck
+            if not ready_nodes and remaining_nodes and not executing_tasks:
+                if verbose:
+                    print(
+                        f"Deadlock detected: {len(remaining_nodes)} nodes cannot execute"
+                    )
+                    remaining_node_names = [
+                        n.operation
+                        for n in operation_nodes
+                        if n.id in remaining_nodes
+                    ]
+                    print(f"Remaining operations: {remaining_node_names}")
+                # Mark remaining nodes as failed
+                for node in operation_nodes:
+                    if node.id in remaining_nodes:
+                        results[node.id] = {
+                            "error": "Blocked by unsatisfied conditions"
+                        }
+                        completed.append(node.id)
+                break
+
+            # Start execution for ready nodes
+            started_count = 0
+            for node in ready_nodes:
+                if len(executing_tasks) >= max_concurrent:
+                    break
+
+                # Get an available branch (round-robin)
+                branch_idx = len(executing_tasks) % len(worker_branches)
+                node_branch = worker_branches[branch_idx]
+
+                # Check if node specifies a branch
+                branch_id = node.parameters.get("branch_id")
+                if branch_id:
+                    try:
+                        node_branch = session.branches[branch_id]
+                    except:
+                        pass  # Use the selected worker branch
+
+                # Create task for this node
+                task = asyncio.create_task(
+                    _execute_node_async(
+                        node,
+                        node_branch,
+                        graph,
+                        results,
+                        execution_context,
+                        verbose,
+                    )
+                )
+                executing_tasks[node.id] = task
+                started_count += 1
+
+                if verbose:
+                    branch_name = (
+                        getattr(node_branch, "name", None) or node_branch.id
+                    )
+                    print(
+                        f"Started operation {node.id} on branch: {branch_name}"
+                    )
+
+            # If we started new tasks or have executing tasks, wait for some to complete
+            if started_count > 0 or executing_tasks:
+                # Wait for at least one task to complete before next iteration
+                if executing_tasks:
+                    done, pending = await asyncio.wait(
+                        executing_tasks.values(),
+                        return_when=asyncio.FIRST_COMPLETED,
+                    )
+                else:
+                    await asyncio.sleep(0.01)
+            elif not remaining_nodes:
+                # All done
+                break
+
+        if iteration >= max_iterations:
+            raise RuntimeError(
+                f"Flow execution exceeded maximum iterations ({max_iterations})"
+            )
+
+    return {
+        "completed_operations": completed,
+        "operation_results": results,
+        "final_context": execution_context,
+    }
+
+
+async def _execute_node_async(
+    node: Operation,
+    branch: Branch,
+    graph: Graph,
+    results: dict[str, Any],
+    execution_context: dict[str, Any],
+    verbose: bool,
+) -> Any:
+    """Execute a single node asynchronously."""
+    # Update operation context with predecessors
+    predecessors = graph.get_predecessors(node)
+    if predecessors:
+        pred_context = {}
+        for pred in predecessors:
+            if pred.id in results:
+                result = results[pred.id]
+                # Use to_dict for proper serialization of complex types only
+                if result is not None and not isinstance(
+                    result, (str, int, float, bool)
+                ):
+                    result = to_dict(result, recursive=True)
+                pred_context[f"{pred.id}_result"] = result
+
+        if "context" not in node.parameters:
+            node.parameters["context"] = pred_context
+        else:
+            node.parameters["context"].update(pred_context)
+
+    # Add execution context
+    if execution_context:
+        if "context" not in node.parameters:
+            node.parameters["context"] = execution_context.copy()
+        else:
+            node.parameters["context"].update(execution_context)
+
+    # Execute the operation
+    await node.invoke(branch)
+    result = node.response
+
+    # Update execution context if needed
+    if isinstance(result, dict) and "context" in result:
+        execution_context.update(result["context"])
+
+    return result
+
+
+def _topological_sort(graph: Graph) -> list[str]:
+    """Get topological ordering of graph nodes."""
+    visited = set()
+    stack = []
+
+    def visit(node_id: str):
+        if node_id in visited:
+            return
+        visited.add(node_id)
+
+        successors = graph.get_successors(graph.internal_nodes[node_id])
+        for successor in successors:
+            visit(successor.id)
+
+        stack.append(node_id)
+
+    for node in graph.internal_nodes:
+        if node.id not in visited:
+            visit(node.id)
+
+    return stack[::-1]
+
+
+async def _dependencies_satisfied_async(
+    node: Node,
+    graph: Graph,
+    completed: set[str],
+    results: dict[str, Any],
+    execution_context: dict[str, Any] | None = None,
+) -> bool:
+    """Check if node dependencies are satisfied and edge conditions pass."""
+    # Get all incoming edges to this node
+    incoming_edges = []
+    for edge in graph.internal_edges:
+        if edge.tail == node.id:
+            incoming_edges.append(edge)
+
+    # If no incoming edges, node can execute
+    if not incoming_edges:
+        return True
+
+    # Check each incoming edge
+    at_least_one_satisfied = False
+    for edge in incoming_edges:
+        # Check if predecessor is completed
+        if edge.head not in completed:
+            # If edge has no condition, we need to wait for predecessor
+            if not edge.condition:
+                continue
+            # If edge has condition but predecessor not complete, skip
+            continue
+
+        # Predecessor is completed
+        if edge.condition:
+            # Evaluate condition
+            # Get the result - don't use to_dict if it's already a simple type
+            result_value = results.get(edge.head)
+            if result_value is not None and not isinstance(
+                result_value, (str, int, float, bool)
+            ):
+                result_value = to_dict(result_value, recursive=True)
+
+            ctx = {"result": result_value, "context": execution_context or {}}
+            try:
+                if await edge.condition.apply(ctx):
+                    at_least_one_satisfied = True
+            except Exception as e:
+                # Condition evaluation failed
+                continue
+        else:
+            # No condition, edge is satisfied
+            at_least_one_satisfied = True
+
+    return at_least_one_satisfied

lionagi-0.13.4/lionagi/operations/node.py

@@ -0,0 +1,107 @@
+import asyncio
+import logging
+from typing import Any, Literal
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from lionagi.protocols.types import ID, Event, EventStatus, IDType, Node
+from lionagi.session.branch import Branch
+
+BranchOperations = Literal[
+    "chat",
+    "operate",
+    "communicate",
+    "parse",
+    "ReAct",
+    "select",
+    "translate",
+    "interpret",
+    "act",
+    "ReActStream",
+    "instruct",
+]
+
+logger = logging.getLogger("operation")
+
+
+class Operation(Node, Event):
+    operation: BranchOperations
+    parameters: dict[str, Any] | BaseModel = Field(
+        default_factory=dict, description="Parameters for the operation"
+    )
+
+    @property
+    def branch_id(self) -> IDType | None:
+        if a := self.metadata.get("branch_id"):
+            return ID.get_id(a)
+
+    @branch_id.setter
+    def branch_id(self, value: str | UUID | IDType | None):
+        if value is None:
+            self.metadata.pop("branch_id", None)
+        else:
+            self.metadata["branch_id"] = str(value)
+
+    @property
+    def graph_id(self) -> str | None:
+        return self.metadata.get("graph_id")
+
+    @graph_id.setter
+    def graph_id(self, value: str | UUID | IDType | None):
+        if value is None:
+            self.metadata.pop("graph_id", None)
+        else:
+            self.metadata["graph_id"] = str(value)
+
+    @property
+    def request(self) -> dict:
+        # Convert parameters to dict if it's a BaseModel
+        params = self.parameters
+        if hasattr(params, "model_dump"):
+            params = params.model_dump()
+        elif hasattr(params, "dict"):
+            params = params.dict()
+
+        return params if isinstance(params, dict) else {}
+
+    @property
+    def response(self):
+        """Get the response from the execution."""
+        return self.execution.response if self.execution else None
+
+    async def invoke(self, branch: Branch):
+        meth = getattr(branch, self.operation, None)
+        if meth is None:
+            raise ValueError(f"Unsupported operation type: {self.operation}")
+
+        start = asyncio.get_event_loop().time()
+
+        try:
+            self.execution.status = EventStatus.PROCESSING
+            self.branch_id = branch.id
+            response = await self._invoke(meth)
+
+            self.execution.response = response
+            self.execution.status = EventStatus.COMPLETED
+
+        except asyncio.CancelledError:
+            self.execution.error = "Operation cancelled"
+            self.execution.status = EventStatus.FAILED
+            raise
+
+        except Exception as e:
+            self.execution.error = str(e)
+            self.execution.status = EventStatus.FAILED
+            logger.error(f"Operation failed: {e}")
+
+        finally:
+            self.execution.duration = asyncio.get_event_loop().time() - start
+
+    async def _invoke(self, meth):
+        if self.operation == "ReActStream":
+            res = []
+            async for i in meth(**self.request):
+                res.append(i)
+            return res
+        return await meth(**self.request)

lionagi-0.13.4/lionagi/protocols/graph/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .edge import Edge, EdgeCondition
+from .graph import Graph
+from .node import Node
+
+__all__ = ["Edge", "EdgeCondition", "Graph", "Node"]

{lionagi-0.13.3 → lionagi-0.13.4}/lionagi/service/connections/providers/claude_code_cli.py

@@ -196,10 +196,7 @@ def _pp_tool_use(tu: dict[str, Any], theme) -> None:
 def _pp_tool_result(tr: dict[str, Any], theme) -> None:
     body_preview = shorten(str(tr["content"]).replace("\n", " "), 130)
     status = "ERR" if tr.get("is_error") else "OK"
-    body = (
-        f"- 📄 Tool Result({tr['tool_use_id']}) - {status}\n\n"
-        f"\tcontent: {body_preview}"
-    )
+    body = f"- 📄 Tool Result({tr['tool_use_id']}) - {status}\n\n\tcontent: {body_preview}"
     print_readable(body, border=False, panel=False, theme=theme)