lionagi 0.15.1__tar.gz → 0.15.3__tar.gz

{lionagi-0.15.1 → lionagi-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.15.1
+Version: 0.15.3
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -497,7 +497,7 @@ We welcome issues, ideas, and pull requests:
 
 ```
 @software{Li_LionAGI_2023,
-  author = {Haiyang Li, Liangbingyan Luo},
+  author = {Haiyang Li},
   month = {12},
   year = {2023},
   title = {LionAGI: Towards Automated General Intelligence},

{lionagi-0.15.1 → lionagi-0.15.3}/README.md

@@ -225,7 +225,7 @@ We welcome issues, ideas, and pull requests:
 
 ```
 @software{Li_LionAGI_2023,
-  author = {Haiyang Li, Liangbingyan Luo},
+  author = {Haiyang Li},
   month = {12},
   year = {2023},
   title = {LionAGI: Towards Automated General Intelligence},

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/operations/builder.py

@@ -253,9 +253,11 @@ class OperationGraphBuilder:
         if not sources:
             raise ValueError("No source nodes for aggregation")
 
-        # Add aggregation metadata
+        # Add aggregation metadata - convert IDType to strings for JSON serialization
         agg_params = {
-            "aggregation_sources": sources,
+            "aggregation_sources": [
+                str(s) for s in sources
+            ],  # Convert IDType to strings
             "aggregation_count": len(sources),
             **parameters,
         }

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/operations/flow.py

@@ -58,6 +58,7 @@ class DependencyAwareExecutor:
         self.results = {}
         self.completion_events = {}  # operation_id -> Event
         self.operation_branches = {}  # operation_id -> Branch
+        self.skipped_operations = set()  # Track skipped operations
 
         # Initialize completion events for all operations
         # and check for already completed operations
@@ -76,6 +77,9 @@ class DependencyAwareExecutor:
         if not self.graph.is_acyclic():
             raise ValueError("Graph must be acyclic for flow execution")
 
+        # Validate edge conditions before execution
+        self._validate_edge_conditions()
+
         # Pre-allocate ALL branches upfront to avoid any locking during execution
         await self._preallocate_all_branches()
 
@@ -94,13 +98,25 @@ class DependencyAwareExecutor:
                 if isinstance(node, Operation):
                     await tg.start_soon(self._execute_operation, node, limiter)
 
-        # Return results
-        return {
-            "completed_operations": list(self.results.keys()),
+        # Return results - only include actually completed operations
+        completed_ops = [
+            op_id
+            for op_id in self.results.keys()
+            if op_id not in self.skipped_operations
+        ]
+
+        result = {
+            "completed_operations": completed_ops,
             "operation_results": self.results,
             "final_context": self.context,
+            "skipped_operations": list(self.skipped_operations),
         }
 
+        # Validate results before returning
+        self._validate_execution_results(result)
+
+        return result
+
     async def _preallocate_all_branches(self):
         """Pre-allocate ALL branches including for context inheritance to eliminate runtime locking."""
         operations_needing_branches = []
@@ -193,6 +209,23 @@ class DependencyAwareExecutor:
             return
 
         try:
+            # Check if this operation should be skipped due to edge conditions
+            should_execute = await self._check_edge_conditions(operation)
+
+            if not should_execute:
+                # Mark as skipped
+                operation.execution.status = EventStatus.SKIPPED
+                self.skipped_operations.add(operation.id)
+
+                if self.verbose:
+                    print(
+                        f"Skipping operation due to edge conditions: {str(operation.id)[:8]}"
+                    )
+
+                # Signal completion so dependent operations can proceed
+                self.completion_events[operation.id].set()
+                return
+
             # Wait for dependencies
             await self._wait_for_dependencies(operation)
 
@@ -235,9 +268,56 @@ class DependencyAwareExecutor:
                 print(f"Operation {str(operation.id)[:8]} failed: {e}")
 
         finally:
-            # Signal completion regardless of success/failure
+            # Signal completion regardless of success/failure/skip
             self.completion_events[operation.id].set()
 
+    async def _check_edge_conditions(self, operation: Operation) -> bool:
+        """
+        Check if operation should execute based on edge conditions.
+
+        Returns True if at least one valid path exists to this operation,
+        or if there are no incoming edges (head nodes).
+        Returns False if all incoming edges have failed conditions.
+        """
+        # Get all incoming edges
+        incoming_edges = [
+            edge
+            for edge in self.graph.internal_edges.values()
+            if edge.tail == operation.id
+        ]
+
+        # If no incoming edges, this is a head node - always execute
+        if not incoming_edges:
+            return True
+
+        # Check each incoming edge
+        has_valid_path = False
+
+        for edge in incoming_edges:
+            # Wait for the head operation to complete first
+            if edge.head in self.completion_events:
+                await self.completion_events[edge.head].wait()
+
+            # Check if the head operation was skipped
+            if edge.head in self.skipped_operations:
+                continue  # This path is not valid
+
+            # Build context for edge condition evaluation
+            result_value = self.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": self.context}
+
+            # Use edge.check_condition() which handles None conditions
+            if await edge.check_condition(ctx):
+                has_valid_path = True
+                break  # At least one valid path found
+
+        return has_valid_path
+
     async def _wait_for_dependencies(self, operation: Operation):
         """Wait for all dependencies to complete."""
         # Special handling for aggregations
@@ -248,10 +328,14 @@ class DependencyAwareExecutor:
                     f"Aggregation {str(operation.id)[:8]} waiting for {len(sources)} sources"
                 )
 
-            # Wait for ALL sources
-            for source_id in sources:
-                if source_id in self.completion_events:
-                    await self.completion_events[source_id].wait()
+            # Wait for ALL sources (sources are now strings from builder.py)
+            for source_id_str in sources:
+                # Convert string back to IDType for lookup
+                # Check all operations to find matching ID
+                for op_id in self.completion_events.keys():
+                    if str(op_id) == source_id_str:
+                        await self.completion_events[op_id].wait()
+                        break
 
         # Regular dependency checking
         predecessors = self.graph.get_predecessors(operation)
@@ -262,32 +346,6 @@ class DependencyAwareExecutor:
                 )
             await self.completion_events[pred.id].wait()
 
-        # Check edge conditions
-        incoming_edges = [
-            edge
-            for edge in self.graph.internal_edges.values()
-            if edge.tail == operation.id
-        ]
-
-        for edge in incoming_edges:
-            # Wait for head to complete
-            if edge.head in self.completion_events:
-                await self.completion_events[edge.head].wait()
-
-            # Evaluate edge condition
-            if edge.condition is not None:
-                result_value = self.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": self.context}
-                if not await edge.condition.apply(ctx):
-                    raise ValueError(
-                        f"Edge condition not satisfied for {str(operation.id)[:8]}"
-                    )
-
     def _prepare_operation(self, operation: Operation):
         """Prepare operation with context and branch assignment."""
         # Update operation context with predecessors
@@ -295,13 +353,18 @@ class DependencyAwareExecutor:
         if predecessors:
             pred_context = {}
             for pred in predecessors:
+                # Skip if predecessor was skipped
+                if pred.id in self.skipped_operations:
+                    continue
+
                 if pred.id in self.results:
                     result = self.results[pred.id]
                     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
+                    # Use string representation of IDType for JSON serialization
+                    pred_context[f"{str(pred.id)}_result"] = result
 
             if "context" not in operation.parameters:
                 operation.parameters["context"] = pred_context
@@ -364,7 +427,12 @@ class DependencyAwareExecutor:
                     ):
                         branch._message_manager.pile.clear()
                         for msg in primary_branch._message_manager.pile:
