agno 2.3.13__py3-none-any.whl → 2.3.15__py3-none-any.whl

agno/tools/toolkit.py

@@ -1,5 +1,5 @@
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
 from agno.tools.function import Function
 from agno.utils.log import log_debug, log_warning, logger
@@ -13,7 +13,7 @@ class Toolkit:
     def __init__(
         self,
         name: str = "toolkit",
-        tools: List[Callable] = [],
+        tools: Sequence[Union[Callable[..., Any], Function]] = [],
         instructions: Optional[str] = None,
         add_instructions: bool = False,
         include_tools: Optional[list[str]] = None,
@@ -31,7 +31,7 @@ class Toolkit:
 
         Args:
             name: A descriptive name for the toolkit
-            tools: List of tools to include in the toolkit
+            tools: List of tools to include in the toolkit (can be callables or Function objects from @tool decorator)
             instructions: Instructions for the toolkit
             add_instructions: Whether to add instructions to the toolkit
             include_tools: List of tool names to include in the toolkit
@@ -46,7 +46,7 @@ class Toolkit:
             show_result_tools (Optional[List[str]]): List of function names whose results should be shown.
         """
         self.name: str = name
-        self.tools: List[Callable] = tools
+        self.tools: Sequence[Union[Callable[..., Any], Function]] = tools
         self.functions: Dict[str, Function] = OrderedDict()
         self.instructions: Optional[str] = instructions
         self.add_instructions: bool = add_instructions
@@ -58,7 +58,9 @@ class Toolkit:
         self.show_result_tools: list[str] = show_result_tools or []
 
         self._check_tools_filters(
-            available_tools=[tool.__name__ for tool in tools], include_tools=include_tools, exclude_tools=exclude_tools
+            available_tools=[self._get_tool_name(tool) for tool in tools],
+            include_tools=include_tools,
+            exclude_tools=exclude_tools,
         )
 
         self.include_tools = include_tools
@@ -72,6 +74,12 @@ class Toolkit:
         if auto_register and self.tools:
             self._register_tools()
 
+    def _get_tool_name(self, tool: Union[Callable[..., Any], Function]) -> str:
+        """Get the name of a tool, whether it's a Function or callable."""
+        if isinstance(tool, Function):
+            return tool.name
+        return tool.__name__
+
     def _check_tools_filters(
         self,
         available_tools: List[str],
@@ -104,22 +112,45 @@ class Toolkit:
                     f"External execution required tool(s) not present in the toolkit: {', '.join(missing_external_execution_required)}"
                 )
 
+        if self.stop_after_tool_call_tools:
+            missing_stop_after_tool_call = set(self.stop_after_tool_call_tools) - set(available_tools)
+            if missing_stop_after_tool_call:
+                log_warning(
+                    f"Stop after tool call tool(s) not present in the toolkit: {', '.join(missing_stop_after_tool_call)}"
+                )
+
+        if self.show_result_tools:
+            missing_show_result = set(self.show_result_tools) - set(available_tools)
+            if missing_show_result:
+                log_warning(f"Show result tool(s) not present in the toolkit: {', '.join(missing_show_result)}")
+
     def _register_tools(self) -> None:
         """Register all tools."""
         for tool in self.tools:
             self.register(tool)
 
-    def register(self, function: Callable[..., Any], name: Optional[str] = None):
+    def register(self, function: Union[Callable[..., Any], Function], name: Optional[str] = None) -> None:
         """Register a function with the toolkit.
 
+        This method supports both regular callables and Function objects (from @tool decorator).
+        When a Function object is passed (e.g., from a @tool decorated method), it will:
+        1. Extract the configuration from the Function object
+        2. Look for a bound method with the same name on `self`
+        3. Create a new Function with the bound method as entrypoint, preserving decorator settings
+
         Args:
-            function: The callable to register
+            function: The callable or Function object to register
             name: Optional custom name for the function
 
         Returns:
             The registered function
         """
         try:
+            # Handle Function objects (from @tool decorator)
+            if isinstance(function, Function):
+                return self._register_decorated_tool(function, name)
+
+            # Handle regular callables
             tool_name = name or function.__name__
             if self.include_tools is not None and tool_name not in self.include_tools:
                 return
@@ -140,9 +171,89 @@ class Toolkit:
             self.functions[f.name] = f
             log_debug(f"Function: {f.name} registered with {self.name}")
         except Exception as e:
-            logger.warning(f"Failed to create Function for: {function.__name__}")
+            func_name = self._get_tool_name(function)
+            logger.warning(f"Failed to create Function for: {func_name}")
             raise e
 
+    def _register_decorated_tool(self, function: Function, name: Optional[str] = None) -> None:
+        """Register a Function object from @tool decorator, binding it to self.
+
+        When @tool decorator is used on a class method, it creates a Function with an unbound
+        method as entrypoint. This method creates a bound version of the entrypoint that
+        includes `self`, preserving all decorator settings.
+
+        Args:
+            function: The Function object from @tool decorator
+            name: Optional custom name override
+        """
+        import inspect
+
+        tool_name = name or function.name
+        if self.include_tools is not None and len(self.include_tools) > 0 and tool_name not in self.include_tools:
+            return
+        if self.exclude_tools is not None and len(self.exclude_tools) > 0 and tool_name in self.exclude_tools:
+            return
+
+        # Get the original entrypoint from the Function
+        if function.entrypoint is None:
+            log_warning(f"Function '{tool_name}' has no entrypoint, skipping registration")
+            return
+
+        original_func = function.entrypoint
+
+        # Check if the function expects 'self' as first argument (i.e., it's an unbound method)
+        sig = inspect.signature(original_func)
+        params = list(sig.parameters.keys())
+
+        if params and params[0] == "self":
+            # Create a bound method by wrapping the function to include self
+            def make_bound_method(func, instance):
+                def bound(*args, **kwargs):
+                    return func(instance, *args, **kwargs)
+
+                # Preserve function metadata for debugging
+                bound.__name__ = getattr(func, "__name__", tool_name)
+                bound.__doc__ = getattr(func, "__doc__", None)
+                return bound
+
+            bound_method = make_bound_method(original_func, self)
+        else:
+            # Function doesn't expect self (e.g., static method or already bound)
+            bound_method = original_func
+
+        # decorator settings take precedence, then toolkit settings
+        stop_after = function.stop_after_tool_call or tool_name in self.stop_after_tool_call_tools
+        show_result = function.show_result or tool_name in self.show_result_tools or stop_after
+        requires_confirmation = function.requires_confirmation or tool_name in self.requires_confirmation_tools
+        external_execution = function.external_execution or tool_name in self.external_execution_required_tools
+
+        # Create new Function with bound method, preserving decorator settings
+        f = Function(
+            name=tool_name,
+            description=function.description,
+            parameters=function.parameters,
+            strict=function.strict,
+            instructions=function.instructions,
+            add_instructions=function.add_instructions,
+            entrypoint=bound_method,
+            skip_entrypoint_processing=True,  # Parameters already processed by decorator
+            show_result=show_result,
+            stop_after_tool_call=stop_after,
+            pre_hook=function.pre_hook,
+            post_hook=function.post_hook,
+            tool_hooks=function.tool_hooks,
+            requires_confirmation=requires_confirmation,
+            requires_user_input=function.requires_user_input,
+            user_input_fields=function.user_input_fields,
+            user_input_schema=function.user_input_schema,
+            external_execution=external_execution,
+            cache_results=function.cache_results if function.cache_results else self.cache_results,
+            cache_dir=function.cache_dir if function.cache_dir else self.cache_dir,
+            cache_ttl=function.cache_ttl if function.cache_ttl != 3600 else self.cache_ttl,
+        )
+        self.functions[f.name] = f
+        log_debug(f"Function: {f.name} registered with {self.name} (from @tool decorator)")
+
     @property
     def requires_connect(self) -> bool:
         """Whether the toolkit requires connection management."""

agno/utils/events.py

@@ -16,6 +16,7 @@ from agno.run.agent import (
     PreHookCompletedEvent,
     PreHookStartedEvent,
     ReasoningCompletedEvent,
+    ReasoningContentDeltaEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
     RunCancelledEvent,
@@ -33,6 +34,7 @@ from agno.run.agent import (
     SessionSummaryCompletedEvent,
     SessionSummaryStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ToolCallStartedEvent,
 )
 from agno.run.requirement import RunRequirement
@@ -47,6 +49,7 @@ from agno.run.team import PostHookStartedEvent as TeamPostHookStartedEvent
 from agno.run.team import PreHookCompletedEvent as TeamPreHookCompletedEvent
 from agno.run.team import PreHookStartedEvent as TeamPreHookStartedEvent
 from agno.run.team import ReasoningCompletedEvent as TeamReasoningCompletedEvent
+from agno.run.team import ReasoningContentDeltaEvent as TeamReasoningContentDeltaEvent
 from agno.run.team import ReasoningStartedEvent as TeamReasoningStartedEvent
 from agno.run.team import ReasoningStepEvent as TeamReasoningStepEvent
 from agno.run.team import RunCancelledEvent as TeamRunCancelledEvent
@@ -59,6 +62,7 @@ from agno.run.team import SessionSummaryCompletedEvent as TeamSessionSummaryComp
 from agno.run.team import SessionSummaryStartedEvent as TeamSessionSummaryStartedEvent
 from agno.run.team import TeamRunEvent, TeamRunInput, TeamRunOutput, TeamRunOutputEvent
 from agno.run.team import ToolCallCompletedEvent as TeamToolCallCompletedEvent
+from agno.run.team import ToolCallErrorEvent as TeamToolCallErrorEvent
 from agno.run.team import ToolCallStartedEvent as TeamToolCallStartedEvent
 from agno.session.summary import SessionSummary
 
@@ -161,23 +165,41 @@ def create_run_continued_event(from_run_response: RunOutput) -> RunContinuedEven
     )
 
 
-def create_team_run_error_event(from_run_response: TeamRunOutput, error: str) -> TeamRunErrorEvent:
+def create_team_run_error_event(
+    from_run_response: TeamRunOutput,
+    error: str,
+    error_type: Optional[str] = None,
+    error_id: Optional[str] = None,
+    additional_data: Optional[Dict[str, Any]] = None,
+) -> TeamRunErrorEvent:
     return TeamRunErrorEvent(
         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,
         content=error,
+        error_type=error_type,
+        error_id=error_id,
+        additional_data=additional_data,
     )
 
 
-def create_run_error_event(from_run_response: RunOutput, error: str) -> RunErrorEvent:
+def create_run_error_event(
+    from_run_response: RunOutput,
+    error: str,
+    error_type: Optional[str] = None,
+    error_id: Optional[str] = None,
+    additional_data: Optional[Dict[str, Any]] = None,
+) -> RunErrorEvent:
     return RunErrorEvent(
         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,
         content=error,
+        error_type=error_type,
+        error_id=error_id,
+        additional_data=additional_data,
     )
 
 
@@ -421,6 +443,19 @@ def create_reasoning_step_event(
     )
 
 
+def create_reasoning_content_delta_event(
+    from_run_response: RunOutput, reasoning_content: str
+) -> ReasoningContentDeltaEvent:
+    """Create an event for streaming reasoning content chunks."""
+    return ReasoningContentDeltaEvent(
+        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,
+        reasoning_content=reasoning_content,
+    )
+
+
 def create_team_reasoning_step_event(
     from_run_response: TeamRunOutput, reasoning_step: ReasoningStep, reasoning_content: str
 ) -> TeamReasoningStepEvent:
@@ -435,6 +470,19 @@ def create_team_reasoning_step_event(
     )
 
 
+def create_team_reasoning_content_delta_event(
+    from_run_response: TeamRunOutput, reasoning_content: str
+) -> TeamReasoningContentDeltaEvent:
+    """Create an event for streaming reasoning content chunks for Team."""
+    return TeamReasoningContentDeltaEvent(
+        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,
+        reasoning_content=reasoning_content,
+    )
+
+
 def create_reasoning_completed_event(
     from_run_response: RunOutput, content: Optional[Any] = None, content_type: Optional[str] = None
 ) -> ReasoningCompletedEvent:
@@ -515,6 +563,32 @@ def create_team_tool_call_completed_event(
     )
 
 
+def create_tool_call_error_event(
+    from_run_response: RunOutput, tool: ToolExecution, error: Optional[str] = None
+) -> ToolCallErrorEvent:
+    return ToolCallErrorEvent(
+        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=tool,
+        error=error,
+    )
+
+
+def create_team_tool_call_error_event(
+    from_run_response: TeamRunOutput, tool: ToolExecution, error: Optional[str] = None
+) -> TeamToolCallErrorEvent:
+    return TeamToolCallErrorEvent(
+        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=tool,
+        error=error,
+    )
+
+
 def create_run_output_content_event(
     from_run_response: RunOutput,
     content: Optional[Any] = None,
@@ -692,9 +766,30 @@ def handle_event(
     store_events: bool = False,
 ) -> Union[RunOutputEvent, TeamRunOutputEvent]:
     # We only store events that are not run_response_content events
-    events_to_skip = [event.value for event in events_to_skip] if events_to_skip else []
-    if store_events and event.event not in events_to_skip:
+    _events_to_skip: List[str] = [event.value for event in events_to_skip] if events_to_skip else []
+    if store_events and event.event not in _events_to_skip:
         if run_response.events is None:
             run_response.events = []
         run_response.events.append(event)  # type: ignore
     return event
+
+
+def add_error_event(
+    error: RunErrorEvent,
+    events: Optional[List[RunOutputEvent]],
+):
+    if events is None:
+        events = []
+    events.append(error)
+
+    return events
+
+
+def add_team_error_event(
+    error: TeamRunErrorEvent,
+    events: Optional[List[Union[RunOutputEvent, TeamRunOutputEvent]]],
+):
+    if events is None:
+        events = []
+    events.append(error)
+    return events

agno/utils/hooks.py

@@ -1,9 +1,7 @@
 from copy import deepcopy
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
-
-if TYPE_CHECKING:
-    from agno.eval.base import BaseEval
+from typing import Any, Callable, Dict, List, Optional, Union
 
+from agno.eval.base import BaseEval
 from agno.guardrails.base import BaseGuardrail
 from agno.hooks.decorator import HOOK_RUN_IN_BACKGROUND_ATTR
 from agno.utils.log import log_warning
@@ -57,7 +55,7 @@ def should_run_hook_in_background(hook: Callable[..., Any]) -> bool:
 
 
 def normalize_pre_hooks(
-    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, "BaseEval"]]],
+    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, BaseEval]]],
     async_mode: bool = False,
 ) -> Optional[List[Callable[..., Any]]]:
     """Normalize pre-hooks to a list format.
@@ -66,8 +64,6 @@ def normalize_pre_hooks(
         hooks: List of hook functions, guardrails, or eval instances
         async_mode: Whether to use async versions of methods
     """
