lionagi 0.13.3__py3-none-any.whl → 0.13.4__py3-none-any.whl

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/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/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/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/protocols/graph/__init__.py

@@ -1,3 +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/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)
 
 

lionagi/session/__init__.py

@@ -1,3 +1,8 @@
 # Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
+
+from .branch import Branch
+from .session import Session
+
+__all__ = ["Branch", "Session"]

lionagi/session/session.py

@@ -16,6 +16,8 @@ from lionagi.protocols.types import (
     ActionManager,
     Communicatable,
     Exchange,
+    Graph,
+    IDType,
     MailManager,
     MessageFlag,
     Node,
@@ -303,6 +305,51 @@ class Session(Node, Communicatable, Relational):
             except Exception as e:
                 raise ValueError(f"Failed to collect mail. Error: {e}")
 
+    async def flow(
+        self,
+        graph: Graph,
+        *,
+        context: dict[str, Any] | None = None,
+        parallel: bool = True,
+        max_concurrent: int = 5,
+        verbose: bool = False,
+        default_branch: Branch | ID.Ref | None = None,
+    ) -> dict[str, Any]:
+        """
+        Execute a graph-based workflow using multi-branch orchestration.
+
+        This is a Session-native operation that coordinates execution across
+        multiple branches for parallel processing.
+
+        Args:
+            graph: The workflow graph containing Operation nodes
+            context: Initial context for the workflow
+            parallel: Whether to execute independent operations in parallel
+            max_concurrent: Maximum concurrent operations (branches)
+            verbose: Enable verbose logging
+            default_branch: Branch to use as default (defaults to self.default_branch)
+            **kwargs: Additional arguments passed to operations
+
+        Returns:
+            Execution results with completed operations and final context
+        """
+        from lionagi.operations.flow import flow
+
+        # Use specified branch or session's default
+        branch = default_branch or self.default_branch
+        if isinstance(branch, (str, IDType)):
+            branch = self.branches[branch]
+
+        return await flow(
+            branch=branch,
+            graph=graph,
+            context=context,
+            parallel=parallel,
+            max_concurrent=max_concurrent,
+            verbose=verbose,
+            session=self,
+        )
+
 
 __all__ = ["Session"]
 # File: autoos/session/session.py

lionagi/settings.py

@@ -18,7 +18,7 @@ CACHED_CONFIG = {
 
 CHAT_IMODEL_CONFIG = {
     "provider": "openai",
-    "model": "gpt-4o",
+    "model": "gpt-4.1-nano",
     "base_url": "https://api.openai.com/v1",
     "endpoint": "chat/completions",
     "api_key": "OPENAI_API_KEY",
@@ -31,7 +31,7 @@ CHAT_IMODEL_CONFIG = {
 
 PARSE_IMODEL_CONFIG = {
     "provider": "openai",
-    "model": "gpt-4o-mini",
+    "model": "gpt-4.1-nano",
     "base_url": "https://api.openai.com/v1",
     "endpoint": "chat/completions",
     "api_key": "OPENAI_API_KEY",

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.13.3"
+__version__ = "0.13.4"

{lionagi-0.13.3.dist-info → lionagi-0.13.4.dist-info}/METADATA

@@ -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.dist-info → lionagi-0.13.4.dist-info}/RECORD

@@ -2,11 +2,11 @@ lionagi/__init__.py,sha256=wg2mLxXbJ5pQKrRMIEoQ0_BlHrxjuR1zmc3SAYN7PBc,513
 lionagi/_class_registry.py,sha256=pfUO1DjFZIqr3OwnNMkFqL_fiEBrrf8-swkGmP_KDLE,3112
 lionagi/_errors.py,sha256=S02keQTY2IMkTvpLe00v7P7b8QNJ0PrZ1KWmQWCEQAA,500
 lionagi/_types.py,sha256=iDdYewsP9rDrM7QY19_NDTcWUk7swp8vnGCrloHMtUM,53
-lionagi/config.py,sha256=dAhDFKtaaSfn6WT9dwX9Vd4TWWs6-Su1FgYIrFgYcgc,3709
+lionagi/config.py,sha256=Dxs5FA9UCv1YX5H54qOJcPsDrIF9wFokWEPZ212eH-k,3715
 lionagi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/settings.py,sha256=74IgATy0-LIuj6pWf2b-eB0ZpnWFt9OcLNifU97HDX8,1626
+lionagi/settings.py,sha256=HDuKCEJCpc4HudKodBnhoQUGuTGhRHdlIFhbtf3VBtY,1633
 lionagi/utils.py,sha256=8zCdJHKbDJv2WSzAAiFnMSpvfyZb9RnmfSNaMEqdTJE,79003
-lionagi/version.py,sha256=aiCDTKDs80gZjvqiXYkxhq_MLi4Du0L9OByDr6ZEVV4,23
+lionagi/version.py,sha256=6QrvAtwvKbCiayGvUAi82njNCcPWhkMC4sBk4mXPkIc,23
 lionagi/fields/__init__.py,sha256=8oU7Vfk-fKiULFKqhM6VpJMqdZcVXPTM7twVfNDN_SQ,603
 lionagi/fields/action.py,sha256=OziEpbaUeEVo34KdtbzDxXJBgkf3QLxlcKIQAfHe4O0,5791
 lionagi/fields/base.py,sha256=5CJc7j8kTTWzXwpYzkSAFzx4BglABfx3AElIATKB7bg,3857
@@ -82,8 +82,10 @@ lionagi/models/model_params.py,sha256=zVU-PHp3skjK5ZVjpsPs1k_VJiS8X0hgct0xs6Z6W_
 lionagi/models/note.py,sha256=okWJL4mGqt0bUVxHRyqsfJr7tEh6wwgYhF1CegxudIA,12202
 lionagi/models/operable_model.py,sha256=fXbcpBjO-SoaeF8fn-F1_KIcYw9_L73VIUM1BDg5hj4,19905
 lionagi/models/schema_model.py,sha256=ghRIM8aBNaToAknwNlhQKpuKXcwzyCw5pDE31bVKxs0,667
-lionagi/operations/__init__.py,sha256=2HExKTx2J3iKWsvS9YaF6i5SZgqcpAJkVmWbi2H5A5U,134
+lionagi/operations/__init__.py,sha256=CwqpPnj6C53mFFu86VtA_JYpVFPBvKKTiA_VwKxLGKk,203
+lionagi/operations/flow.py,sha256=iERw_owbu3tgh_6a35aV2US7r2KaztQ0e54Fu2ETm1w,15074
 lionagi/operations/manager.py,sha256=7KD6NMWqYJHCPI2LumDRwGinF8WYKFjrr3bsNUi9xzI,564
+lionagi/operations/node.py,sha256=JNJpn_LUP_46F7C8DcvwAg6rzlaRKzs9RcVGQakARyU,3066
 lionagi/operations/types.py,sha256=fM8HphnbBifMzhoKKvdl3JxGCBHlEGPJEYkLWj9b7vE,704
 lionagi/operations/utils.py,sha256=Cl4HuWQ1nCGkTexwOtDx7fpEWMc2L3ZQMCqylRBDy74,1219
 lionagi/operations/ReAct/ReAct.py,sha256=uoJnFMoPP1kzzmgLDFNBwEbWdfGNfG37IT22N1AM-hE,13504
@@ -133,7 +135,7 @@ lionagi/protocols/generic/log.py,sha256=vepclOaY3fdR1QgFDj9usOffsx9T-9PbgwXjTvm6
 lionagi/protocols/generic/pile.py,sha256=SVy4fk4pVDv3jS1GiLZo9fO_Nk53_ojfsQbUzM_Bkao,33531
 lionagi/protocols/generic/processor.py,sha256=GQ_j_5f4UE-jJeqIJ9L2NdicpZnu50DSP1mvxlc7O_4,10381
 lionagi/protocols/generic/progression.py,sha256=qlITq1qzV119iR5qR__fBAzV489S7d4t20E8uDRicEw,15189
-lionagi/protocols/graph/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
+lionagi/protocols/graph/__init__.py,sha256=UPu3OmUpjSgX2aBuBJUdG2fppGlfqAH96hU0qIMBMp0,253
 lionagi/protocols/graph/edge.py,sha256=lgxeceoazM4Jl2Un_owLpJOanqw2m4XPk3-dXGp1u8g,5229
 lionagi/protocols/graph/graph.py,sha256=fhPc_ogXkxbBrM0_En9QTDVM7fHA_LzURCdmDRuBlHE,10217
 lionagi/protocols/graph/node.py,sha256=_bQ9h_s_X6dVyV4pueEfiKiFapOkDL-HuH2MboUekYI,4250
@@ -178,7 +180,7 @@ lionagi/service/connections/match_endpoint.py,sha256=K3I4vU6GH6utlEArlyDFUmNdnp9
 lionagi/service/connections/providers/__init__.py,sha256=3lzOakDoBWmMaNnT2g-YwktPKa_Wme4lnPRSmOQfayY,105
 lionagi/service/connections/providers/anthropic_.py,sha256=SUPnw2UqjY5wuHXLHas6snMTzhQ-UuixvPYbkVnXn34,3083
 lionagi/service/connections/providers/claude_code_.py,sha256=KAx7zK_mUwroPHwB5NfkHl0VYOxarM_LOOJUyD4NBQQ,17437
-lionagi/service/connections/providers/claude_code_cli.py,sha256=U9JtP6kdL-lkw9IIwF-Z8QIrbLWLjVInRI53ZfQulkQ,14610
+lionagi/service/connections/providers/claude_code_cli.py,sha256=C9gjZ_LzhlEBLZptlRjnlkVRIdPcPys5Aa1uKsPeAdg,14582
 lionagi/service/connections/providers/exa_.py,sha256=GGWaD9jd5gKM257OfUaIBBKIqR1NrNcBE67p_7JbK7g,938
 lionagi/service/connections/providers/oai_.py,sha256=FmQMEmOY7H7dZd4og-_cdd1Unzy4lkIzMsTtEsm-yVE,4782
 lionagi/service/connections/providers/ollama_.py,sha256=jdx6dGeChwVk5TFfFRbpnrpKzj8YQZw6D5iWJ6zYmfk,4096
@@ -189,17 +191,17 @@ lionagi/service/third_party/anthropic_models.py,sha256=oqSPSlcayYG-fS5BLiLeTtkrp
 lionagi/service/third_party/exa_models.py,sha256=G_hnekcy-DillPLzMoDQ8ZisVAL8Mp7iMAK4xqAT_3w,5470
 lionagi/service/third_party/openai_models.py,sha256=sF-fQ726CnaDBgLY_r2NdPqc3GicPKhZjh5F8IfjBO0,501904
 lionagi/service/third_party/pplx_models.py,sha256=Nkm1ftESBa_NwP9ITBUNqLmAZ3Jh92aL732g_i6T8LQ,5947
-lionagi/session/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
+lionagi/session/__init__.py,sha256=kDypY6L3kGPnatAw7YNQAykgg-9MlIBnlhHExaXvt-c,202
 lionagi/session/branch.py,sha256=OzF8lftHXuI8ovS8I4iWet96XKHmJ0tA0rh7qvimw-0,69940
 lionagi/session/prompts.py,sha256=vLoodSB1vosCTujtU1hUWrm_OgsBAR_QZmru0yTIQ5A,3236
-lionagi/session/session.py,sha256=pLgNKE1eZBQ9LTPQRYKbteA86ebEKnA7Q-zaoKGpc1s,9171
+lionagi/session/session.py,sha256=otln9YGw-YBxkeW7N2qlhFztO9PpPP-erIW86_rSAzg,10770
 lionagi/tools/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/base.py,sha256=cld32pyjaTUdyiqZ8hNyJjWKAhcJ8RQNhgImI7R8b-E,1940
 lionagi/tools/types.py,sha256=XtJLY0m-Yi_ZLWhm0KycayvqMCZd--HxfQ0x9vFUYDE,230
 lionagi/tools/file/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/file/reader.py,sha256=0TdnfVGVCKuM58MmGM-NyVjhU9BFoitkNYEepdc0z_Y,9529
 lionagi/tools/memory/tools.py,sha256=zTGBenVsF8Wuh303kWntmQSGlAFKonHNdh5ePuQ26KE,15948
-lionagi-0.13.3.dist-info/METADATA,sha256=OWMWwGTjG1vBa1S2tel3RF_DoZdSOi-URz24Vle_YRY,20520
-lionagi-0.13.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.13.3.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.13.3.dist-info/RECORD,,
+lionagi-0.13.4.dist-info/METADATA,sha256=FW6nor2rxEtx_JZpmDx1Q5LGMYMH1ekB-qRVScIcVkE,20719
+lionagi-0.13.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.13.4.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.13.4.dist-info/RECORD,,