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

lionagi/__init__.py

@@ -7,6 +7,9 @@ import logging
 from pydantic import BaseModel, Field
 
 from . import _types as types
+from .operations import Operation
+from .operations import OperationGraphBuilder as Builder
+from .operations import brainstorm, flow, plan
 from .service.imodel import iModel
 from .session.session import Branch, Session
 from .version import __version__
@@ -23,4 +26,9 @@ __all__ = (
     "BaseModel",
     "Field",
     "logger",
+    "Builder",
+    "Operation",
+    "brainstorm",
+    "flow",
+    "plan",
 )

lionagi/_types.py

@@ -1,2 +1,8 @@
 from .fields import *
+from .operations import (
+    BrainstormOperation,
+    ExpansionStrategy,
+    Operation,
+    PlanOperation,
+)
 from .protocols.types import *

lionagi/fields/__init__.py

@@ -1,4 +1,10 @@
-from .action import ActionRequestModel, ActionResponseModel
+from .action import (
+    ACTION_REQUESTS_FIELD,
+    ACTION_REQUIRED_FIELD,
+    ACTION_RESPONSES_FIELD,
+    ActionRequestModel,
+    ActionResponseModel,
+)
 from .base import (
     CodeSnippet,
     Outline,
@@ -8,8 +14,13 @@ from .base import (
     TextSnippet,
 )
 from .file import Documentation, File, Module, ResearchSummary
-from .instruct import Instruct, InstructResponse
-from .reason import Reason
+from .instruct import (
+    INSTRUCT_FIELD,
+    LIST_INSTRUCT_FIELD_MODEL,
+    Instruct,
+    InstructResponse,
+)
+from .reason import REASON_FIELD, Reason
 
 __all__ = (
     "ActionRequestModel",
@@ -27,4 +38,10 @@ __all__ = (
     "Instruct",
     "InstructResponse",
     "Reason",
+    "LIST_INSTRUCT_FIELD_MODEL",
+    "INSTRUCT_FIELD",
+    "ACTION_REQUESTS_FIELD",
+    "ACTION_RESPONSES_FIELD",
+    "ACTION_REQUIRED_FIELD",
+    "REASON_FIELD",
 )

lionagi/libs/schema/load_pydantic_model_from_schema.py

@@ -13,18 +13,16 @@ from pydantic import BaseModel, PydanticUserError
 
 from lionagi.utils import is_import_installed
 
-_HAS_DATAMODEL_CODE_GENERATOR = is_import_installed("datamodel-code-generator")
+_HAS_DATAMODEL_CODE_GENERATOR = is_import_installed("datamodel_code_generator")
 
-# Import at module level for easier mocking in tests
-if _HAS_DATAMODEL_CODE_GENERATOR:
-    from datamodel_code_generator import (
+try:
+    from datamodel_code_generator import (  # type: ignore[import]
         DataModelType,
         InputFileType,
         PythonVersion,
         generate,
     )
-else:
-    # Create dummy objects for when package is not installed
+except ImportError:
     DataModelType = None
     InputFileType = None
     PythonVersion = None

lionagi/operations/__init__.py

@@ -2,6 +2,21 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .brainstorm.brainstorm import BrainstormOperation, brainstorm
+from .builder import ExpansionStrategy, OperationGraphBuilder
 from .flow import flow
 from .node import BranchOperations, Operation
-from .types import *
+from .plan.plan import PlanOperation, plan
+
+__all__ = (
+    "ExpansionStrategy",
+    "OperationGraphBuilder",
+    "create_operation_graph",
+    "flow",
+    "BranchOperations",
+    "Operation",
+    "plan",
+    "PlanOperation",
+    "brainstorm",
+    "BrainstormOperation",
+)

lionagi/operations/builder.py

@@ -0,0 +1,664 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+OperationGraphBuilder: Incremental graph builder for multi-stage operations.
+
+Build → Execute → Expand → Execute → ...
+"""
+
+from enum import Enum
+from typing import Any
+
+from lionagi.operations.node import BranchOperations, Operation
+from lionagi.protocols.graph.edge import Edge
+from lionagi.protocols.graph.graph import Graph
+
+__all__ = (
+    "OperationGraphBuilder",
+    "ExpansionStrategy",
+)
+
+
+class ExpansionStrategy(Enum):
+    """Strategies for expanding operations."""
+
+    CONCURRENT = "concurrent"
+    SEQUENTIAL = "sequential"
+    SEQUENTIAL_CONCURRENT_CHUNK = "sequential_concurrent_chunk"
+    CONCURRENT_SEQUENTIAL_CHUNK = "concurrent_sequential_chunk"
+
+
+class OperationGraphBuilder:
+    """
+    Incremental graph builder that supports build → execute → expand cycles.
+
+    Unlike static builders, this maintains state and allows expanding the graph
+    based on execution results.
+
+    Examples:
+        >>> # Build initial graph
+        >>> builder = OperationGraphBuilder()
+        >>> builder.add_operation("operate", instruction="Generate ideas", num_instruct=5)
+        >>> graph = builder.get_graph()
+        >>>
+        >>> # Execute with session
+        >>> result = await session.flow(graph)
+        >>>
+        >>> # Expand based on results
+        >>> if hasattr(result, 'instruct_models'):
+        ...     builder.expand_from_result(
+        ...         result.instruct_models,
+        ...         source_node_id=builder.last_operation_id,
+        ...         operation="instruct"
+        ...     )
+        >>>
+        >>> # Get expanded graph and continue execution
+        >>> graph = builder.get_graph()
+        >>> final_result = await session.flow(graph)
+    """
+
+    def __init__(self, name: str = "DynamicGraph"):
+        """Initialize the incremental graph builder."""
+        self.name = name
+        self.graph = Graph()
+
+        # Track state
+        self._operations: dict[str, Operation] = {}  # All operations by ID
+        self._executed: set[str] = set()  # IDs of executed operations
+        self._current_heads: list[str] = []  # Current head nodes for linking
+        self.last_operation_id: str | None = None
+
+    def add_operation(
+        self,
+        operation: BranchOperations,
+        node_id: str | None = None,
+        depends_on: list[str] | None = None,
+        **parameters,
+    ) -> str:
+        """
+        Add an operation to the graph.
+
+        Args:
+            operation: The branch operation
+            node_id: Optional ID reference for this node
+            depends_on: List of node IDs this depends on
+            **parameters: Operation parameters
+
+        Returns:
+            ID of the created node
+        """
+        # Create operation node
+        node = Operation(operation=operation, parameters=parameters)
+
+        self.graph.add_node(node)
+        self._operations[node.id] = node
+
+        # Store reference if provided
+        if node_id:
+            # Add as metadata for easy lookup
+            node.metadata["reference_id"] = node_id
+
+        # Handle dependencies
+        if depends_on:
+            for dep_id in depends_on:
+                if dep_id in self._operations:
+                    edge = Edge(
+                        head=dep_id, tail=node.id, label=["depends_on"]
+                    )
+                    self.graph.add_edge(edge)
+        elif self._current_heads:
+            # Auto-link from current heads
+            for head_id in self._current_heads:
+                edge = Edge(head=head_id, tail=node.id, label=["sequential"])
+                self.graph.add_edge(edge)
+
+        # Update state
+        self._current_heads = [node.id]
+        self.last_operation_id = node.id
+
+        return node.id
+
+    def expand_from_result(
+        self,
+        items: list[Any],
+        source_node_id: str,
+        operation: BranchOperations,
+        strategy: ExpansionStrategy = ExpansionStrategy.CONCURRENT,
+        **shared_params,
+    ) -> list[str]:
+        """
+        Expand the graph based on execution results.
+
+        This is called after executing the graph to add new operations
+        based on results.
+
+        Args:
+            items: Items from result to expand (e.g., instruct_models)
+            source_node_id: ID of node that produced these items
+            operation: Operation to apply to each item
+            strategy: How to organize the expanded operations
+            **shared_params: Shared parameters for all operations
+
+        Returns:
+            List of new node IDs
+        """
+        if source_node_id not in self._operations:
+            raise ValueError(f"Source node {source_node_id} not found")
+
+        new_node_ids = []
+
+        # Create operation for each item
+        for i, item in enumerate(items):
+            # Extract parameters from item if it's a model
+            if hasattr(item, "model_dump"):
+                params = {**item.model_dump(), **shared_params}
+            else:
+                params = {**shared_params, "item_index": i, "item": str(item)}
+
+            # Add metadata about expansion
+            params["expanded_from"] = source_node_id
+            params["expansion_strategy"] = strategy.value
+
+            node = Operation(
+                operation=operation,
+                parameters=params,
+                metadata={
+                    "expansion_index": i,
+                    "expansion_source": source_node_id,
+                    "expansion_strategy": strategy.value,
+                },
+            )
+
+            self.graph.add_node(node)
+            self._operations[node.id] = node
+            new_node_ids.append(node.id)
+
+            # Link from source
+            edge = Edge(
+                head=source_node_id,
+                tail=node.id,
+                label=["expansion", strategy.value],
+            )
+            self.graph.add_edge(edge)
+
+        # Update current heads based on strategy
+        if strategy in [
+            ExpansionStrategy.CONCURRENT,
+            ExpansionStrategy.SEQUENTIAL,
+        ]:
+            self._current_heads = new_node_ids
+
+        return new_node_ids
+
+    def add_aggregation(
+        self,
+        operation: BranchOperations,
+        source_node_ids: list[str] | None = None,
+        **parameters,
+    ) -> str:
+        """
+        Add an aggregation operation that collects from multiple sources.
+
+        Args:
+            operation: Aggregation operation
+            source_node_ids: Nodes to aggregate from (defaults to current heads)
+            **parameters: Operation parameters
+
+        Returns:
+            ID of aggregation node
+        """
+        sources = source_node_ids or self._current_heads
+        if not sources:
+            raise ValueError("No source nodes for aggregation")
+
+        # Add aggregation metadata
+        agg_params = {
+            "aggregation_sources": sources,
+            "aggregation_count": len(sources),
+            **parameters,
+        }
+
+        node = Operation(
+            operation=operation,
+            parameters=agg_params,
+            metadata={"aggregation": True},
+        )
+
+        self.graph.add_node(node)
+        self._operations[node.id] = node
+
+        # Connect all sources
+        for source_id in sources:
+            edge = Edge(head=source_id, tail=node.id, label=["aggregate"])
+            self.graph.add_edge(edge)
+
+        # Update state
+        self._current_heads = [node.id]
+        self.last_operation_id = node.id
+
+        return node.id
+
+    def mark_executed(self, node_ids: list[str]):
+        """
+        Mark nodes as executed.
+
+        This helps track which parts of the graph have been run.
+
+        Args:
+            node_ids: IDs of executed nodes
+        """
+        self._executed.update(node_ids)
+
+    def get_unexecuted_nodes(self) -> list[Operation]:
+        """
+        Get nodes that haven't been executed yet.
+
+        Returns:
+            List of unexecuted operations
+        """
+        return [
+            op
+            for op_id, op in self._operations.items()
+            if op_id not in self._executed
+        ]
+
+    def add_conditional_branch(
+        self,
+        condition_check_op: BranchOperations,
+        true_op: BranchOperations,
+        false_op: BranchOperations | None = None,
+        **check_params,
+    ) -> dict[str, str]:
+        """
+        Add a conditional branch structure.
+
+        Args:
+            condition_check_op: Operation that evaluates condition
+            true_op: Operation if condition is true
+            false_op: Operation if condition is false
+            **check_params: Parameters for condition check
+
+        Returns:
+            Dict with node IDs: {'check': id, 'true': id, 'false': id}
+        """
+        # Add condition check node
+        check_node = Operation(
+            operation=condition_check_op,
+            parameters={**check_params, "is_condition_check": True},
+        )
+        self.graph.add_node(check_node)
+        self._operations[check_node.id] = check_node
+
+        # Link from current heads
+        for head_id in self._current_heads:
+            edge = Edge(
+                head=head_id, tail=check_node.id, label=["to_condition"]
+            )
+            self.graph.add_edge(edge)
+
+        result = {"check": check_node.id}
+
+        # Add true branch
+        true_node = Operation(operation=true_op, parameters={"branch": "true"})
+        self.graph.add_node(true_node)
+        self._operations[true_node.id] = true_node
+        result["true"] = true_node.id
+
+        # Connect with condition label
+        true_edge = Edge(
+            head=check_node.id, tail=true_node.id, label=["if_true"]
+        )
+        self.graph.add_edge(true_edge)
+
+        # Add false branch if specified
+        if false_op:
+            false_node = Operation(
+                operation=false_op, parameters={"branch": "false"}
+            )
+            self.graph.add_node(false_node)
+            self._operations[false_node.id] = false_node
+            result["false"] = false_node.id
+
+            false_edge = Edge(
+                head=check_node.id, tail=false_node.id, label=["if_false"]
+            )
+            self.graph.add_edge(false_edge)
+
+            self._current_heads = [true_node.id, false_node.id]
+        else:
+            self._current_heads = [true_node.id]
+
+        return result
+
+    def get_graph(self) -> Graph:
+        """
+        Get the current graph for execution.
+
+        Returns:
+            The graph in its current state
+        """
+        return self.graph
+
+    def get_node_by_reference(self, reference_id: str) -> Operation | None:
+        """
+        Get a node by its reference ID.
+
+        Args:
+            reference_id: The reference ID assigned when creating the node
+
+        Returns:
+            The operation node or None
+        """
+        for op in self._operations.values():
+            if op.metadata.get("reference_id") == reference_id:
+                return op
+        return None
+
+    def visualize_state(self) -> dict[str, Any]:
+        """
+        Get visualization of current graph state.
+
+        Returns:
+            Dict with graph statistics and state
+        """
+        # Group nodes by expansion source
+        expansions = {}
+        for op in self._operations.values():
+            source = op.metadata.get("expansion_source")
+            if source:
+                if source not in expansions:
+                    expansions[source] = []
+                expansions[source].append(op.id)
+
+        return {
+            "name": self.name,
+            "total_nodes": len(self._operations),
+            "executed_nodes": len(self._executed),
+            "unexecuted_nodes": len(self._operations) - len(self._executed),
+            "current_heads": self._current_heads,
+            "expansions": expansions,
+            "edges": len(self.graph.internal_edges),
+        }
+
+    def visualize(self, title: str = "Operation Graph", figsize=(14, 10)):
+        visualize_graph(
+            self,
+            title=title,
+            figsize=figsize,
+        )
+
+
+def visualize_graph(
+    builder: OperationGraphBuilder,
+    title: str = "Operation Graph",
+    figsize=(14, 10),
+):
+    """Visualization with improved layout for complex graphs."""
+    import matplotlib.pyplot as plt
+    import networkx as nx
+    import numpy as np
+
+    graph = builder.get_graph()
+
+    # Convert to networkx
+    G = nx.DiGraph()
+
+    # Track node positions for hierarchical layout
+    node_levels = {}
+    node_labels = {}
+    node_colors = []
+    node_sizes = []
+
+    # First pass: add nodes and determine levels
+    for node in graph.internal_nodes.values():
+        node_id = str(node.id)[:8]
+        G.add_node(node_id)
+
+        # Determine level based on dependencies
+        in_edges = [
+            e
+            for e in graph.internal_edges.values()
+            if str(e.tail)[:8] == node_id
+        ]
+        if not in_edges:
+            level = 0  # Root nodes
+        else:
+            # Get max level of predecessors + 1
+            pred_levels = []
+            for edge in in_edges:
+                pred_id = str(edge.head)[:8]
+                if pred_id in node_levels:
+                    pred_levels.append(node_levels[pred_id])
+            level = max(pred_levels, default=0) + 1
+
+        node_levels[node_id] = level
+
+        # Create label
+        ref_id = node.metadata.get("reference_id", "")
+        if ref_id:
+            label = f"{node.operation}\n[{ref_id}]"
+        else:
+            label = f"{node.operation}\n{node_id}"
+        node_labels[node_id] = label
+
+        # Color and size based on status and type
+        if node.id in builder._executed:
+            node_colors.append("#90EE90")  # Light green
+            node_sizes.append(4000)
+        elif node.metadata.get("expansion_source"):
+            node_colors.append("#87CEEB")  # Sky blue
+            node_sizes.append(3500)
+        elif node.metadata.get("aggregation"):
+            node_colors.append("#FFD700")  # Gold
+            node_sizes.append(4500)
+        elif node.metadata.get("is_condition_check"):
+            node_colors.append("#DDA0DD")  # Plum
+            node_sizes.append(3500)
+        else:
+            node_colors.append("#E0E0E0")  # Light gray
+            node_sizes.append(3000)
+
+    # Add edges
+    edge_colors = []
+    edge_styles = []
+    edge_widths = []
+    edge_labels = {}
+
+    for edge in graph.internal_edges.values():
+        head_id = str(edge.head)[:8]
+        tail_id = str(edge.tail)[:8]
+        G.add_edge(head_id, tail_id)
+
+        # Style edges based on type
+        edge_label = edge.label[0] if edge.label else ""
+        edge_labels[(head_id, tail_id)] = edge_label
+
+        if "expansion" in edge_label:
+            edge_colors.append("#4169E1")  # Royal blue
+            edge_styles.append("dashed")
+            edge_widths.append(2)
+        elif "aggregate" in edge_label:
+            edge_colors.append("#FF6347")  # Tomato
+            edge_styles.append("dotted")
+            edge_widths.append(2.5)
+        else:
+            edge_colors.append("#808080")  # Gray
+            edge_styles.append("solid")
+            edge_widths.append(1.5)
+
+    # Create improved hierarchical layout
+    pos = {}
+    nodes_by_level = {}
+
+    for node_id, level in node_levels.items():
+        if level not in nodes_by_level:
+            nodes_by_level[level] = []
+        nodes_by_level[level].append(node_id)
+
+    # Position nodes with better spacing algorithm
+    y_spacing = 2.5
+    max_width = 16  # Maximum horizontal spread
+
+    for level, nodes in nodes_by_level.items():
+        num_nodes = len(nodes)
+
+        if num_nodes <= 6:
+            # Normal spacing for small levels
+            x_spacing = 2.5
+            x_offset = -(num_nodes - 1) * x_spacing / 2
+            for i, node_id in enumerate(nodes):
+                pos[node_id] = (x_offset + i * x_spacing, -level * y_spacing)
+        else:
+            # Multi-row layout for large levels
+            nodes_per_row = min(6, int(np.ceil(np.sqrt(num_nodes * 1.5))))
+            rows = int(np.ceil(num_nodes / nodes_per_row))
+
+            for i, node_id in enumerate(nodes):
+                row = i // nodes_per_row
+                col = i % nodes_per_row
+
+                # Calculate row width
+                nodes_in_row = min(
+                    nodes_per_row, num_nodes - row * nodes_per_row
+                )
+                x_spacing = 2.5
+                x_offset = -(nodes_in_row - 1) * x_spacing / 2
+
+                # Add slight y offset for different rows
+                y_offset = row * 0.8
+
+                pos[node_id] = (
+                    x_offset + col * x_spacing,
+                    -level * y_spacing - y_offset,
+                )
+
+    # Create figure
+    plt.figure(figsize=figsize)
+
+    # Draw nodes
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        node_color=node_colors,
+        node_size=node_sizes,
+        alpha=0.9,
+        linewidths=2,
+        edgecolors="black",
+    )
+
+    # Draw edges with different styles - use curved edges for better visibility
+    for i, (u, v) in enumerate(G.edges()):
+        # Calculate curve based on node positions
+        u_pos = pos[u]
+        v_pos = pos[v]
+
+        # Determine connection style based on relative positions
+        if abs(u_pos[0] - v_pos[0]) > 5:  # Far apart horizontally
+            connectionstyle = "arc3,rad=0.2"
+        else:
+            connectionstyle = "arc3,rad=0.1"
+
+        nx.draw_networkx_edges(
+            G,
+            pos,
+            [(u, v)],
+            edge_color=[edge_colors[i]],
+            style=edge_styles[i],
+            width=edge_widths[i],
+            alpha=0.7,
+            arrows=True,
+            arrowsize=20,
+            arrowstyle="-|>",
+            connectionstyle=connectionstyle,
+        )
+
+    # Draw labels
+    nx.draw_networkx_labels(
+        G,
+        pos,
+        node_labels,
+        font_size=9,
+        font_weight="bold",
+        font_family="monospace",
+    )
+
+    # Draw edge labels (only for smaller graphs)
+    if len(G.edges()) < 20:
+        nx.draw_networkx_edge_labels(
+            G,
+            pos,
+            edge_labels,
+            font_size=7,
+            font_color="darkblue",
+            bbox=dict(
+                boxstyle="round,pad=0.3",
+                facecolor="white",
+                edgecolor="none",
+                alpha=0.7,
+            ),
+        )
+
+    plt.title(title, fontsize=18, fontweight="bold", pad=20)
+    plt.axis("off")
+
+    # Enhanced legend
+    from matplotlib.lines import Line2D
+    from matplotlib.patches import Patch, Rectangle
+
+    legend_elements = [
+        Patch(facecolor="#90EE90", edgecolor="black", label="Executed"),
+        Patch(facecolor="#87CEEB", edgecolor="black", label="Expanded"),
+        Patch(facecolor="#FFD700", edgecolor="black", label="Aggregation"),
+        Patch(facecolor="#DDA0DD", edgecolor="black", label="Condition"),
+        Patch(facecolor="#E0E0E0", edgecolor="black", label="Pending"),
+        Line2D([0], [0], color="#808080", linewidth=2, label="Sequential"),
+        Line2D(
+            [0],
+            [0],
+            color="#4169E1",
+            linewidth=2,
+            linestyle="dashed",
+            label="Expansion",
+        ),
+        Line2D(
+            [0],
+            [0],
+            color="#FF6347",
+            linewidth=2,
+            linestyle="dotted",
+            label="Aggregate",
+        ),
+    ]
+
+    plt.legend(
+        handles=legend_elements,
+        loc="upper left",
+        bbox_to_anchor=(0, 1),
+        frameon=True,
+        fancybox=True,
+        shadow=True,
+        ncol=2,
+    )
+
+    # Add statistics box
+    stats_text = f"Nodes: {len(G.nodes())}\nEdges: {len(G.edges())}\nExecuted: {len(builder._executed)}"
+    if nodes_by_level:
+        max_level = max(nodes_by_level.keys())
+        stats_text += f"\nLevels: {max_level + 1}"
+
+    plt.text(
+        0.98,
+        0.02,
+        stats_text,
+        transform=plt.gca().transAxes,
+        bbox=dict(boxstyle="round,pad=0.5", facecolor="lightgray", alpha=0.8),
+        verticalalignment="bottom",
+        horizontalalignment="right",
+        fontsize=10,
+        fontfamily="monospace",
+    )
+
+    plt.tight_layout()
+    plt.show()

lionagi/operations/flow.py

@@ -3,10 +3,12 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio
+import contextlib
 from typing import Any
 
 from lionagi.operations.node import Operation
-from lionagi.protocols.types import Graph, Node
+from lionagi.operations.utils import prepare_session
+from lionagi.protocols.types import ID, Edge, Graph, Node
 from lionagi.session.branch import Branch
 from lionagi.session.session import Session
 from lionagi.utils import to_dict
@@ -44,19 +46,10 @@ async def flow(
     if not graph.is_acyclic():
         raise ValueError("Graph must be acyclic for flow execution")
 
-    # Simple sequential execution on single branch
+    session, branch = prepare_session(session, 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
     )
@@ -167,7 +160,7 @@ async def _execute_parallel(
 
         # Process nodes in dependency order
         remaining_nodes = {node.id for node in operation_nodes}
-        executing_tasks = {}  # node_id -> asyncio.Task
+        executing_tasks: dict[ID[Operation], asyncio.Task] = {}
         blocked_nodes = set()  # Nodes that have been checked and found blocked
 
         max_iterations = 1000  # Prevent infinite loops
@@ -392,7 +385,7 @@ async def _dependencies_satisfied_async(
 ) -> bool:
     """Check if node dependencies are satisfied and edge conditions pass."""
     # Get all incoming edges to this node
-    incoming_edges = []
+    incoming_edges: list[Edge] = []
     for edge in graph.internal_edges:
         if edge.tail == node.id:
             incoming_edges.append(edge)
@@ -406,10 +399,6 @@ async def _dependencies_satisfied_async(
     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
@@ -423,12 +412,9 @@ async def _dependencies_satisfied_async(
                 result_value = to_dict(result_value, recursive=True)
 
             ctx = {"result": result_value, "context": execution_context or {}}
-            try:
+            with contextlib.suppress(Exception):
                 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

lionagi/operations/utils.py

@@ -7,7 +7,9 @@ from lionagi.session.session import Branch, Session
 
 
 def prepare_session(
-    session=None, branch=None, branch_kwargs=None
+    session: Session | None = None,
+    branch: Branch | None = None,
+    branch_kwargs=None,
 ) -> tuple[Session, Branch]:
     if session is not None:
         if branch is not None:

lionagi/service/connections/endpoint_config.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
 import os
 from typing import Any, TypeVar
 
@@ -17,6 +18,9 @@ from pydantic import (
 
 from .header_factory import AUTH_TYPES
 
+logger = logging.getLogger(__name__)
+
+
 B = TypeVar("B", bound=type[BaseModel])
 
 
@@ -32,7 +36,7 @@ class EndpointConfig(BaseModel):
     auth_type: AUTH_TYPES = "bearer"
     default_headers: dict = {}
     request_options: B | None = None
-    api_key: str | SecretStr | None = None
+    api_key: str | SecretStr | None = Field(None, exclude=True)
     timeout: int = 300
     max_retries: int = 3
     openai_compatible: bool = False
@@ -98,9 +102,16 @@ class EndpointConfig(BaseModel):
                 return v.__class__
             if isinstance(v, dict | str):
                 from lionagi.libs.schema.load_pydantic_model_from_schema import (
+                    _HAS_DATAMODEL_CODE_GENERATOR,
                     load_pydantic_model_from_schema,
                 )
 
+                if not _HAS_DATAMODEL_CODE_GENERATOR:
+                    logger.warning(
+                        "datamodel-code-generator is not installed, "
+                        "request_options will not be validated"
+                    )
+                    return None
                 return load_pydantic_model_from_schema(v)
         except Exception as e:
             raise ValueError("Invalid request options") from e

lionagi/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.13.4
+Version: 0.13.6
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -235,6 +235,7 @@ Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0
 Provides-Extra: all
 Requires-Dist: claude-code-sdk>=0.0.14; extra == 'all'
+Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'all'
 Requires-Dist: docling>=2.15.1; extra == 'all'
 Requires-Dist: fastmcp>=2.10.5; extra == 'all'
 Requires-Dist: ollama>=0.4.0; extra == 'all'
@@ -257,6 +258,8 @@ Provides-Extra: reader
 Requires-Dist: docling>=2.15.1; extra == 'reader'
 Provides-Extra: rich
 Requires-Dist: rich>=13.0.0; extra == 'rich'
+Provides-Extra: schema
+Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'schema'
 Provides-Extra: test
 Requires-Dist: pytest-asyncio>=1.0.0; extra == 'test'
 Requires-Dist: pytest>=8.3.4; extra == 'test'
@@ -422,8 +425,6 @@ model = iModel(
 # Start a coding session
 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.communicate("how do these parts form lionagi system")
 ```
 

{lionagi-0.13.4.dist-info → lionagi-0.13.6.dist-info}/RECORD

@@ -1,13 +1,13 @@
-lionagi/__init__.py,sha256=wg2mLxXbJ5pQKrRMIEoQ0_BlHrxjuR1zmc3SAYN7PBc,513
+lionagi/__init__.py,sha256=x_DLjvYZp15u2L3pjIKrUDvvdDBzf7VmrhYVzbsACjU,725
 lionagi/_class_registry.py,sha256=pfUO1DjFZIqr3OwnNMkFqL_fiEBrrf8-swkGmP_KDLE,3112
 lionagi/_errors.py,sha256=S02keQTY2IMkTvpLe00v7P7b8QNJ0PrZ1KWmQWCEQAA,500
-lionagi/_types.py,sha256=iDdYewsP9rDrM7QY19_NDTcWUk7swp8vnGCrloHMtUM,53
+lionagi/_types.py,sha256=R5-XbcOpgqDBgwa65EQTC8irPDuLm3oGXY5t_zwpa9M,163
 lionagi/config.py,sha256=Dxs5FA9UCv1YX5H54qOJcPsDrIF9wFokWEPZ212eH-k,3715
 lionagi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/settings.py,sha256=HDuKCEJCpc4HudKodBnhoQUGuTGhRHdlIFhbtf3VBtY,1633
 lionagi/utils.py,sha256=8zCdJHKbDJv2WSzAAiFnMSpvfyZb9RnmfSNaMEqdTJE,79003
-lionagi/version.py,sha256=6QrvAtwvKbCiayGvUAi82njNCcPWhkMC4sBk4mXPkIc,23
-lionagi/fields/__init__.py,sha256=8oU7Vfk-fKiULFKqhM6VpJMqdZcVXPTM7twVfNDN_SQ,603
+lionagi/version.py,sha256=riz4KLyxI3rKxqm-AbvFFuR22uDgmXnMIjs0NxKBiIE,23
+lionagi/fields/__init__.py,sha256=yrn9NDAM6_v73kK7aJeb-Pvqigeu8WASaV-My-6CDsc,939
 lionagi/fields/action.py,sha256=OziEpbaUeEVo34KdtbzDxXJBgkf3QLxlcKIQAfHe4O0,5791
 lionagi/fields/base.py,sha256=5CJc7j8kTTWzXwpYzkSAFzx4BglABfx3AElIATKB7bg,3857
 lionagi/fields/code.py,sha256=TFym51obzaSfCmeRoHZJyBtjfDI4tvl9F-1sjFc9rMw,7713
@@ -46,7 +46,7 @@ lionagi/libs/schema/extract_code_block.py,sha256=PuJbJj1JnqR5fSZudowPcVPpEoKISLr
 lionagi/libs/schema/extract_docstring.py,sha256=uWyUevXS4JSN60tfouoBBAyE4_jyE-fz45CiS-fvKeI,5714
 lionagi/libs/schema/function_to_schema.py,sha256=XAB031WbYu3a7eFJyYjXVMAjmtWYSYr5kC_DYgjiuyM,5604
 lionagi/libs/schema/json_schema.py,sha256=cuHcaMr748O9g6suNGmRx4tRXcidd5-c7AMGjTIZyHM,7670
-lionagi/libs/schema/load_pydantic_model_from_schema.py,sha256=VGrmnMb26JNcB9LaQcqTwW--sUljqqlqqsPD69zjcEc,10183
+lionagi/libs/schema/load_pydantic_model_from_schema.py,sha256=p4UTgGcb2Tmxc9tLznHPSOWXnHeztJLpl6XTSDcIZ90,10078
 lionagi/libs/token_transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/libs/token_transform/base.py,sha256=LBnaDgi4HNgaJJGwIzWcQjVMdu49i_93rRvOvMU22Rw,1545
 lionagi/libs/token_transform/llmlingua.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
@@ -82,12 +82,13 @@ 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=CwqpPnj6C53mFFu86VtA_JYpVFPBvKKTiA_VwKxLGKk,203
-lionagi/operations/flow.py,sha256=iERw_owbu3tgh_6a35aV2US7r2KaztQ0e54Fu2ETm1w,15074
+lionagi/operations/__init__.py,sha256=L22n8rRls9oVdzHoDlznHFGiKJMNw3ZhbwVQbm1Fn6M,584
+lionagi/operations/builder.py,sha256=6OEPQuONlJuC7bkrmaxOrurMdygjSsvwEX_Zsqf1EmM,20300
+lionagi/operations/flow.py,sha256=o_o_UTXvW1MRvsCwbIXG5pbJPEvLA0d3Qb7Fk3wRHF4,14627
 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/utils.py,sha256=b8HmpF5vRgmf6PTzg3_fZCIKMnhoGa0HCyOlX6JCz7g,1263
 lionagi/operations/ReAct/ReAct.py,sha256=uoJnFMoPP1kzzmgLDFNBwEbWdfGNfG37IT22N1AM-hE,13504
 lionagi/operations/ReAct/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/operations/ReAct/utils.py,sha256=FKb0v-1tboN17imxef9jLKWhet0Iz049eqvZCcJKNX8,4436
@@ -174,7 +175,7 @@ lionagi/service/types.py,sha256=6zavqBxK1Fj0nB9eZgJn3JICxmdT-n0nn8YWZFzM5LU,508
 lionagi/service/connections/__init__.py,sha256=yHQZ7OJpCftd6CStYR8inbxjJydYdmv9kCvbUBhJ2zU,362
 lionagi/service/connections/api_calling.py,sha256=XetCrjMhOHNKGGv-NzHhBhVS7XjKPalrS_iExzU-4S4,8005
 lionagi/service/connections/endpoint.py,sha256=yNIjq9wETMnytynGbq3qY_dkyaMlaHrcfiZjS-tnmLg,14756
-lionagi/service/connections/endpoint_config.py,sha256=mu-5KoETd4Y2RcRmc6MWJ2-FJyxYLjJhebBGYfWgjRs,4758
+lionagi/service/connections/endpoint_config.py,sha256=7u5HDWe-4nttG2cDXtx_OxPzAI4DAA0bPtjJ6BA4gk8,5162
 lionagi/service/connections/header_factory.py,sha256=22sG4ian3MiNklF6SdQqkEYgtWKOZik_yDE0Lna6BiE,1754
 lionagi/service/connections/match_endpoint.py,sha256=K3I4vU6GH6utlEArlyDFUmNdnp94CEPxqKrehAx29J4,2410
 lionagi/service/connections/providers/__init__.py,sha256=3lzOakDoBWmMaNnT2g-YwktPKa_Wme4lnPRSmOQfayY,105
@@ -201,7 +202,7 @@ 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.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,,
+lionagi-0.13.6.dist-info/METADATA,sha256=ENE6dEOAAy0IbJkdVVgryZ8v-ySobfMqzgdsZguQsJE,20818
+lionagi-0.13.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.13.6.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.13.6.dist-info/RECORD,,