-    from agno.eval.base import BaseEval
-
     result_hooks: List[Callable[..., Any]] = []
 
     if hooks is not None:
@@ -102,7 +98,7 @@ def normalize_pre_hooks(
 
 
 def normalize_post_hooks(
-    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, "BaseEval"]]],
+    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, BaseEval]]],
     async_mode: bool = False,
 ) -> Optional[List[Callable[..., Any]]]:
     """Normalize post-hooks to a list format.
@@ -111,8 +107,6 @@ def normalize_post_hooks(
         hooks: List of hook functions, guardrails, or eval instances
         async_mode: Whether to use async versions of methods
     """
-    from agno.eval.base import BaseEval
-
     result_hooks: List[Callable[..., Any]] = []
 
     if hooks is not None:

agno/utils/print_response/agent.py

@@ -134,6 +134,11 @@ def print_response_stream(
                                 )
                             except Exception as e:
                                 log_warning(f"Failed to convert response to JSON: {e}")
+                        elif agent.output_schema is not None and isinstance(response_event.content, dict):
+                            try:
+                                response_content_batch = JSON(json.dumps(response_event.content), indent=2)  # type: ignore
+                            except Exception as e:
+                                log_warning(f"Failed to convert response to JSON: {e}")
                         else:
                             try:
                                 response_content_batch = JSON(json.dumps(response_event.content), indent=4)
