agno 2.3.25__py3-none-any.whl → 2.4.0__py3-none-any.whl

agno/tools/workflow.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, Field
 
+from agno.run import RunContext
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
 from agno.workflow.workflow import Workflow, WorkflowRunOutput
@@ -65,7 +66,7 @@ class WorkflowTools(Toolkit):
             else:
                 self.register(self.analyze, name="analyze")
 
-    def think(self, session_state: Dict[str, Any], thought: str) -> str:
+    def think(self, run_context: RunContext, thought: str) -> str:
         """Use this tool as a scratchpad to reason about the workflow execution, refine your approach, brainstorm workflow inputs, or revise your plan.
         Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan workflow inputs, or decide on execution strategy.
         You should use this tool as frequently as needed.
@@ -76,14 +77,14 @@ class WorkflowTools(Toolkit):
             log_debug(f"Workflow Thought: {thought}")
 
             # Add the thought to the session state
-            if session_state is None:
-                session_state = {}
-            if "workflow_thoughts" not in session_state:
-                session_state["workflow_thoughts"] = []
-            session_state["workflow_thoughts"].append(thought)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "workflow_thoughts" not in run_context.session_state:
+                run_context.session_state["workflow_thoughts"] = []
+            run_context.session_state["workflow_thoughts"].append(thought)
 
             # Return the full log of thoughts and the new thought
-            thoughts = "\n".join([f"- {t}" for t in session_state["workflow_thoughts"]])
+            thoughts = "\n".join([f"- {t}" for t in run_context.session_state["workflow_thoughts"]])
             formatted_thoughts = dedent(
                 f"""Workflow Thoughts:
                 {thoughts}
@@ -94,7 +95,7 @@ class WorkflowTools(Toolkit):
             log_error(f"Error recording workflow thought: {e}")
             return f"Error recording workflow thought: {e}"
 
-    async def async_think(self, session_state: Dict[str, Any], thought: str) -> str:
+    async def async_think(self, run_context: RunContext, thought: str) -> str:
         """Use this tool as a scratchpad to reason about the workflow execution, refine your approach, brainstorm workflow inputs, or revise your plan.
         Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan workflow inputs, or decide on execution strategy.
         You should use this tool as frequently as needed.
@@ -105,14 +106,14 @@ class WorkflowTools(Toolkit):
             log_debug(f"Workflow Thought: {thought}")
 
             # Add the thought to the session state
-            if session_state is None:
-                session_state = {}
-            if "workflow_thoughts" not in session_state:
-                session_state["workflow_thoughts"] = []
-            session_state["workflow_thoughts"].append(thought)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "workflow_thoughts" not in run_context.session_state:
+                run_context.session_state["workflow_thoughts"] = []
+            run_context.session_state["workflow_thoughts"].append(thought)
 
             # Return the full log of thoughts and the new thought
-            thoughts = "\n".join([f"- {t}" for t in session_state["workflow_thoughts"]])
+            thoughts = "\n".join([f"- {t}" for t in run_context.session_state["workflow_thoughts"]])
             formatted_thoughts = dedent(
                 f"""Workflow Thoughts:
                 {thoughts}
@@ -125,7 +126,7 @@ class WorkflowTools(Toolkit):
 
     def run_workflow(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         input: RunWorkflowInput,
     ) -> str:
         """Use this tool to execute the workflow with the specified inputs and parameters.
@@ -140,22 +141,22 @@ class WorkflowTools(Toolkit):
         try:
             log_debug(f"Running workflow with input: {input.input_data}")
 
-            user_id = session_state.get("current_user_id")
-            session_id = session_state.get("current_session_id")
+            if run_context.session_state is None:
+                run_context.session_state = {}
 
             # Execute the workflow
             result: WorkflowRunOutput = self.workflow.run(
                 input=input.input_data,
-                user_id=user_id,
-                session_id=session_id,
-                session_state=session_state,
+                user_id=run_context.user_id,
+                session_id=run_context.session_id,
+                session_state=run_context.session_state,
                 additional_data=input.additional_data,
             )
 
-            if "workflow_results" not in session_state:
-                session_state["workflow_results"] = []
+            if "workflow_results" not in run_context.session_state:
+                run_context.session_state["workflow_results"] = []
 
-            session_state["workflow_results"].append(result.to_dict())
+            run_context.session_state["workflow_results"].append(result.to_dict())
 
             return json.dumps(result.to_dict(), indent=2)
 
@@ -165,7 +166,7 @@ class WorkflowTools(Toolkit):
 
     async def async_run_workflow(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         input: RunWorkflowInput,
     ) -> str:
         """Use this tool to execute the workflow with the specified inputs and parameters.
