agno 2.4.5__py3-none-any.whl → 2.4.7__py3-none-any.whl

agno/utils/print_response/team.py

@@ -61,7 +61,7 @@ def print_response(
         tags_to_include_in_markdown = {"think", "thinking"}
 
     with Live(console=console) as live_console:
-        status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
+        status = Status("Working...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_console.update(status)
 
         response_timer = Timer()
@@ -349,7 +349,7 @@ def print_response(
                 panels.append(summary_panel)
                 team.session_summary_manager.summaries_updated = False
 
-        # Final update to remove the "Thinking..." status
+        # Final update to remove the "Working..." status
         panels = [p for p in panels if not isinstance(p, Status)]
         live_console.update(Group(*panels))
 
@@ -410,7 +410,7 @@ def print_response_stream(
     processed_tool_calls = set()
 
     with Live(console=console) as live_console:
-        status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
+        status = Status("Working...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_console.update(status)
         response_timer = Timer()
         response_timer.start()
@@ -735,7 +735,7 @@ def print_response_stream(
             live_console.update(Group(*panels))
             team.session_summary_manager.summaries_updated = False
 
-        # Final update to remove the "Thinking..." status
+        # Final update to remove the "Working..." status
         panels = [p for p in panels if not isinstance(p, Status)]
 
         if markdown:
@@ -992,7 +992,7 @@ async def aprint_response(
         tags_to_include_in_markdown = {"think", "thinking"}
 
     with Live(console=console) as live_console:
-        status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
+        status = Status("Working...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_console.update(status)
 
         response_timer = Timer()
@@ -1278,7 +1278,7 @@ async def aprint_response(
                 panels.append(summary_panel)
                 team.session_summary_manager.summaries_updated = False
 
-        # Final update to remove the "Thinking..." status
+        # Final update to remove the "Working..." status
         panels = [p for p in panels if not isinstance(p, Status)]
         live_console.update(Group(*panels))
 
@@ -1340,7 +1340,7 @@ async def aprint_response_stream(
     final_panels = []  # type: ignore
 
     with Live(console=console) as live_console:
-        status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
+        status = Status("Working...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_console.update(status)
         response_timer = Timer()
         response_timer.start()
@@ -1663,7 +1663,7 @@ async def aprint_response_stream(
             live_console.update(Group(*panels))
             team.session_summary_manager.summaries_updated = False
 
-        # Final update to remove the "Thinking..." status
+        # Final update to remove the "Working..." status
         panels = [p for p in panels if not isinstance(p, Status)]
 
         if markdown:

agno/vectordb/lancedb/lance_db.py

@@ -104,7 +104,7 @@ class LanceDb(VectorDb):
         self.async_connection: Optional[lancedb.AsyncConnection] = async_connection
         self.async_table: Optional[lancedb.db.AsyncTable] = async_table
 
-        if table_name and table_name in self.connection.table_names():
+        if table_name and table_name in self.connection.list_tables().tables:
             # Open the table if it exists
             try:
                 self.table = self.connection.open_table(name=table_name)
@@ -186,8 +186,8 @@ class LanceDb(VectorDb):
             self.async_connection = await lancedb.connect_async(self.uri)
         # Only try to open table if it exists and we don't have it already
         if self.async_table is None:
-            table_names = await self.async_connection.table_names()
-            if self.table_name in table_names:
+            table_list = await self.async_connection.list_tables()
+            if self.table_name in table_list.tables:
                 try:
                     self.async_table = await self.async_connection.open_table(self.table_name)
                 except ValueError:
@@ -199,7 +199,7 @@ class LanceDb(VectorDb):
         """Refresh the sync connection to see changes made by async operations."""
         try:
             # Re-establish sync connection to see async changes
-            if self.connection and self.table_name in self.connection.table_names():
+            if self.connection is not None and self.table_name in self.connection.list_tables().tables:
                 self.table = self.connection.open_table(self.table_name)
         except Exception as e:
             log_debug(f"Could not refresh sync connection: {e}")
@@ -459,7 +459,7 @@ class LanceDb(VectorDb):
         Returns:
             List[Document]: List of matching documents
         """
-        if self.connection:
+        if self.connection is not None:
             self.table = self.connection.open_table(name=self.table_name)
 
         results = None
@@ -641,8 +641,8 @@ class LanceDb(VectorDb):
         # If we have an async table that was created, the table exists
         if self.async_table is not None:
             return True
-        if self.connection:
-            return self.table_name in self.connection.table_names()
+        if self.connection is not None:
+            return self.table_name in self.connection.list_tables().tables
         return False
 
     async def async_exists(self) -> bool:
@@ -653,8 +653,8 @@ class LanceDb(VectorDb):
         # Check if table exists in database without trying to open it
         if self.async_connection is None:
             self.async_connection = await lancedb.connect_async(self.uri)
-        table_names = await self.async_connection.table_names()
-        return self.table_name in table_names
+        table_list = await self.async_connection.list_tables()
+        return self.table_name in table_list.tables
 
     async def async_get_count(self) -> int:
         """Get the number of rows in the table asynchronously."""

agno/workflow/condition.py

@@ -17,6 +17,10 @@ from agno.utils.log import log_debug, logger
 from agno.workflow.step import Step
 from agno.workflow.types import StepInput, StepOutput, StepType
 
+# Constants for condition branch identifiers
+CONDITION_BRANCH_IF = "if"
+CONDITION_BRANCH_ELSE = "else"
+
 WorkflowSteps = List[
     Union[
         Callable[
@@ -34,7 +38,12 @@ WorkflowSteps = List[
 
 @dataclass
 class Condition:
-    """A condition that executes a step (or list of steps) if the condition is met"""
+    """A condition that executes a step (or list of steps) if the condition is met.
+
+    If the condition evaluates to True, the `steps` are executed.
+    If the condition evaluates to False and `else_steps` is provided (and not empty),
+    the `else_steps` are executed instead.
+    """
 
     # Evaluator should only return boolean
     evaluator: Union[
@@ -44,6 +53,9 @@ class Condition:
     ]
     steps: WorkflowSteps
 
+    # Steps to execute when condition is False (optional)
+    else_steps: Optional[WorkflowSteps] = None
+
     name: Optional[str] = None
     description: Optional[str] = None
 
@@ -57,20 +69,27 @@ class Condition:
         from agno.workflow.step import Step
         from agno.workflow.steps import Steps
 
-        prepared_steps: WorkflowSteps = []
-        for step in self.steps:
-            if callable(step) and hasattr(step, "__name__"):
-                prepared_steps.append(Step(name=step.__name__, description="User-defined callable step", executor=step))
-            elif isinstance(step, Agent):
-                prepared_steps.append(Step(name=step.name, description=step.description, agent=step))
-            elif isinstance(step, Team):
-                prepared_steps.append(Step(name=step.name, description=step.description, team=step))
-            elif isinstance(step, (Step, Steps, Loop, Parallel, Condition, Router)):
-                prepared_steps.append(step)
-            else:
-                raise ValueError(f"Invalid step type: {type(step).__name__}")
+        def prepare_step_list(steps: WorkflowSteps) -> WorkflowSteps:
+            """Helper to prepare a list of steps."""
+            prepared: WorkflowSteps = []
+            for step in steps:
+                if callable(step) and hasattr(step, "__name__"):
+                    prepared.append(Step(name=step.__name__, description="User-defined callable step", executor=step))
+                elif isinstance(step, Agent):
+                    prepared.append(Step(name=step.name, description=step.description, agent=step))
+                elif isinstance(step, Team):
+                    prepared.append(Step(name=step.name, description=step.description, team=step))
+                elif isinstance(step, (Step, Steps, Loop, Parallel, Condition, Router)):
+                    prepared.append(step)
+                else:
+                    raise ValueError(f"Invalid step type: {type(step).__name__}")
+            return prepared
+
+        self.steps = prepare_step_list(self.steps)
 
-        self.steps = prepared_steps
+        # Also prepare else_steps if provided and not empty
+        if self.else_steps and len(self.else_steps) > 0:
+            self.else_steps = prepare_step_list(self.else_steps)
 
     def _update_step_input_from_outputs(
         self,
@@ -169,6 +188,10 @@ class Condition:
         except Exception:
             return False
 
+    def _has_else_steps(self) -> bool:
+        """Check if else_steps is provided and not empty."""
+        return self.else_steps is not None and len(self.else_steps) > 0
+
     def execute(
         self,
         step_input: StepInput,
@@ -183,7 +206,12 @@ class Condition:
         num_history_runs: int = 3,
         background_tasks: Optional[Any] = None,
     ) -> StepOutput:
-        """Execute the condition and its steps with sequential chaining if condition is true"""
+        """Execute the condition and its steps with sequential chaining.
+
+        If condition is True, executes `steps`.
+        If condition is False and `else_steps` is provided (and not empty), executes `else_steps`.
+        If condition is False and no `else_steps`, returns a "not met" message.
+        """
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
         conditional_step_id = str(uuid4())
@@ -198,7 +226,17 @@ class Condition:
 
         log_debug(f"Condition {self.name} evaluated to: {condition_result}")
 
-        if not condition_result:
+        # Determine which steps to execute
+        if condition_result:
+            steps_to_execute = self.steps
+            branch = CONDITION_BRANCH_IF
+            log_debug(f"Condition {self.name} met, executing {len(steps_to_execute)} steps (if branch)")
+        elif self._has_else_steps():
+            steps_to_execute = self.else_steps  # type: ignore[assignment]
+            branch = CONDITION_BRANCH_ELSE
+            log_debug(f"Condition {self.name} not met, executing {len(steps_to_execute)} else_steps (else branch)")
+        else:
+            # No else_steps provided, return "not met" message
             log_debug(f"Condition {self.name} not met, skipping {len(self.steps)} steps")
             return StepOutput(
                 step_name=self.name,
@@ -208,12 +246,11 @@ class Condition:
                 success=True,
             )
 
-        log_debug(f"Condition {self.name} met, executing {len(self.steps)} steps")
         all_results: List[StepOutput] = []
         current_step_input = step_input
-        condition_step_outputs = {}
+        condition_step_outputs: Dict[str, StepOutput] = {}
 
-        for i, step in enumerate(self.steps):
+        for i, step in enumerate(steps_to_execute):
             try:
                 step_output = step.execute(  # type: ignore[union-attr]
                     current_step_input,
@@ -234,7 +271,7 @@ class Condition:
                     all_results.extend(step_output)
                     if step_output:
                         step_name = getattr(step, "name", f"step_{i}")
-                        log_debug(f"Executing condition step {i + 1}/{len(self.steps)}: {step_name}")
+                        log_debug(f"Executing condition step {i + 1}/{len(steps_to_execute)}: {step_name}")
 
                         condition_step_outputs[step_name] = step_output[-1]
 
@@ -269,13 +306,13 @@ class Condition:
                 all_results.append(error_output)
                 break
 
-        log_debug(f"Condition End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
+        log_debug(f"Condition End: {self.name} ({len(all_results)} results, {branch} branch)", center=True, symbol="-")
 
         return StepOutput(
             step_name=self.name,
             step_id=conditional_step_id,
             step_type=StepType.CONDITION,
-            content=f"Condition {self.name} completed with {len(all_results)} results",
+            content=f"Condition {self.name} completed with {len(all_results)} results ({branch} branch)",
             success=all(result.success for result in all_results) if all_results else True,
             error=None,
             stop=any(result.stop for result in all_results) if all_results else False,
@@ -300,7 +337,12 @@ class Condition:
         num_history_runs: int = 3,
         background_tasks: Optional[Any] = None,
     ) -> Iterator[Union[WorkflowRunOutputEvent, StepOutput]]:
-        """Execute the condition with streaming support - mirrors Loop logic"""
+        """Execute the condition with streaming support.
+
+        If condition is True, executes `steps`.
+        If condition is False and `else_steps` is provided (and not empty), executes `else_steps`.
+        If condition is False and no `else_steps`, yields completed event and returns.
+        """
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
         conditional_step_id = str(uuid4())
@@ -328,9 +370,18 @@ class Condition:
                 parent_step_id=parent_step_id,
             )
 
-        if not condition_result:
+        # Determine which steps to execute
+        if condition_result:
+            steps_to_execute = self.steps
+            branch = CONDITION_BRANCH_IF
+            log_debug(f"Condition {self.name} met, executing {len(steps_to_execute)} steps (if branch)")
+        elif self._has_else_steps():
+            steps_to_execute = self.else_steps  # type: ignore[assignment]
+            branch = CONDITION_BRANCH_ELSE
+            log_debug(f"Condition {self.name} not met, executing {len(steps_to_execute)} else_steps (else branch)")
+        else:
+            # No else_steps provided, yield completed event and return
             if stream_events and workflow_run_response:
-                # Yield condition completed event for empty case
                 yield ConditionExecutionCompletedEvent(
                     run_id=workflow_run_response.run_id or "",
                     workflow_name=workflow_run_response.workflow_name or "",
@@ -340,20 +391,20 @@ class Condition:
                     step_index=step_index,
                     condition_result=False,
                     executed_steps=0,
+                    branch=None,
                     step_results=[],
                     step_id=conditional_step_id,
                     parent_step_id=parent_step_id,
                 )
             return
 
-        log_debug(f"Condition {self.name} met, executing {len(self.steps)} steps")
-        all_results = []
+        all_results: List[StepOutput] = []
         current_step_input = step_input
-        condition_step_outputs = {}
+        condition_step_outputs: Dict[str, StepOutput] = {}
 
-        for i, step in enumerate(self.steps):
+        for i, step in enumerate(steps_to_execute):
             try:
-                step_outputs_for_step = []
+                step_outputs_for_step: List[StepOutput] = []
 
                 # Create child index for each step within condition
                 if step_index is None or isinstance(step_index, int):
@@ -426,7 +477,7 @@ class Condition:
                 all_results.append(error_output)
                 break
 
-        log_debug(f"Condition End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
+        log_debug(f"Condition End: {self.name} ({len(all_results)} results, {branch} branch)", center=True, symbol="-")
         if stream_events and workflow_run_response:
             # Yield condition completed event
             yield ConditionExecutionCompletedEvent(
@@ -436,8 +487,9 @@ class Condition:
                 session_id=workflow_run_response.session_id or "",
                 step_name=self.name,
                 step_index=step_index,
-                condition_result=True,
-                executed_steps=len(self.steps),
+                condition_result=condition_result,
+                executed_steps=len(steps_to_execute),
+                branch=branch,
                 step_results=all_results,
                 step_id=conditional_step_id,
                 parent_step_id=parent_step_id,
@@ -447,7 +499,7 @@ class Condition:
             step_name=self.name,
             step_id=conditional_step_id,
             step_type=StepType.CONDITION,
-            content=f"Condition {self.name} completed with {len(all_results)} results",
+            content=f"Condition {self.name} completed with {len(all_results)} results ({branch} branch)",
             success=all(result.success for result in all_results) if all_results else True,
             stop=any(result.stop for result in all_results) if all_results else False,
             steps=all_results,
@@ -467,7 +519,12 @@ class Condition:
         num_history_runs: int = 3,
         background_tasks: Optional[Any] = None,
     ) -> StepOutput:
-        """Async execute the condition and its steps with sequential chaining"""
+        """Async execute the condition and its steps with sequential chaining.
+
+        If condition is True, executes `steps`.
+        If condition is False and `else_steps` is provided (and not empty), executes `else_steps`.
+        If condition is False and no `else_steps`, returns a "not met" message.
+        """
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
         conditional_step_id = str(uuid4())
@@ -481,24 +538,32 @@ class Condition:
             condition_result = await self._aevaluate_condition(step_input, session_state=session_state)
         log_debug(f"Condition {self.name} evaluated to: {condition_result}")
 
-        if not condition_result:
+        # Determine which steps to execute
+        if condition_result:
+            steps_to_execute = self.steps
+            branch = CONDITION_BRANCH_IF
+            log_debug(f"Condition {self.name} met, executing {len(steps_to_execute)} steps (if branch)")
+        elif self._has_else_steps():
+            steps_to_execute = self.else_steps  # type: ignore[assignment]
+            branch = CONDITION_BRANCH_ELSE
+            log_debug(f"Condition {self.name} not met, executing {len(steps_to_execute)} else_steps (else branch)")
+        else:
+            # No else_steps provided, return "not met" message
             log_debug(f"Condition {self.name} not met, skipping {len(self.steps)} steps")
             return StepOutput(
                 step_name=self.name,
-                step_id=str(uuid4()),
+                step_id=conditional_step_id,
                 step_type=StepType.CONDITION,
                 content=f"Condition {self.name} not met - skipped {len(self.steps)} steps",
                 success=True,
             )
 
-        log_debug(f"Condition {self.name} met, executing {len(self.steps)} steps")
-
         # Chain steps sequentially like Loop does
         all_results: List[StepOutput] = []
         current_step_input = step_input
-        condition_step_outputs = {}
+        condition_step_outputs: Dict[str, StepOutput] = {}
 
-        for i, step in enumerate(self.steps):
+        for i, step in enumerate(steps_to_execute):
             try:
                 step_output = await step.aexecute(  # type: ignore[union-attr]
                     current_step_input,
@@ -552,13 +617,13 @@ class Condition:
                 all_results.append(error_output)
                 break
 
-        log_debug(f"Condition End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
+        log_debug(f"Condition End: {self.name} ({len(all_results)} results, {branch} branch)", center=True, symbol="-")
 
         return StepOutput(
             step_name=self.name,
             step_id=conditional_step_id,
             step_type=StepType.CONDITION,
-            content=f"Condition {self.name} completed with {len(all_results)} results",
+            content=f"Condition {self.name} completed with {len(all_results)} results ({branch} branch)",
             success=all(result.success for result in all_results) if all_results else True,
             error=None,
             stop=any(result.stop for result in all_results) if all_results else False,
@@ -583,7 +648,12 @@ class Condition:
         num_history_runs: int = 3,
         background_tasks: Optional[Any] = None,
     ) -> AsyncIterator[Union[WorkflowRunOutputEvent, TeamRunOutputEvent, RunOutputEvent, StepOutput]]:
-        """Async execute the condition with streaming support - mirrors Loop logic"""
+        """Async execute the condition with streaming support.
+
+        If condition is True, executes `steps`.
+        If condition is False and `else_steps` is provided (and not empty), executes `else_steps`.
+        If condition is False and no `else_steps`, yields completed event and returns.
+        """
         log_debug(f"Condition Start: {self.name}", center=True, symbol="-")
 
         conditional_step_id = str(uuid4())
@@ -611,9 +681,18 @@ class Condition:
                 parent_step_id=parent_step_id,
             )
 
-        if not condition_result:
+        # Determine which steps to execute
+        if condition_result:
+            steps_to_execute = self.steps
+            branch = CONDITION_BRANCH_IF
+            log_debug(f"Condition {self.name} met, executing {len(steps_to_execute)} steps (if branch)")
+        elif self._has_else_steps():
+            steps_to_execute = self.else_steps  # type: ignore[assignment]
+            branch = CONDITION_BRANCH_ELSE
+            log_debug(f"Condition {self.name} not met, executing {len(steps_to_execute)} else_steps (else branch)")
+        else:
+            # No else_steps provided, yield completed event and return
             if stream_events and workflow_run_response:
-                # Yield condition completed event for empty case
                 yield ConditionExecutionCompletedEvent(
                     run_id=workflow_run_response.run_id or "",
                     workflow_name=workflow_run_response.workflow_name or "",
@@ -623,22 +702,21 @@ class Condition:
                     step_index=step_index,
                     condition_result=False,
                     executed_steps=0,
+                    branch=None,
                     step_results=[],
                     step_id=conditional_step_id,
                     parent_step_id=parent_step_id,
                 )
             return
 
-        log_debug(f"Condition {self.name} met, executing {len(self.steps)} steps")
-
         # Chain steps sequentially like Loop does
-        all_results = []
+        all_results: List[StepOutput] = []
         current_step_input = step_input
-        condition_step_outputs = {}
+        condition_step_outputs: Dict[str, StepOutput] = {}
 
-        for i, step in enumerate(self.steps):
+        for i, step in enumerate(steps_to_execute):
             try:
-                step_outputs_for_step = []
+                step_outputs_for_step: List[StepOutput] = []
 
                 # Create child index for each step within condition
                 if step_index is None or isinstance(step_index, int):
@@ -711,7 +789,7 @@ class Condition:
                 all_results.append(error_output)
                 break
 
-        log_debug(f"Condition End: {self.name} ({len(all_results)} results)", center=True, symbol="-")
+        log_debug(f"Condition End: {self.name} ({len(all_results)} results, {branch} branch)", center=True, symbol="-")
 
         if stream_events and workflow_run_response:
             # Yield condition completed event
@@ -722,8 +800,9 @@ class Condition:
                 session_id=workflow_run_response.session_id or "",
                 step_name=self.name,
                 step_index=step_index,
-                condition_result=True,
-                executed_steps=len(self.steps),
+                condition_result=condition_result,
+                executed_steps=len(steps_to_execute),
+                branch=branch,
                 step_results=all_results,
                 step_id=conditional_step_id,
                 parent_step_id=parent_step_id,
@@ -733,7 +812,7 @@ class Condition:
             step_name=self.name,
             step_id=conditional_step_id,
             step_type=StepType.CONDITION,
-            content=f"Condition {self.name} completed with {len(all_results)} results",
+            content=f"Condition {self.name} completed with {len(all_results)} results ({branch} branch)",
             success=all(result.success for result in all_results) if all_results else True,
             stop=any(result.stop for result in all_results) if all_results else False,
             steps=all_results,