-                            branch._message_manager.pile.append(msg.clone())
+                            if hasattr(msg, "clone"):
+                                branch._message_manager.pile.append(
+                                    msg.clone()
+                                )
+                            else:
+                                branch._message_manager.pile.append(msg)
 
                     # Clear the pending flag
                     branch.metadata["pending_context_inheritance"] = False
@@ -386,6 +454,49 @@ class DependencyAwareExecutor:
             return self._default_branch
         return self.session.default_branch
 
+    def _validate_edge_conditions(self):
+        """Validate that all edge conditions are properly configured."""
+        for edge in self.graph.internal_edges.values():
+            if edge.condition is not None:
+                # Ensure condition is an EdgeCondition instance
+                from lionagi.protocols.graph.edge import EdgeCondition
+
+                if not isinstance(edge.condition, EdgeCondition):
+                    raise TypeError(
+                        f"Edge {edge.id} has invalid condition type: {type(edge.condition)}. "
+                        "Must be EdgeCondition or None."
+                    )
+
+                # Ensure condition has apply method
+                if not hasattr(edge.condition, "apply"):
+                    raise AttributeError(
+                        f"Edge {edge.id} condition missing 'apply' method."
+                    )
+
+    def _validate_execution_results(self, results: dict[str, Any]):
+        """Validate execution results for consistency."""
+        completed = set(results.get("completed_operations", []))
+        skipped = set(results.get("skipped_operations", []))
+
+        # Check for operations in both lists
+        overlap = completed & skipped
+        if overlap:
+            raise RuntimeError(
+                f"Operations {overlap} appear in both completed and skipped lists! "
+                "This indicates a bug in edge condition handling."
+            )
+
+        # Verify skipped operations have proper status
+        for node in self.graph.internal_nodes.values():
+            if isinstance(node, Operation) and node.id in skipped:
+                if node.execution.status != EventStatus.SKIPPED:
+                    # Log warning but don't fail - status might not be perfectly synced
+                    if self.verbose:
+                        print(
+                            f"Warning: Skipped operation {node.id} has status "
+                            f"{node.execution.status} instead of SKIPPED"
+                        )
+
 
 async def flow(
     session: Session,

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/operations/node.py

@@ -3,6 +3,7 @@ import logging
 from typing import Any, Literal
 from uuid import UUID
 
+from anyio import get_cancelled_exc_class
 from pydantic import BaseModel, Field
 
 from lionagi.protocols.types import ID, Event, EventStatus, IDType, Node
@@ -87,9 +88,9 @@ class Operation(Node, Event):
             self.execution.response = response
             self.execution.status = EventStatus.COMPLETED
 
-        except asyncio.CancelledError:
+        except get_cancelled_exc_class():
             self.execution.error = "Operation cancelled"
-            self.execution.status = EventStatus.FAILED
+            self.execution.status = EventStatus.CANCELLED
             raise
 
         except Exception as e:

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/protocols/generic/event.py

@@ -32,12 +32,14 @@ class EventStatus(str, Enum):
         PROCESSING: Action is currently being executed.
         COMPLETED: Action completed successfully.
         FAILED: Action failed during execution.
+        SKIPPED: Action was skipped due to unmet conditions.
     """
 
     PENDING = "pending"
     PROCESSING = "processing"
     COMPLETED = "completed"
     FAILED = "failed"
+    SKIPPED = "skipped"
     CANCELLED = "cancelled"
     ABORTED = "aborted"
 

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/service/connections/api_calling.py

@@ -197,7 +197,7 @@ class APICalling(Event):
 
         except get_cancelled_exc_class():
             self.execution.error = "API call cancelled"
-            self.execution.status = EventStatus.FAILED
+            self.execution.status = EventStatus.CANCELLED
             raise
 
         except Exception as e:

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/service/connections/endpoint.py

@@ -148,6 +148,8 @@ class Endpoint:
                 "chat_model",
                 "imodel",
                 "branch",
+                "aggregation_sources",
+                "aggregation_count",
             }
             payload = {
                 k: v for k, v in payload.items() if k not in non_api_params

{lionagi-0.15.1 → lionagi-0.15.3}/lionagi/session/session.py

@@ -86,6 +86,31 @@ class Session(Node, Communicatable, Relational):
     ):
         self._operation_manager.register(operation, func, update=update)
 
+    def operation(self, name: str = None, *, update: bool = False):
+        """
+        Decorator to automatically register functions as operations.
+
+        Args:
+            name: Operation name. If None, uses the function's __name__.
+            update: Whether to update if operation already exists.
+
+        Usage:
+            @session.operation()
+            async def read_issue():
+                ...
+
+            @session.operation("custom_name")
+            async def some_function():
+                ...
+        """
+
+        def decorator(func: Callable) -> Callable:
+            operation_name = name if name is not None else func.__name__
+            self.register_operation(operation_name, func, update=update)
+            return func
+
+        return decorator
+
     @model_validator(mode="after")
     def _add_mail_sources(self) -> Self:
         if self.default_branch is None:

lionagi-0.15.3/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.15.3"

{lionagi-0.15.1 → lionagi-0.15.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.15.1"
+version = "0.15.3"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },

{lionagi-0.15.1 → lionagi-0.15.3}/uv.lock

@@ -1933,7 +1933,7 @@ wheels = [
 
 [[package]]
 name = "lionagi"
-version = "0.15.1"
+version = "0.15.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiocache" },

lionagi-0.15.1/lionagi/version.py

@@ -1 +0,0 @@
-__version__ = "0.15.1"