agno 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

agno/tools/mem0.py

@@ -2,7 +2,6 @@ import json
 from os import getenv
 from typing import Any, Dict, List, Optional, Union
 
-from agno.agent import Agent
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error, log_warning
 
@@ -69,15 +68,13 @@ class Mem0Tools(Toolkit):
     def _get_user_id(
         self,
         method_name: str,
-        agent: Optional[Agent] = None,
+        session_state: Dict[str, Any],
     ) -> str:
         """Resolve the user ID"""
         resolved_user_id = self.user_id
-        if not resolved_user_id and agent is not None:
+        if not resolved_user_id:
             try:
-                session_state = getattr(agent, "session_state", None)
-                if isinstance(session_state, dict):
-                    resolved_user_id = session_state.get("current_user_id")
+                resolved_user_id = session_state.get("current_user_id")
             except Exception:
                 pass
         if not resolved_user_id:
@@ -88,7 +85,7 @@ class Mem0Tools(Toolkit):
 
     def add_memory(
         self,
-        agent: Agent,
+        session_state,
         content: Union[str, Dict[str, str]],
     ) -> str:
         """Add facts to the user's memory.
@@ -101,7 +98,7 @@ class Mem0Tools(Toolkit):
             str: JSON-encoded Mem0 response or an error message.
         """
 
-        resolved_user_id = self._get_user_id("add_memory", agent=agent)
+        resolved_user_id = self._get_user_id("add_memory", session_state=session_state)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in add_memory:"):
             return resolved_user_id
         try:
@@ -116,7 +113,6 @@ class Mem0Tools(Toolkit):
                 messages_list,
                 user_id=resolved_user_id,
                 infer=self.infer,
-                output_format="v1.1",
             )
             return json.dumps(result)
         except Exception as e:
@@ -125,19 +121,18 @@ class Mem0Tools(Toolkit):
 
     def search_memory(
         self,
-        agent: Agent,
+        session_state: Dict[str, Any],
         query: str,
     ) -> str:
         """Semantic search for *query* across the user's stored memories."""
 
-        resolved_user_id = self._get_user_id("search_memory", agent=agent)
+        resolved_user_id = self._get_user_id("search_memory", session_state=session_state)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in search_memory:"):
             return resolved_user_id
         try:
             results = self.client.search(
                 query=query,
                 user_id=resolved_user_id,
-                output_format="v1.1",
             )
 
             if isinstance(results, dict) and "results" in results:
@@ -156,16 +151,15 @@ class Mem0Tools(Toolkit):
             log_error(f"Error searching memory: {e}")
             return f"Error searching memory: {e}"
 
-    def get_all_memories(self, agent: Agent) -> str:
+    def get_all_memories(self, session_state: Dict[str, Any]) -> str:
         """Return **all** memories for the current user as a JSON string."""
 
-        resolved_user_id = self._get_user_id("get_all_memories", agent=agent)
+        resolved_user_id = self._get_user_id("get_all_memories", session_state=session_state)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in get_all_memories:"):
             return resolved_user_id
         try:
             results = self.client.get_all(
                 user_id=resolved_user_id,
-                output_format="v1.1",
             )
 
             if isinstance(results, dict) and "results" in results:
@@ -183,10 +177,10 @@ class Mem0Tools(Toolkit):
             log_error(f"Error getting all memories: {e}")
             return f"Error getting all memories: {e}"
 
-    def delete_all_memories(self, agent: Agent) -> str:
+    def delete_all_memories(self, session_state: Dict[str, Any]) -> str:
         """Delete *all* memories associated with the current user"""
 
-        resolved_user_id = self._get_user_id("delete_all_memories", agent=agent)
+        resolved_user_id = self._get_user_id("delete_all_memories", session_state=session_state)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in delete_all_memories:"):
             error_msg = resolved_user_id
             log_error(error_msg)

agno/tools/memory.py

