agno 2.2.5__py3-none-any.whl → 2.2.6__py3-none-any.whl

agno/utils/print_response/workflow.py

@@ -25,6 +25,8 @@ from agno.run.workflow import (
     StepsExecutionCompletedEvent,
     StepsExecutionStartedEvent,
     StepStartedEvent,
+    WorkflowAgentCompletedEvent,
+    WorkflowAgentStartedEvent,
     WorkflowCompletedEvent,
     WorkflowErrorEvent,
     WorkflowRunOutput,
@@ -135,7 +137,16 @@ def print_response(
 
             response_timer.stop()
 
-            if show_step_details and workflow_response.step_results:
+            # Check if this is a workflow agent direct response
+            if workflow_response.workflow_agent_run is not None and not workflow_response.workflow_agent_run.tools:
+                # Agent answered directly from history without executing workflow
+                agent_response_panel = create_panel(
+                    content=Markdown(str(workflow_response.content)) if markdown else str(workflow_response.content),
+                    title="Workflow Agent Response",
+                    border_style="green",
+                )
+                console.print(agent_response_panel)  # type: ignore
+            elif show_step_details and workflow_response.step_results:
                 for i, step_output in enumerate(workflow_response.step_results):
                     print_step_output_recursive(step_output, i + 1, markdown, console)  # type: ignore
 
@@ -260,6 +271,8 @@ def print_response_stream(
     step_results = []
     step_started_printed = False
     is_callable_function = callable(workflow.steps)
+    workflow_started = False  # Track if workflow has actually started
+    is_workflow_agent_response = False  # Track if this is a workflow agent direct response
 
     # Smart step hierarchy tracking
     current_primitive_context = None  # Current primitive being executed (parallel, loop, etc.)
@@ -328,12 +341,25 @@ def print_response_stream(
             ):  # type: ignore
                 # Handle the new event types
                 if isinstance(response, WorkflowStartedEvent):
+                    workflow_started = True
                     status.update("Workflow started...")
                     if is_callable_function:
                         current_step_name = "Custom Function"
                         current_step_index = 0
                     live_log.update(status)
 
+                elif isinstance(response, WorkflowAgentStartedEvent):
+                    # Workflow agent is starting to process
+                    status.update("Workflow agent processing...")
+                    live_log.update(status)
+                    continue
+
+                elif isinstance(response, WorkflowAgentCompletedEvent):
+                    # Workflow agent has completed
+                    status.update("Workflow agent completed")
+                    live_log.update(status)
+                    continue
+
                 elif isinstance(response, StepStartedEvent):
                     step_name = response.step_name or "Unknown"
                     step_index = response.step_index or 0  # type: ignore
@@ -646,8 +672,23 @@ def print_response_stream(
                 elif isinstance(response, WorkflowCompletedEvent):
                     status.update("Workflow completed!")
 
+                    # Check if this is an agent direct response
+                    if response.metadata and response.metadata.get("agent_direct_response"):
+                        is_workflow_agent_response = True
+                        # Print the agent's direct response from history
+                        if show_step_details:
+                            live_log.update(status, refresh=True)
+                            agent_response_panel = create_panel(
+                                content=Markdown(str(response.content)) if markdown else str(response.content),
+                                title="Workflow Agent Response",
+                                border_style="green",
+                            )
+                            console.print(agent_response_panel)  # type: ignore
+                            step_started_printed = True
                     # For callable functions, print the final content block here since there are no step events
-                    if is_callable_function and show_step_details and current_step_content and not step_started_printed:
+                    elif (
+                        is_callable_function and show_step_details and current_step_content and not step_started_printed
+                    ):
                         final_step_panel = create_panel(
                             content=Markdown(current_step_content) if markdown else current_step_content,
                             title="Custom Function (Completed)",
@@ -658,8 +699,8 @@ def print_response_stream(
 
                     live_log.update(status, refresh=True)
 
-                    # Show final summary
-                    if response.metadata:
+                    # Show final summary (skip for agent responses)
+                    if response.metadata and not is_workflow_agent_response:
                         status = response.status
                         summary_content = ""
                         summary_content += f"""\n\n**Status:** {status}"""
@@ -710,8 +751,16 @@ def print_response_stream(
                                 and response.content_type != ""
                             )
                             response_str = response.content  # type: ignore
+
+                            if isinstance(response, RunContentEvent) and not workflow_started:
+                                is_workflow_agent_response = True
+                                continue
+
                         elif isinstance(response, RunContentEvent) and current_step_executor_type != "team":
                             response_str = response.content  # type: ignore
+                            # If we get RunContentEvent BEFORE workflow starts, it's an agent direct response
+                            if not workflow_started and not is_workflow_agent_response:
+                                is_workflow_agent_response = True
                         else:
                             continue
 
@@ -734,8 +783,8 @@ def print_response_stream(
                         else:
                             current_step_content += response_str
 
-                        # Live update the step panel with streaming content
-                        if show_step_details and not step_started_printed:
+                        # Live update the step panel with streaming content (skip for workflow agent responses)
+                        if show_step_details and not step_started_printed and not is_workflow_agent_response:
                             # Generate smart step number for streaming title (will use cached value)
                             step_display = get_step_display_number(current_step_index, current_step_name)
                             title = f"{step_display}: {current_step_name} (Streaming...)"
@@ -757,8 +806,8 @@ def print_response_stream(
 
             live_log.update("")
 
-            # Final completion message
-            if show_time:
+            # Final completion message (skip for agent responses)
+            if show_time and not is_workflow_agent_response:
                 completion_text = Text(f"Completed in {response_timer.elapsed:.1f}s", style="bold green")
                 console.print(completion_text)  # type: ignore
 
@@ -927,7 +976,16 @@ async def aprint_response(
 
             response_timer.stop()
 
-            if show_step_details and workflow_response.step_results:
+            # Check if this is a workflow agent direct response
+            if workflow_response.workflow_agent_run is not None and not workflow_response.workflow_agent_run.tools:
+                # Agent answered directly from history without executing workflow
+                agent_response_panel = create_panel(
+                    content=Markdown(str(workflow_response.content)) if markdown else str(workflow_response.content),
+                    title="Workflow Agent Response",
+                    border_style="green",
+                )
+                console.print(agent_response_panel)  # type: ignore
+            elif show_step_details and workflow_response.step_results:
                 for i, step_output in enumerate(workflow_response.step_results):
                     print_step_output_recursive(step_output, i + 1, markdown, console)  # type: ignore
 
@@ -1052,6 +1110,8 @@ async def aprint_response_stream(
     step_results = []
     step_started_printed = False
     is_callable_function = callable(workflow.steps)
+    workflow_started = False  # Track if workflow has actually started
+    is_workflow_agent_response = False  # Track if this is a workflow agent direct response
 
     # Smart step hierarchy tracking
     current_primitive_context = None  # Current primitive being executed (parallel, loop, etc.)
@@ -1120,13 +1180,30 @@ async def aprint_response_stream(
             ):  # type: ignore
                 # Handle the new event types
                 if isinstance(response, WorkflowStartedEvent):
+                    workflow_started = True
                     status.update("Workflow started...")
                     if is_callable_function:
                         current_step_name = "Custom Function"
                         current_step_index = 0
                     live_log.update(status)
 
+                elif isinstance(response, WorkflowAgentStartedEvent):
+                    # Workflow agent is starting to process
+                    status.update("Workflow agent processing...")
+                    live_log.update(status)
+                    continue
+
+                elif isinstance(response, WorkflowAgentCompletedEvent):
+                    # Workflow agent has completed
+                    status.update("Workflow agent completed")
+                    live_log.update(status)
+                    continue
+
                 elif isinstance(response, StepStartedEvent):
+                    # Skip step events if workflow hasn't started (agent direct response)
+                    if not workflow_started:
+                        continue
+
                     step_name = response.step_name or "Unknown"
                     step_index = response.step_index or 0  # type: ignore
 
@@ -1438,8 +1515,23 @@ async def aprint_response_stream(
                 elif isinstance(response, WorkflowCompletedEvent):
                     status.update("Workflow completed!")
 
+                    # Check if this is an agent direct response
+                    if response.metadata and response.metadata.get("agent_direct_response"):
+                        is_workflow_agent_response = True
+                        # Print the agent's direct response from history
+                        if show_step_details:
+                            live_log.update(status, refresh=True)
+                            agent_response_panel = create_panel(
+                                content=Markdown(str(response.content)) if markdown else str(response.content),
+                                title="Workflow Agent Response",
+                                border_style="green",
+                            )
+                            console.print(agent_response_panel)  # type: ignore
+                            step_started_printed = True
                     # For callable functions, print the final content block here since there are no step events
-                    if is_callable_function and show_step_details and current_step_content and not step_started_printed:
+                    elif (
+                        is_callable_function and show_step_details and current_step_content and not step_started_printed
+                    ):
                         final_step_panel = create_panel(
                             content=Markdown(current_step_content) if markdown else current_step_content,
                             title="Custom Function (Completed)",
@@ -1450,8 +1542,8 @@ async def aprint_response_stream(
 
                     live_log.update(status, refresh=True)
 
-                    # Show final summary
-                    if response.metadata:
+                    # Show final summary (skip for agent responses)
+                    if response.metadata and not is_workflow_agent_response:
                         status = response.status
                         summary_content = ""
                         summary_content += f"""\n\n**Status:** {status}"""
@@ -1499,6 +1591,11 @@ async def aprint_response_stream(
                                 # Extract the content from the streaming event
                                 response_str = response.content  # type: ignore
 
+                                # If we get RunContentEvent BEFORE workflow starts, it's an agent direct response
+                                if isinstance(response, RunContentEvent) and not workflow_started:
+                                    is_workflow_agent_response = True
+                                    continue  # Skip ALL agent direct response content
+
                                 # Check if this is a team's final structured output
                                 is_structured_output = (
                                     isinstance(response, TeamRunContentEvent)
@@ -1508,6 +1605,9 @@ async def aprint_response_stream(
                                 )
                         elif isinstance(response, RunContentEvent) and current_step_executor_type != "team":
                             response_str = response.content  # type: ignore
+                            # If we get RunContentEvent BEFORE workflow starts, it's an agent direct response
+                            if not workflow_started and not is_workflow_agent_response:
+                                is_workflow_agent_response = True
                         else:
                             continue
 
@@ -1530,8 +1630,8 @@ async def aprint_response_stream(
                         else:
                             current_step_content += response_str
 
-                        # Live update the step panel with streaming content
-                        if show_step_details and not step_started_printed:
+                        # Live update the step panel with streaming content (skip for workflow agent responses)
+                        if show_step_details and not step_started_printed and not is_workflow_agent_response:
                             # Generate smart step number for streaming title (will use cached value)
                             step_display = get_step_display_number(current_step_index, current_step_name)
                             title = f"{step_display}: {current_step_name} (Streaming...)"
@@ -1553,8 +1653,7 @@ async def aprint_response_stream(
 
             live_log.update("")
 
-            # Final completion message
-            if show_time:
+            if show_time and not is_workflow_agent_response:
                 completion_text = Text(f"Completed in {response_timer.elapsed:.1f}s", style="bold green")
                 console.print(completion_text)  # type: ignore
 

agno/vectordb/milvus/milvus.py

@@ -719,6 +719,11 @@ class Milvus(VectorDb):
                 )
             )
 
+        # Apply reranker if available
+        if self.reranker and search_results:
+            search_results = self.reranker.rerank(query=query, documents=search_results)
+            search_results = search_results[:limit]
+
         log_info(f"Found {len(search_results)} documents")
         return search_results
 

agno/workflow/__init__.py

@@ -1,3 +1,4 @@
+from agno.workflow.agent import WorkflowAgent
 from agno.workflow.condition import Condition
 from agno.workflow.loop import Loop
 from agno.workflow.parallel import Parallel
@@ -9,6 +10,7 @@ from agno.workflow.workflow import Workflow
 
 __all__ = [
     "Workflow",
+    "WorkflowAgent",
     "Steps",
     "Step",
     "Loop",

agno/workflow/agent.py

@@ -0,0 +1,298 @@
+"""WorkflowAgent - A restricted Agent for workflow orchestration"""
+
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+
+from agno.agent import Agent
+from agno.models.base import Model
+from agno.workflow.types import WebSocketHandler
+
+if TYPE_CHECKING:
+    from agno.session.workflow import WorkflowSession
+    from agno.workflow.types import WorkflowExecutionInput
+
+
+class WorkflowAgent(Agent):
+    """
+    A restricted Agent class specifically designed for workflow orchestration.
+    This agent can:
+    1. Decide whether to run the workflow or answer directly from history
+    2. Call the workflow execution tool when needed
+    3. Access workflow session history for context
+    Restrictions:
+    - Only model configuration allowed
+    - No custom tools (tools are set by workflow)
+    - No knowledge base
+    - Limited configuration options
+    """
+
+    def __init__(
+        self,
+        model: Model,
+        instructions: Optional[str] = None,
+        add_workflow_history: bool = True,
+        num_history_runs: int = 5,
+    ):
+        """
+        Initialize WorkflowAgent with restricted parameters.
+        Args:
+            model: The model to use for the agent (required)
+            instructions: Custom instructions (will be combined with workflow context)
+            add_workflow_history: Whether to add workflow history to context (default: True)
+            num_history_runs: Number of previous workflow runs to include in context (default: 5)
+        """
+        self.add_workflow_history = add_workflow_history
+
+        default_instructions = """You are a workflow orchestration agent. Your job is to help users by either:
+1. **Answering directly** from the workflow history context if the question can be answered from previous runs
+2. **Running the workflow** by calling the run_workflow tool ONCE when you need to process a new query
+
+Guidelines:
+- ALWAYS check the workflow history first before calling the tool
+- Answer directly from history if:
+    * The user asks about something already in history
+    * The user asks for comparisons/analysis of things in history (e.g., "compare X and Y")
+    * The user asks follow-up questions about previous results
+- Only call the run_workflow tool for NEW topics not covered in history
+- IMPORTANT: Do NOT call the tool multiple times. Call it once and use the result.
+- Keep your responses concise and helpful
+- When you must call the workflow, pass a clear and concise query
+
+{workflow_context}
+"""
+
+        if instructions:
+            if "{workflow_context}" not in instructions:
+                # Add the workflow context placeholder
+                final_instructions = f"{instructions}\n\n{{workflow_context}}"
+            else:
+                final_instructions = instructions
+        else:
+            final_instructions = default_instructions
+
+        super().__init__(
+            model=model,
+            instructions=final_instructions,
+            resolve_in_context=True,
+            num_history_runs=num_history_runs,
+        )
+
+    def create_workflow_tool(
+        self,
+        workflow: "Any",  # Workflow type
+        session: "WorkflowSession",
+        execution_input: "WorkflowExecutionInput",
+        session_state: Optional[Dict[str, Any]],
+        stream: bool = False,
+    ) -> Callable:
+        """
+        Create the workflow execution tool that this agent can call.
+        This is similar to how Agent has search_knowledge_base() method.
+        Args:
+            workflow: The workflow instance
+            session: The workflow session
+            execution_input: The execution input
+            session_state: The session state
+            stream: Whether to stream the workflow execution
+        Returns:
+            Callable tool function
+        """
+        from datetime import datetime
+        from uuid import uuid4
+
+        from pydantic import BaseModel
+
+        from agno.run.workflow import WorkflowRunOutput
+        from agno.utils.log import log_debug
+        from agno.workflow.types import WorkflowExecutionInput
+
+        def run_workflow(query: str):
+            """
+            Execute the complete workflow with the given query.
+            Use this tool when you need to run the workflow to answer the user's question.
+
+            Args:
+                query: The input query/question to process through the workflow
+            Returns:
+                The workflow execution result (str in non-streaming, generator in streaming)
+            """
+            # Reload session to get latest data from database
+            # This ensures we don't overwrite any updates made after the tool was created
+            session_from_db = workflow.get_session(session_id=session.session_id)
+            if session_from_db is None:
+                session_from_db = session  # Fallback to closure session if reload fails
+                log_debug(f"Fallback to closure session: {len(session_from_db.runs or [])} runs")
+            else:
+                log_debug(f"Reloaded session before tool execution: {len(session_from_db.runs or [])} runs")
+
+            # Create a new run ID for this execution
+            run_id = str(uuid4())
+
+            workflow_run_response = WorkflowRunOutput(
+                run_id=run_id,
+                input=execution_input.input,  # Use original user input
+                session_id=session_from_db.session_id,
+                workflow_id=workflow.id,
+                workflow_name=workflow.name,
+                created_at=int(datetime.now().timestamp()),
+            )
+
+            workflow_execution_input = WorkflowExecutionInput(
+                input=query,  # Agent's refined query for execution
+                additional_data=execution_input.additional_data,
+                audio=execution_input.audio,
+                images=execution_input.images,
+                videos=execution_input.videos,
+                files=execution_input.files,
+            )
+
+            # ===== EXECUTION LOGIC (Based on streaming mode) =====
+            if stream:
+                final_content = ""
+                for event in workflow._execute_stream(
+                    session=session_from_db,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    session_state=session_state,
+                    stream_events=True,
+                ):
+                    yield event
+
+                    # Capture final content from WorkflowCompletedEvent
+                    from agno.run.workflow import WorkflowCompletedEvent
+
+                    if isinstance(event, WorkflowCompletedEvent):
+                        final_content = str(event.content) if event.content else ""
+
+                return final_content
+            else:
+                # NON-STREAMING MODE: Execute synchronously
+                result = workflow._execute(
+                    session=session_from_db,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    session_state=session_state,
+                )
+
+                if isinstance(result.content, str):
+                    return result.content
+                elif isinstance(result.content, BaseModel):
+                    return result.content.model_dump_json(exclude_none=True)
+                else:
+                    return str(result.content)
+
+        return run_workflow
+
+    def async_create_workflow_tool(
+        self,
+        workflow: "Any",  # Workflow type
+        session: "WorkflowSession",
+        execution_input: "WorkflowExecutionInput",
+        session_state: Optional[Dict[str, Any]],
+        stream: bool = False,
+        websocket_handler: Optional[WebSocketHandler] = None,
+    ) -> Callable:
+        """
+        Create the async workflow execution tool that this agent can call.
+        This is the async counterpart of create_workflow_tool.
+
+        Args:
+            workflow: The workflow instance
+            session: The workflow session
+            execution_input: The execution input
+            session_state: The session state
+            stream: Whether to stream the workflow execution
+
+        Returns:
+            Async callable tool function
+        """
+        from datetime import datetime
+        from uuid import uuid4
+
+        from pydantic import BaseModel
+
+        from agno.run.workflow import WorkflowRunOutput
+        from agno.utils.log import log_debug
+        from agno.workflow.types import WorkflowExecutionInput
+
+        async def run_workflow(query: str):
+            """
+            Execute the complete workflow with the given query asynchronously.
+            Use this tool when you need to run the workflow to answer the user's question.
+
+            Args:
+                query: The input query/question to process through the workflow
+
+            Returns:
+                The workflow execution result (str in non-streaming, async generator in streaming)
+            """
+            # Reload session to get latest data from database
+            # This ensures we don't overwrite any updates made after the tool was created
+            # Use async or sync method based on database type
+            if workflow._has_async_db():
+                session_from_db = await workflow.aget_session(session_id=session.session_id)
+            else:
+                session_from_db = workflow.get_session(session_id=session.session_id)
+
+            if session_from_db is None:
+                session_from_db = session  # Fallback to closure session if reload fails
+                log_debug(f"Fallback to closure session: {len(session_from_db.runs or [])} runs")
+            else:
+                log_debug(f"Reloaded session before async tool execution: {len(session_from_db.runs or [])} runs")
+
+            # Create a new run ID for this execution
+            run_id = str(uuid4())
+
+            workflow_run_response = WorkflowRunOutput(
+                run_id=run_id,
+                input=execution_input.input,  # Use original user input
+                session_id=session_from_db.session_id,
+                workflow_id=workflow.id,
+                workflow_name=workflow.name,
+                created_at=int(datetime.now().timestamp()),
+            )
+
+            workflow_execution_input = WorkflowExecutionInput(
+                input=query,  # Agent's refined query for execution
+                additional_data=execution_input.additional_data,
+                audio=execution_input.audio,
+                images=execution_input.images,
+                videos=execution_input.videos,
+                files=execution_input.files,
+            )
+
+            if stream:
+                final_content = ""
+                async for event in workflow._aexecute_stream(
+                    session_id=session_from_db.session_id,
+                    user_id=session_from_db.user_id,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    session_state=session_state,
+                    stream_events=True,
+                    websocket_handler=websocket_handler,
+                ):
+                    yield event
+
+                    from agno.run.workflow import WorkflowCompletedEvent
+
+                    if isinstance(event, WorkflowCompletedEvent):
+                        final_content = str(event.content) if event.content else ""
+
+                yield final_content
+            else:
+                result = await workflow._aexecute(
+                    session_id=session_from_db.session_id,
+                    user_id=session_from_db.user_id,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    session_state=session_state,
+                )
+
+                if isinstance(result.content, str):
+                    yield result.content
+                elif isinstance(result.content, BaseModel):
+                    yield result.content.model_dump_json(exclude_none=True)
+                else:
+                    yield str(result.content)
+
+        return run_workflow