@@ -141,6 +146,12 @@ def print_response_stream(
                                 log_warning(f"Failed to convert response to JSON: {e}")
                     if hasattr(response_event, "reasoning_content") and response_event.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += response_event.reasoning_content  # type: ignore
+
+                # Handle streaming reasoning content delta events
+                if response_event.event == RunEvent.reasoning_content_delta:  # type: ignore
+                    if hasattr(response_event, "reasoning_content") and response_event.reasoning_content is not None:  # type: ignore
+                        _response_reasoning_content += response_event.reasoning_content  # type: ignore
+
                 if hasattr(response_event, "reasoning_steps") and response_event.reasoning_steps is not None:  # type: ignore
                     reasoning_steps = response_event.reasoning_steps  # type: ignore
 
@@ -325,6 +336,11 @@ async def aprint_response_stream(
                             response_content_batch = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore
                         except Exception as e:
                             log_warning(f"Failed to convert response to JSON: {e}")
+                    elif agent.output_schema is not None and isinstance(resp.content, dict):
+                        try:
+                            response_content_batch = JSON(json.dumps(resp.content), indent=2)  # type: ignore
+                        except Exception as e:
+                            log_warning(f"Failed to convert response to JSON: {e}")
                     else:
                         try:
                             response_content_batch = JSON(json.dumps(resp.content), indent=4)
@@ -333,6 +349,11 @@ async def aprint_response_stream(
                     if resp.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += resp.reasoning_content  # type: ignore
 
+                # Handle streaming reasoning content delta events
+                if resp.event == RunEvent.reasoning_content_delta:  # type: ignore
+                    if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:  # type: ignore
+                        _response_reasoning_content += resp.reasoning_content  # type: ignore
+
                 if hasattr(resp, "reasoning_steps") and resp.reasoning_steps is not None:  # type: ignore
                     reasoning_steps = resp.reasoning_steps  # type: ignore
 
@@ -883,6 +904,11 @@ def build_panels(
                 response_content_batch = JSON(run_response.content.model_dump_json(exclude_none=True), indent=2)
             except Exception as e:
                 log_warning(f"Failed to convert response to JSON: {e}")
+        elif output_schema is not None and isinstance(run_response.content, dict):
+            try:
+                response_content_batch = JSON(json.dumps(run_response.content), indent=2)
+            except Exception as e:
+                log_warning(f"Failed to convert response to JSON: {e}")
         else:
             try:
                 response_content_batch = JSON(json.dumps(run_response.content), indent=4)

agno/utils/print_response/team.py

@@ -1,3 +1,4 @@
+import json
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Set, Union, get_args
 
 from pydantic import BaseModel
@@ -488,6 +489,11 @@ def print_response_stream(
                             _response_content = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore
                         except Exception as e:
                             log_warning(f"Failed to convert response to JSON: {e}")
+                    elif team.output_schema is not None and isinstance(resp.content, dict):
+                        try:
+                            _response_content = JSON(json.dumps(resp.content), indent=2)  # type: ignore
+                        except Exception as e:
+                            log_warning(f"Failed to convert response to JSON: {e}")
                     if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += resp.reasoning_content  # type: ignore
                 if hasattr(resp, "reasoning_steps") and resp.reasoning_steps is not None:  # type: ignore
@@ -1412,6 +1418,11 @@ async def aprint_response_stream(
                             _response_content = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore
                         except Exception as e:
                             log_warning(f"Failed to convert response to JSON: {e}")
+                    elif team.output_schema is not None and isinstance(resp.content, dict):
+                        try:
+                            _response_content = JSON(json.dumps(resp.content), indent=2)  # type: ignore
+                        except Exception as e:
+                            log_warning(f"Failed to convert response to JSON: {e}")
                     if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += resp.reasoning_content  # type: ignore
                 if hasattr(resp, "reasoning_steps") and resp.reasoning_steps is not None:  # type: ignore

agno/utils/prompts.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel
 from agno.utils.log import log_warning
 
 
-def get_json_output_prompt(output_schema: Union[str, list, BaseModel]) -> str:
+def get_json_output_prompt(output_schema: Union[str, list, dict, BaseModel]) -> str:
     """Return the JSON output prompt for the Agent.
 
     This is added to the system prompt when the output_schema is set and structured_outputs is False.
@@ -22,11 +22,13 @@ def get_json_output_prompt(output_schema: Union[str, list, BaseModel]) -> str:
             json_output_prompt += "\n<json_fields>"
             json_output_prompt += f"\n{json.dumps(output_schema)}"
             json_output_prompt += "\n</json_fields>"
-        elif (
-            issubclass(type(output_schema), BaseModel)
-            or issubclass(output_schema, BaseModel)  # type: ignore
-            or isinstance(output_schema, BaseModel)
-        ):  # type: ignore
+        elif isinstance(output_schema, dict):
+            json_output_prompt += "\n<json_fields>"
+            json_output_prompt += f"\n{json.dumps(output_schema)}"
+            json_output_prompt += "\n</json_fields>"
+        elif (isinstance(output_schema, type) and issubclass(output_schema, BaseModel)) or isinstance(
+            output_schema, BaseModel
+        ):
             json_schema = output_schema.model_json_schema()
             if json_schema is not None:
                 response_model_properties = {}

agno/utils/string.py

@@ -201,6 +201,52 @@ def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Op
     return structured_output
 
 
+def parse_response_dict_str(content: str) -> Optional[dict]:
+    """Parse dict from string content, extracting JSON if needed"""
+    from agno.utils.reasoning import extract_thinking_content
+
+    # Handle thinking content b/w <think> tags
+    if "</think>" in content:
+        reasoning_content, output_content = extract_thinking_content(content)
+        if reasoning_content:
+            content = output_content
+
+    # Clean content first to simplify all parsing attempts
+    cleaned_content = _clean_json_content(content)
+
+    try:
+        # First attempt: direct JSON parsing on cleaned content
+        return json.loads(cleaned_content)
+    except json.JSONDecodeError as e:
+        logger.warning(f"Failed to parse cleaned JSON: {e}")
+
+        # Second attempt: Extract individual JSON objects
+        candidate_jsons = _extract_json_objects(cleaned_content)
+
+        if len(candidate_jsons) == 1:
+            # Single JSON object - try to parse it directly
+            try:
+                return json.loads(candidate_jsons[0])
+            except json.JSONDecodeError:
+                pass
+
+        if len(candidate_jsons) > 1:
+            # Final attempt: Merge multiple JSON objects
+            merged_data: dict = {}
+            for candidate in candidate_jsons:
+                try:
+                    obj = json.loads(candidate)
+                    if isinstance(obj, dict):
+                        merged_data.update(obj)
+                except json.JSONDecodeError:
+                    continue
+            if merged_data:
+                return merged_data
+
+        logger.warning("All parsing attempts failed.")
+        return None
+
+
 def generate_id(seed: Optional[str] = None) -> str:
     """
     Generate a deterministic UUID5 based on a seed string.

agno/utils/team.py

@@ -59,7 +59,7 @@ def add_interaction_to_team_run_context(
     team_run_context: Dict[str, Any],
     member_name: str,
     task: str,
-    run_response: Union[RunOutput, TeamRunOutput],
+    run_response: Optional[Union[RunOutput, TeamRunOutput]],
 ) -> None:
     if "member_responses" not in team_run_context:
         team_run_context["member_responses"] = []