@@ -95,13 +95,28 @@ class MemoryTools(Toolkit):
 
     def get_memories(self, session_state: Dict[str, Any]) -> str:
         """
-        Use this tool to get a list of memories from the database.
+        Use this tool to get a list of memories for the current user from the database.
         """
         try:
             # Get user info from session state
             user_id = session_state.get("current_user_id") if session_state else None
 
             memories = self.db.get_user_memories(user_id=user_id)
+
+            # Store the result in session state for analysis
+            if session_state is None:
+                session_state = {}
+            if "memory_operations" not in session_state:
+                session_state["memory_operations"] = []
+
+            operation_result = {
+                "operation": "get_memories",
+                "success": True,
+                "memories": [memory.to_dict() for memory in memories],  # type: ignore
+                "error": None,
+            }
+            session_state["memory_operations"].append(operation_result)
+
             return json.dumps([memory.to_dict() for memory in memories], indent=2)  # type: ignore
         except Exception as e:
             log_error(f"Error getting memories: {e}")
@@ -328,19 +343,23 @@ class MemoryTools(Toolkit):
         - Purpose: A scratchpad for planning memory operations, brainstorming memory content, and refining your approach. You never reveal your "Think" content to the user.
         - Usage: Call `think` whenever you need to figure out what memory operations to perform, analyze requirements, or decide on strategy.
 
-        2. **Add Memory**
+        2. **Get Memories**
+        - Purpose: Retrieves a list of memories from the database for the current user.
+        - Usage: Call `get_memories` when you need to retrieve memories for the current user.
+
+        3. **Add Memory**
         - Purpose: Creates new memories in the database with specified content and metadata.
         - Usage: Call `add_memory` with memory content and optional topics when you need to store new information.
 
-        3. **Update Memory**
+        4. **Update Memory**
         - Purpose: Modifies existing memories in the database by memory ID.
         - Usage: Call `update_memory` with a memory ID and the fields you want to change. Only specify the fields that need updating.
 
-        4. **Delete Memory**
+        5. **Delete Memory**
         - Purpose: Removes memories from the database by memory ID.
         - Usage: Call `delete_memory` with a memory ID when a memory is no longer needed or requested to be removed.
 
-        5. **Analyze**
+        6. **Analyze**
         - Purpose: Evaluate whether the memory operations results are correct and sufficient. If not, go back to "Think" or use memory operations with refined parameters.
         - Usage: Call `analyze` after performing memory operations to verify:
             - Success: Did the operation complete successfully?
@@ -387,5 +406,14 @@ class MemoryTools(Toolkit):
         Delete Memory: memory_id="work_schedule_memory_id"
         Analyze: Successfully deleted the outdated work schedule memory. The old information won't interfere with future scheduling requests.
 
-        Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.\
+        Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.
+        
+        #### Example 4: Retrieving Memories
+
+        User: What have you remembered about me?
+        Think: The user wants to retrieve memories about themselves. I should use the get_memories tool to retrieve the memories.
+        Get Memories: 
+        Analyze: Successfully retrieved the memories about the user. The memories are relevant to the user's preferences and activities.
+
+        Final Answer: I've retrieved the memories about you. You like to hike in the mountains on weekends and travel to new places and experience different cultures. You are planning to travel to Africa in December.\
     """)

agno/utils/common.py

@@ -1,5 +1,5 @@
 from dataclasses import asdict
-from typing import Any, List, Optional, Type
+from typing import Any, List, Optional, Set, Type, Union, get_type_hints
 
 
 def isinstanceany(obj: Any, class_list: List[Type]) -> bool:
@@ -41,3 +41,92 @@ def nested_model_dump(value):
     elif isinstance(value, list):
         return [nested_model_dump(item) for item in value]
     return value