@@ -180,22 +181,22 @@ class WorkflowTools(Toolkit):
         try:
             log_debug(f"Running workflow with input: {input.input_data}")
 
-            user_id = session_state.get("current_user_id")
-            session_id = session_state.get("current_session_id")
+            if run_context.session_state is None:
+                run_context.session_state = {}
 
             # Execute the workflow
             result: WorkflowRunOutput = await self.workflow.arun(
                 input=input.input_data,
-                user_id=user_id,
-                session_id=session_id,
-                session_state=session_state,
+                user_id=run_context.user_id,
+                session_id=run_context.session_id,
+                session_state=run_context.session_state,
                 additional_data=input.additional_data,
             )
 
-            if "workflow_results" not in session_state:
-                session_state["workflow_results"] = []
+            if "workflow_results" not in run_context.session_state:
+                run_context.session_state["workflow_results"] = []
 
-            session_state["workflow_results"].append(result.to_dict())
+            run_context.session_state["workflow_results"].append(result.to_dict())
 
             return json.dumps(result.to_dict(), indent=2)
 
@@ -203,7 +204,7 @@ class WorkflowTools(Toolkit):
             log_error(f"Error running workflow: {e}")
             return f"Error running workflow: {e}"
 
-    def analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+    def analyze(self, run_context: RunContext, analysis: str) -> str:
         """Use this tool to evaluate whether the workflow execution results are correct and sufficient.
         If not, go back to "Think" or "Run" with refined inputs or parameters.
         Args:
@@ -213,14 +214,14 @@ class WorkflowTools(Toolkit):
             log_debug(f"Workflow Analysis: {analysis}")
 
             # Add the analysis to the session state
-            if session_state is None:
-                session_state = {}
-            if "workflow_analysis" not in session_state:
-                session_state["workflow_analysis"] = []
-            session_state["workflow_analysis"].append(analysis)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "workflow_analysis" not in run_context.session_state:
+                run_context.session_state["workflow_analysis"] = []
+            run_context.session_state["workflow_analysis"].append(analysis)
 
             # Return the full log of analysis and the new analysis
-            analysis_log = "\n".join([f"- {a}" for a in session_state["workflow_analysis"]])
+            analysis_log = "\n".join([f"- {a}" for a in run_context.session_state["workflow_analysis"]])
             formatted_analysis = dedent(
                 f"""Workflow Analysis:
                 {analysis_log}
@@ -231,7 +232,7 @@ class WorkflowTools(Toolkit):
             log_error(f"Error recording workflow analysis: {e}")
             return f"Error recording workflow analysis: {e}"
 
-    async def async_analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+    async def async_analyze(self, run_context: RunContext, analysis: str) -> str:
         """Use this tool to evaluate whether the workflow execution results are correct and sufficient.
         If not, go back to "Think" or "Run" with refined inputs or parameters.
         Args:
@@ -241,14 +242,14 @@ class WorkflowTools(Toolkit):
             log_debug(f"Workflow Analysis: {analysis}")
 
             # Add the analysis to the session state
-            if session_state is None:
-                session_state = {}
-            if "workflow_analysis" not in session_state:
-                session_state["workflow_analysis"] = []
-            session_state["workflow_analysis"].append(analysis)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "workflow_analysis" not in run_context.session_state:
+                run_context.session_state["workflow_analysis"] = []
+            run_context.session_state["workflow_analysis"].append(analysis)
 
             # Return the full log of analysis and the new analysis
-            analysis_log = "\n".join([f"- {a}" for a in session_state["workflow_analysis"]])
+            analysis_log = "\n".join([f"- {a}" for a in run_context.session_state["workflow_analysis"]])
             formatted_analysis = dedent(
                 f"""Workflow Analysis:
                 {analysis_log}