+
+
+def is_typed_dict(cls: Type[Any]) -> bool:
+    """Check if a class is a TypedDict"""
+    return (
+        hasattr(cls, "__annotations__")
+        and hasattr(cls, "__total__")
+        and hasattr(cls, "__required_keys__")
+        and hasattr(cls, "__optional_keys__")
+    )
+
+
+def check_type_compatibility(value: Any, expected_type: Type) -> bool:
+    """Basic type compatibility checking."""
+    from typing import get_args, get_origin
+
+    # Handle None/Optional types
+    if value is None:
+        return (
+            type(None) in get_args(expected_type) if hasattr(expected_type, "__args__") else expected_type is type(None)
+        )
+
+    # Handle Union types (including Optional)
+    origin = get_origin(expected_type)
+    if origin is Union:
+        return any(check_type_compatibility(value, arg) for arg in get_args(expected_type))
+
+    # Handle List types
+    if origin is list or expected_type is list:
+        if not isinstance(value, list):
+            return False
+        if origin is list and get_args(expected_type):
+            element_type = get_args(expected_type)[0]
+            return all(check_type_compatibility(item, element_type) for item in value)
+        return True
+
+    if expected_type in (str, int, float, bool):
+        return isinstance(value, expected_type)
+
+    if expected_type is Any:
+        return True
+
+    try:
+        return isinstance(value, expected_type)
+    except TypeError:
+        return True
+
+
+def validate_typed_dict(data: dict, schema_cls) -> dict:
+    """Validate input data against a TypedDict schema."""
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected dict for TypedDict {schema_cls.__name__}, got {type(data)}")
+
+    # Get type hints from the TypedDict
+    try:
+        type_hints = get_type_hints(schema_cls)
+    except Exception as e:
+        raise ValueError(f"Could not get type hints for TypedDict {schema_cls.__name__}: {e}")
+
+    # Get required and optional keys
+    required_keys: Set[str] = getattr(schema_cls, "__required_keys__", set())
+    optional_keys: Set[str] = getattr(schema_cls, "__optional_keys__", set())
+    all_keys = required_keys | optional_keys
+
+    # Check for missing required fields
+    missing_required = required_keys - set(data.keys())
+    if missing_required:
+        raise ValueError(f"Missing required fields in TypedDict {schema_cls.__name__}: {missing_required}")
+
+    # Check for unexpected fields
+    unexpected_fields = set(data.keys()) - all_keys
+    if unexpected_fields:
+        raise ValueError(f"Unexpected fields in TypedDict {schema_cls.__name__}: {unexpected_fields}")
+
+    # Basic type checking for provided fields
+    validated_data = {}
+    for field_name, value in data.items():
+        if field_name in type_hints:
+            expected_type = type_hints[field_name]
+
+            # Handle simple type checking
+            if not check_type_compatibility(value, expected_type):
+                raise ValueError(
+                    f"Field '{field_name}' expected type {expected_type}, got {type(value)} with value {value}"
+                )
+
+            validated_data[field_name] = value
+
+    return validated_data

agno/utils/streamlit.py

@@ -1,14 +1,20 @@
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
-import streamlit as st
-
-from agno.agent import Agent
-from agno.db.base import SessionType
-from agno.models.anthropic import Claude
-from agno.models.google import Gemini
-from agno.models.openai import OpenAIChat
-from agno.utils.log import logger
+try:
+    from agno.agent import Agent
+    from agno.db.base import SessionType
+    from agno.models.anthropic import Claude
+    from agno.models.google import Gemini
+    from agno.models.openai import OpenAIChat
+    from agno.utils.log import logger
+except ImportError:
+    raise ImportError("`agno` not installed. Please install using `pip install agno`")
+
+try:
+    import streamlit as st
+except ImportError:
+    raise ImportError("`streamlit` not installed. Please install using `pip install streamlit`")
 
 
 def add_message(role: str, content: str, tool_calls: Optional[List[Dict[str, Any]]] = None) -> None:

agno/utils/string.py

@@ -1,7 +1,9 @@
 import hashlib
 import json
 import re