@@ -262,7 +263,7 @@ class WorkflowTools(Toolkit):
     DEFAULT_INSTRUCTIONS = dedent("""\
         You have access to the Think, Run Workflow, and Analyze tools that will help you execute workflows and analyze their results. Use these tools as frequently as needed to successfully complete workflow-based tasks.
         ## How to use the Think, Run Workflow, and Analyze tools:
-        
+
         1. **Think**
         - Purpose: A scratchpad for planning workflow execution, brainstorming inputs, and refining your approach. You never reveal your "Think" content to the user.
         - Usage: Call `think` whenever you need to figure out what workflow inputs to use, analyze requirements, or decide on execution strategy before (or after) you run the workflow.

agno/utils/agent.py

@@ -1,5 +1,19 @@
+import asyncio
 from asyncio import Future, Task
-from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Dict, Iterator, List, Optional, Sequence, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+)
 
 from pydantic import BaseModel
 
@@ -84,6 +98,7 @@ async def await_for_thread_tasks_stream(
     stream_events: bool = False,
     events_to_skip: Optional[List[RunEvent]] = None,
     store_events: bool = False,
+    get_memories_callback: Optional[Callable[[], Union[Optional[List[Any]], Awaitable[Optional[List[Any]]]]]] = None,
 ) -> AsyncIterator[RunOutputEvent]:
     if memory_task is not None:
         if stream_events:
@@ -106,16 +121,29 @@ async def await_for_thread_tasks_stream(
         except Exception as e:
             log_warning(f"Error in memory creation: {str(e)}")
         if stream_events:
+            # Get memories after update if callback provided
+            memories = None
+            if get_memories_callback is not None:
+                try:
+                    result = get_memories_callback()
+                    # Handle both sync and async callbacks
+                    if asyncio.iscoroutine(result):
+                        memories = await result
+                    else:
+                        memories = result
+                except Exception as e:
+                    log_warning(f"Error getting memories: {str(e)}")
+
             if isinstance(run_response, TeamRunOutput):
                 yield handle_event(  # type: ignore
-                    create_team_memory_update_completed_event(from_run_response=run_response),
+                    create_team_memory_update_completed_event(from_run_response=run_response, memories=memories),
                     run_response,
                     events_to_skip=events_to_skip,  # type: ignore
                     store_events=store_events,
                 )
             else:
                 yield handle_event(  # type: ignore
-                    create_memory_update_completed_event(from_run_response=run_response),
+                    create_memory_update_completed_event(from_run_response=run_response, memories=memories),
                     run_response,
                     events_to_skip=events_to_skip,  # type: ignore
                     store_events=store_events,
@@ -142,6 +170,7 @@ def wait_for_thread_tasks_stream(
     stream_events: bool = False,
     events_to_skip: Optional[List[RunEvent]] = None,
     store_events: bool = False,
+    get_memories_callback: Optional[Callable[[], Optional[List[Any]]]] = None,
 ) -> Iterator[Union[RunOutputEvent, TeamRunOutputEvent]]:
     if memory_future is not None:
         if stream_events:
@@ -164,16 +193,24 @@ def wait_for_thread_tasks_stream(
         except Exception as e:
             log_warning(f"Error in memory creation: {str(e)}")
         if stream_events:
+            # Get memories after update if callback provided
+            memories = None
+            if get_memories_callback is not None:
+                try:
+                    memories = get_memories_callback()
+                except Exception as e:
+                    log_warning(f"Error getting memories: {str(e)}")
+
             if isinstance(run_response, TeamRunOutput):
                 yield handle_event(  # type: ignore
-                    create_team_memory_update_completed_event(from_run_response=run_response),
+                    create_team_memory_update_completed_event(from_run_response=run_response, memories=memories),
                     run_response,
                     events_to_skip=events_to_skip,  # type: ignore
                     store_events=store_events,
                 )
             else:
                 yield handle_event(  # type: ignore
-                    create_memory_update_completed_event(from_run_response=run_response),
+                    create_memory_update_completed_event(from_run_response=run_response, memories=memories),
                     run_response,
                     events_to_skip=events_to_skip,  # type: ignore
                     store_events=store_events,

agno/utils/events.py

@@ -5,8 +5,12 @@ from agno.models.message import Citations
 from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
 from agno.run.agent import (
+    CompressionCompletedEvent,
+    CompressionStartedEvent,
     MemoryUpdateCompletedEvent,
     MemoryUpdateStartedEvent,
+    ModelRequestCompletedEvent,
+    ModelRequestStartedEvent,
     OutputModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
@@ -38,8 +42,12 @@ from agno.run.agent import (
     ToolCallStartedEvent,
 )
 from agno.run.requirement import RunRequirement
+from agno.run.team import CompressionCompletedEvent as TeamCompressionCompletedEvent
+from agno.run.team import CompressionStartedEvent as TeamCompressionStartedEvent
 from agno.run.team import MemoryUpdateCompletedEvent as TeamMemoryUpdateCompletedEvent
 from agno.run.team import MemoryUpdateStartedEvent as TeamMemoryUpdateStartedEvent
+from agno.run.team import ModelRequestCompletedEvent as TeamModelRequestCompletedEvent
+from agno.run.team import ModelRequestStartedEvent as TeamModelRequestStartedEvent
 from agno.run.team import OutputModelResponseCompletedEvent as TeamOutputModelResponseCompletedEvent
 from agno.run.team import OutputModelResponseStartedEvent as TeamOutputModelResponseStartedEvent
 from agno.run.team import ParserModelResponseCompletedEvent as TeamParserModelResponseCompletedEvent
@@ -349,21 +357,27 @@ def create_team_memory_update_started_event(from_run_response: TeamRunOutput) ->
     )
 
 
-def create_memory_update_completed_event(from_run_response: RunOutput) -> MemoryUpdateCompletedEvent:
+def create_memory_update_completed_event(
+    from_run_response: RunOutput, memories: Optional[List[Any]] = None
+) -> MemoryUpdateCompletedEvent:
     return MemoryUpdateCompletedEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
         run_id=from_run_response.run_id,
+        memories=memories,
     )
 
 
-def create_team_memory_update_completed_event(from_run_response: TeamRunOutput) -> TeamMemoryUpdateCompletedEvent:
+def create_team_memory_update_completed_event(
+    from_run_response: TeamRunOutput, memories: Optional[List[Any]] = None
+) -> TeamMemoryUpdateCompletedEvent:
     return TeamMemoryUpdateCompletedEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
         run_id=from_run_response.run_id,
+        memories=memories,
     )
 
 
@@ -759,6 +773,150 @@ def create_team_output_model_response_completed_event(
     )
 
 
+def create_model_request_started_event(
+    from_run_response: RunOutput,
+    model: Optional[str] = None,
+    model_provider: Optional[str] = None,
+) -> ModelRequestStartedEvent:
+    return ModelRequestStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        model=model,
+        model_provider=model_provider,
+    )
+
+
+def create_model_request_completed_event(
+    from_run_response: RunOutput,
+    model: Optional[str] = None,
+    model_provider: Optional[str] = None,
+    input_tokens: Optional[int] = None,
+    output_tokens: Optional[int] = None,
+    total_tokens: Optional[int] = None,
+    time_to_first_token: Optional[float] = None,
+    reasoning_tokens: Optional[int] = None,
+    cache_read_tokens: Optional[int] = None,
+    cache_write_tokens: Optional[int] = None,
+) -> ModelRequestCompletedEvent:
+    return ModelRequestCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        model=model,
+        model_provider=model_provider,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        total_tokens=total_tokens,
+        time_to_first_token=time_to_first_token,
+        reasoning_tokens=reasoning_tokens,
+        cache_read_tokens=cache_read_tokens,
+        cache_write_tokens=cache_write_tokens,
+    )
+
+
+def create_team_model_request_started_event(
+    from_run_response: TeamRunOutput,
+    model: Optional[str] = None,
+    model_provider: Optional[str] = None,
+) -> TeamModelRequestStartedEvent:
+    return TeamModelRequestStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        model=model,
+        model_provider=model_provider,
+    )
+
+
+def create_team_model_request_completed_event(
+    from_run_response: TeamRunOutput,
+    model: Optional[str] = None,
+    model_provider: Optional[str] = None,
+    input_tokens: Optional[int] = None,
+    output_tokens: Optional[int] = None,
+    total_tokens: Optional[int] = None,
+    time_to_first_token: Optional[float] = None,
+    reasoning_tokens: Optional[int] = None,
+    cache_read_tokens: Optional[int] = None,
+    cache_write_tokens: Optional[int] = None,
+) -> TeamModelRequestCompletedEvent:
+    return TeamModelRequestCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        model=model,
+        model_provider=model_provider,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        total_tokens=total_tokens,
+        time_to_first_token=time_to_first_token,
+        reasoning_tokens=reasoning_tokens,
+        cache_read_tokens=cache_read_tokens,
+        cache_write_tokens=cache_write_tokens,
+    )
+
+
+def create_compression_started_event(
+    from_run_response: RunOutput,
+) -> CompressionStartedEvent:
+    return CompressionStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_compression_completed_event(
+    from_run_response: RunOutput,
+    tool_results_compressed: Optional[int] = None,
+    original_size: Optional[int] = None,
+    compressed_size: Optional[int] = None,
+) -> CompressionCompletedEvent:
+    return CompressionCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        tool_results_compressed=tool_results_compressed,
+        original_size=original_size,
+        compressed_size=compressed_size,
+    )
+
+
+def create_team_compression_started_event(
+    from_run_response: TeamRunOutput,
+) -> TeamCompressionStartedEvent:
+    return TeamCompressionStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_team_compression_completed_event(
+    from_run_response: TeamRunOutput,
+    tool_results_compressed: Optional[int] = None,
+    original_size: Optional[int] = None,
+    compressed_size: Optional[int] = None,
+) -> TeamCompressionCompletedEvent:
+    return TeamCompressionCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        tool_results_compressed=tool_results_compressed,
+        original_size=original_size,
+        compressed_size=compressed_size,
+    )
+
+
 def handle_event(
     event: Union[RunOutputEvent, TeamRunOutputEvent],
     run_response: Union[RunOutput, TeamRunOutput],

agno/utils/print_response/agent.py

@@ -1,5 +1,4 @@
 import json
-import warnings
 from collections.abc import Set
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union, cast, get_args
 
@@ -555,8 +554,6 @@ def print_response(
     videos: Optional[Sequence[Video]] = None,
     files: Optional[Sequence[File]] = None,
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
-    stream_events: Optional[bool] = None,
-    stream_intermediate_steps: Optional[bool] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
     show_message: bool = True,
@@ -571,19 +568,6 @@ def print_response(
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
-    if stream_events is not None:
-        warnings.warn(
-            "The 'stream_events' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the print_response function.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-    if stream_intermediate_steps is not None:
-        warnings.warn(
-            "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the print_response function.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     with Live(console=console) as live_log:
         status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_log.update(status)
@@ -695,8 +679,6 @@ async def aprint_response(
     show_message: bool = True,
     show_reasoning: bool = True,
     show_full_reasoning: bool = False,
-    stream_events: Optional[bool] = None,
-    stream_intermediate_steps: Optional[bool] = None,
     tags_to_include_in_markdown: Set[str] = {"think", "thinking"},
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
@@ -706,19 +688,6 @@ async def aprint_response(
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
-    if stream_events is not None:
-        warnings.warn(
-            "The 'stream_events' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the aprint_response function.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-    if stream_intermediate_steps is not None:
-        warnings.warn(
-            "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the aprint_response function.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     with Live(console=console) as live_log:
         status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_log.update(status)

agno/utils/print_response/team.py

@@ -373,7 +373,6 @@ def print_response_stream(
     files: Optional[Sequence[File]] = None,
     markdown: bool = False,
     stream_events: bool = False,
-    stream_intermediate_steps: bool = False,  # type: ignore
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
@@ -1303,7 +1302,6 @@ async def aprint_response_stream(
     files: Optional[Sequence[File]] = None,
     markdown: bool = False,
     stream_events: bool = False,
-    stream_intermediate_steps: bool = False,  # type: ignore
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,

agno/utils/print_response/workflow.py

@@ -203,7 +203,6 @@ def print_response_stream(
     videos: Optional[List[Video]] = None,
     files: Optional[List[File]] = None,
     stream_events: bool = False,
-    stream_intermediate_steps: bool = False,
     markdown: bool = True,
     show_time: bool = True,
     show_step_details: bool = True,
@@ -1042,7 +1041,6 @@ async def aprint_response_stream(
     videos: Optional[List[Video]] = None,
     files: Optional[List[File]] = None,
     stream_events: bool = False,
-    stream_intermediate_steps: bool = False,
     markdown: bool = True,
     show_time: bool = True,
     show_step_details: bool = True,