+import uuid
 from typing import Optional, Type
+from uuid import uuid4
 
 from pydantic import BaseModel, ValidationError
 
@@ -188,3 +190,33 @@ def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Op
                     logger.warning("All parsing attempts failed.")
 
     return structured_output
+
+
+def generate_id(seed: Optional[str] = None) -> str:
+    """
+    Generate a deterministic UUID5 based on a seed string.
+    If no seed is provided, generate a random UUID4.
+
+    Args:
+        seed (str): The seed string to generate the UUID from.
+
+    Returns:
+        str: A deterministic UUID5 string.
+    """
+    if seed is None:
+        return str(uuid4())
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, seed))
+
+
+def generate_id_from_name(name: Optional[str] = None) -> str:
+    """
+    Generate a deterministic ID from a name string.
+    If no name is provided, generate a random UUID4.
+
+    Args:
+        name (str): The name string to generate the ID from.
+    """
+    if name:
+        return name.lower().replace(" ", "-").replace("_", "-")
+    else:
+        return str(uuid4())

agno/utils/tools.py

@@ -13,7 +13,7 @@ def get_function_call_for_tool_call(
         _tool_call_function = tool_call.get("function")
         if _tool_call_function is not None:
             _tool_call_function_name = _tool_call_function.get("name")
-            _tool_call_function_arguments_str = _tool_call_function.get("arguments")
+            _tool_call_function_arguments_str = _tool_call_function.get("arguments") or "{}"
             if _tool_call_function_name is not None:
                 return get_function_call(
                     name=_tool_call_function_name,

agno/vectordb/chroma/chromadb.py

@@ -766,9 +766,15 @@ class ChromaDb(VectorDb):
                     updated_metadatas.append(updated_meta)
 
                 # Update the documents
+                # Filter out None values from metadata as ChromaDB doesn't accept them
+                cleaned_metadatas = []
+                for meta in updated_metadatas:
+                    cleaned_meta = {k: v for k, v in meta.items() if v is not None}
+                    cleaned_metadatas.append(cleaned_meta)
+
                 # Convert to the expected type for ChromaDB
-                chroma_metadatas = cast(List[Mapping[str, Union[str, int, float, bool, None]]], updated_metadatas)
-                collection.update(ids=ids, metadatas=chroma_metadatas)
+                chroma_metadatas = cast(List[Mapping[str, Union[str, int, float, bool]]], cleaned_metadatas)
+                collection.update(ids=ids, metadatas=chroma_metadatas)  # type: ignore
                 logger.debug(f"Updated metadata for {len(ids)} documents with content_id: {content_id}")
 
             except TypeError as te:

agno/workflow/step.py

@@ -164,6 +164,38 @@ class Step:
             return response.metrics
         return None
 
+    def _call_custom_function(
+        self,
+        func: Callable,
+        step_input: StepInput,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Call custom function with session_state support if the function accepts it"""
+        if session_state is not None and self._function_has_session_state_param():
+            return func(step_input, session_state)
+        else:
+            return func(step_input)
+
+    async def _acall_custom_function(
+        self,
+        func: Callable,
+        step_input: StepInput,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Call custom async function with session_state support if the function accepts it"""
+        import inspect
+
+        if inspect.isasyncgenfunction(func):
+            if session_state is not None and self._function_has_session_state_param():
+                return func(step_input, session_state)
+            else:
+                return func(step_input)
+        else:
+            if session_state is not None and self._function_has_session_state_param():
+                return await func(step_input, session_state)
+            else:
+                return await func(step_input)
+
     def execute(
         self,
         step_input: StepInput,
@@ -191,8 +223,11 @@ class Step:
                     if inspect.isgeneratorfunction(self.active_executor):
                         content = ""
                         final_response = None
+                        session_state_copy = copy(session_state) if session_state else None
                         try:
-                            for chunk in self.active_executor(step_input):  # type: ignore
+                            for chunk in self._call_custom_function(
+                                self.active_executor, step_input, session_state_copy
+                            ):  # type: ignore
                                 if (
                                     hasattr(chunk, "content")
                                     and chunk.content is not None
@@ -208,13 +243,22 @@ class Step:
                             if hasattr(e, "value") and isinstance(e.value, StepOutput):
                                 final_response = e.value
 
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
+
                         if final_response is not None:
                             response = final_response
                         else:
                             response = StepOutput(content=content)
                     else:
-                        # Execute function directly with StepInput
-                        result = self.active_executor(step_input)  # type: ignore
+                        # Execute function with signature inspection for session_state support
+                        session_state_copy = copy(session_state) if session_state else None
+                        result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
 
                         # If function returns StepOutput, use it directly
                         if isinstance(result, StepOutput):
@@ -291,6 +335,19 @@ class Step:
 
         return StepOutput(content=f"Step {self.name} failed but skipped", success=False)
 
+    def _function_has_session_state_param(self) -> bool:
+        """Check if the custom function has a session_state parameter"""
+        if self._executor_type != "function":
+            return False
+
+        try:
+            from inspect import signature
+
+            sig = signature(self.active_executor)  # type: ignore
+            return "session_state" in sig.parameters
+        except Exception:
+            return False
+
     def execute_stream(
         self,
         step_input: StepInput,
@@ -338,8 +395,10 @@ class Step:
                     if inspect.isgeneratorfunction(self.active_executor):
                         log_debug("Function returned iterable, streaming events")
                         content = ""
+                        session_state_copy = copy(session_state) if session_state else None
                         try:
-                            for event in self.active_executor(step_input):  # type: ignore
+                            iterator = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+                            for event in iterator:  # type: ignore
                                 if (
                                     hasattr(event, "content")
                                     and event.content is not None
@@ -353,6 +412,11 @@ class Step:
                                     break
                                 else:
                                     yield event  # type: ignore[misc]
+
+                            # Merge session_state changes back
+                            if session_state_copy and session_state:
+                                merge_dictionaries(session_state, session_state_copy)
+
                             if not final_response:
                                 final_response = StepOutput(content=content)
                         except StopIteration as e:
@@ -360,7 +424,13 @@ class Step:
                                 final_response = e.value
 
                     else:
-                        result = self.active_executor(step_input)  # type: ignore
+                        session_state_copy = copy(session_state) if session_state else None
+                        result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
+
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
@@ -429,7 +499,7 @@ class Step:
                         if store_executor_outputs and workflow_run_response is not None:
                             self._store_executor_response(workflow_run_response, active_executor_run_response)  # type: ignore
 
-                        final_response = self._process_step_output(active_executor_run_response)  # type: ignore
+                        final_response = active_executor_run_response  # type: ignore
 
                     else:
                         raise ValueError(f"Unsupported executor type: {self._executor_type}")
@@ -443,6 +513,7 @@ class Step:
                 use_workflow_logger()
 
                 # Yield the step output
+                final_response = self._process_step_output(final_response)
                 yield final_response
 
                 # Emit StepCompletedEvent
@@ -505,9 +576,13 @@ class Step:
                     ):
                         content = ""
                         final_response = None
+                        session_state_copy = copy(session_state) if session_state else None
                         try:
                             if inspect.isgeneratorfunction(self.active_executor):
-                                for chunk in self.active_executor(step_input):  # type: ignore
+                                iterator = self._call_custom_function(
+                                    self.active_executor, step_input, session_state_copy
+                                )  # type: ignore
+                                for chunk in iterator:  # type: ignore
                                     if (
                                         hasattr(chunk, "content")
                                         and chunk.content is not None
@@ -520,7 +595,10 @@ class Step:
                                         final_response = chunk
                             else:
                                 if inspect.isasyncgenfunction(self.active_executor):
-                                    async for chunk in self.active_executor(step_input):  # type: ignore
+                                    iterator = await self._acall_custom_function(
+                                        self.active_executor, step_input, session_state_copy
+                                    )  # type: ignore
+                                    async for chunk in iterator:  # type: ignore
                                         if (
                                             hasattr(chunk, "content")
                                             and chunk.content is not None
@@ -536,15 +614,26 @@ class Step:
                             if hasattr(e, "value") and isinstance(e.value, StepOutput):
                                 final_response = e.value
 
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
+
                         if final_response is not None:
                             response = final_response
                         else:
                             response = StepOutput(content=content)
                     else:
+                        session_state_copy = copy(session_state) if session_state else None
                         if inspect.iscoroutinefunction(self.active_executor):
-                            result = await self.active_executor(step_input)  # type: ignore
+                            result = await self._acall_custom_function(
+                                self.active_executor, step_input, session_state_copy
+                            )  # type: ignore
                         else:
-                            result = self.active_executor(step_input)  # type: ignore
+                            result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
 
                         # If function returns StepOutput, use it directly
                         if isinstance(result, StepOutput):
@@ -662,11 +751,16 @@ class Step:
                     log_debug(f"Executing async function executor for step: {self.name}")
                     import inspect
 
+                    session_state_copy = copy(session_state) if session_state else None
+
                     # Check if the function is an async generator
                     if inspect.isasyncgenfunction(self.active_executor):
                         content = ""
                         # It's an async generator - iterate over it
-                        async for event in self.active_executor(step_input):  # type: ignore
+                        iterator = await self._acall_custom_function(
+                            self.active_executor, step_input, session_state_copy
+                        )  # type: ignore
+                        async for event in iterator:  # type: ignore
                             if (
                                 hasattr(event, "content")
                                 and event.content is not None
@@ -684,7 +778,7 @@ class Step:
                             final_response = StepOutput(content=content)
                     elif inspect.iscoroutinefunction(self.active_executor):
                         # It's a regular async function - await it
-                        result = await self.active_executor(step_input)  # type: ignore
+                        result = await self._acall_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
@@ -692,7 +786,8 @@ class Step:
                     elif inspect.isgeneratorfunction(self.active_executor):
                         content = ""
                         # It's a regular generator function - iterate over it
-                        for event in self.active_executor(step_input):  # type: ignore
+                        iterator = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+                        for event in iterator:  # type: ignore
                             if (
                                 hasattr(event, "content")
                                 and event.content is not None
@@ -710,11 +805,15 @@ class Step:
                             final_response = StepOutput(content=content)
                     else:
                         # It's a regular function - call it directly
-                        result = self.active_executor(step_input)  # type: ignore
+                        result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
                             final_response = StepOutput(content=str(result))
+
+                    # Merge session_state changes back
+                    if session_state_copy and session_state:
+                        merge_dictionaries(session_state, session_state_copy)
                 else:
                     # For agents and teams, prepare message with context
                     message = self._prepare_message(
@@ -767,7 +866,6 @@ class Step:
 
                         active_executor_run_response = None
                         async for event in response_stream:
-                            log_debug(f"Received async event from agent: {type(event).__name__}")
                             if isinstance(event, RunOutput) or isinstance(event, TeamRunOutput):
                                 active_executor_run_response = event
                                 break
@@ -779,7 +877,7 @@ class Step:
                         if store_executor_outputs and workflow_run_response is not None:
                             self._store_executor_response(workflow_run_response, active_executor_run_response)  # type: ignore
 
-                        final_response = self._process_step_output(active_executor_run_response)  # type: ignore
+                        final_response = active_executor_run_response  # type: ignore
                     else:
                         raise ValueError(f"Unsupported executor type: {self._executor_type}")
 
@@ -791,6 +889,7 @@ class Step:
                 use_workflow_logger()
 
                 # Yield the final response
+                final_response = self._process_step_output(final_response)
                 yield final_response
 
                 if stream_intermediate_steps and workflow_run_response: