agno 2.3.12__py3-none-any.whl → 2.3.14__py3-none-any.whl

agno/tools/postgres.py

@@ -110,7 +110,7 @@ class PostgresTools(Toolkit):
         """
         if not self.is_connected:
             return self.connect()
-        return self._connection
+        return self._connection  # type: ignore
 
     def __enter__(self):
         return self.connect()

agno/utils/cryptography.py

@@ -0,0 +1,22 @@
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+def generate_rsa_keys():
+    """Generate RSA key pair for RS256 JWT signing/verification."""
+    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+
+    # Private key PEM (used by auth server to sign tokens)
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    # Public key PEM (used by AgentOS to verify tokens)
+    public_pem = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    return private_pem.decode("utf-8"), public_pem.decode("utf-8")

agno/utils/events.py

@@ -16,6 +16,7 @@ from agno.run.agent import (
     PreHookCompletedEvent,
     PreHookStartedEvent,
     ReasoningCompletedEvent,
+    ReasoningContentDeltaEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
     RunCancelledEvent,
@@ -47,6 +48,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
@@ -161,23 +163,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 +441,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 +468,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:
@@ -698,3 +744,24 @@ def handle_event(
             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
 
@@ -494,11 +515,23 @@ def build_panels_stream(
         and response_event.citations is not None
         and response_event.citations.urls is not None
     ):
-        md_content = "\n".join(
+        md_lines = []
+
+        # Add search queries if present
+        if response_event.citations.search_queries:
+            md_lines.append("**Search Queries:**")
+            for query in response_event.citations.search_queries:
+                md_lines.append(f"- {query}")
+            md_lines.append("")  # Empty line before URLs
+
+        # Add URL citations
+        md_lines.extend(
             f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
             for i, citation in enumerate(response_event.citations.urls)
             if citation.url  # Only include citations with valid URLs
         )
+
+        md_content = "\n".join(md_lines)
         if md_content:  # Only create panel if there are citations
             citations_panel = create_panel(
                 content=Markdown(md_content),
@@ -871,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)
@@ -890,11 +928,23 @@ def build_panels(
         and run_response.citations is not None
         and run_response.citations.urls is not None
     ):
-        md_content = "\n".join(
+        md_lines = []
+
+        # Add search queries if present
+        if run_response.citations.search_queries:
+            md_lines.append("**Search Queries:**")
+            for query in run_response.citations.search_queries:
+                md_lines.append(f"- {query}")
+            md_lines.append("")  # Empty line before URLs
+
+        # Add URL citations
+        md_lines.extend(
             f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
             for i, citation in enumerate(run_response.citations.urls)
             if citation.url  # Only include citations with valid URLs
         )
+
+        md_content = "\n".join(md_lines)
         if md_content:  # Only create panel if there are citations
             citations_panel = create_panel(
                 content=Markdown(md_content),

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
@@ -229,11 +230,23 @@ def print_response(
                     panels.append(member_response_panel)
 
                     if member_response.citations is not None and member_response.citations.urls is not None:
-                        md_content = "\n".join(
+                        md_lines = []
+
+                        # Add search queries if present
+                        if member_response.citations.search_queries:
+                            md_lines.append("**Search Queries:**")
+                            for query in member_response.citations.search_queries:
+                                md_lines.append(f"- {query}")
+                            md_lines.append("")  # Empty line before URLs
+
+                        # Add URL citations
+                        md_lines.extend(
                             f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                             for i, citation in enumerate(member_response.citations.urls)
                             if citation.url  # Only include citations with valid URLs
                         )
+
+                        md_content = "\n".join(md_lines)
                         if md_content:  # Only create panel if there are citations
                             citations_panel = create_panel(
                                 content=Markdown(md_content),
@@ -293,11 +306,23 @@ def print_response(
 
             # Add citations
             if run_response.citations is not None and run_response.citations.urls is not None:
-                md_content = "\n".join(
+                md_lines = []
+
+                # Add search queries if present
+                if run_response.citations.search_queries:
+                    md_lines.append("**Search Queries:**")
+                    for query in run_response.citations.search_queries:
+                        md_lines.append(f"- {query}")
+                    md_lines.append("")  # Empty line before URLs
+
+                # Add URL citations
+                md_lines.extend(
                     f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                     for i, citation in enumerate(run_response.citations.urls)
                     if citation.url  # Only include citations with valid URLs
                 )
+
+                md_content = "\n".join(md_lines)
                 if md_content:  # Only create panel if there are citations
                     citations_panel = create_panel(
                         content=Markdown(md_content),
@@ -464,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
@@ -660,11 +690,23 @@ def print_response_stream(
 
         # Add citations
         if hasattr(resp, "citations") and resp.citations is not None and resp.citations.urls is not None:
-            md_content = "\n".join(
+            md_lines = []
+
+            # Add search queries if present
+            if resp.citations.search_queries:
+                md_lines.append("**Search Queries:**")
+                for query in resp.citations.search_queries:
+                    md_lines.append(f"- {query}")
+                md_lines.append("")  # Empty line before URLs
+
+            # Add URL citations
+            md_lines.extend(
                 f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                 for i, citation in enumerate(resp.citations.urls)
                 if citation.url  # Only include citations with valid URLs
             )
+
+            md_content = "\n".join(md_lines)
             if md_content:  # Only create panel if there are citations
                 citations_panel = create_panel(
                     content=Markdown(md_content),
@@ -804,11 +846,23 @@ def print_response_stream(
 
                 # Add citations if any
                 if member_response.citations is not None and member_response.citations.urls is not None:
-                    md_content = "\n".join(
+                    md_lines = []
+
+                    # Add search queries if present
+                    if member_response.citations.search_queries:
+                        md_lines.append("**Search Queries:**")
+                        for query in member_response.citations.search_queries:
+                            md_lines.append(f"- {query}")
+                        md_lines.append("")  # Empty line before URLs
+
+                    # Add URL citations
+                    md_lines.extend(
                         f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                         for i, citation in enumerate(member_response.citations.urls)
                         if citation.url  # Only include citations with valid URLs
                     )
+
+                    md_content = "\n".join(md_lines)
                     if md_content:  # Only create panel if there are citations
                         citations_panel = create_panel(
                             content=Markdown(md_content),
@@ -868,11 +922,23 @@ def print_response_stream(
 
         # Add team citations
         if hasattr(resp, "citations") and resp.citations is not None and resp.citations.urls is not None:
-            md_content = "\n".join(
+            md_lines = []
+
+            # Add search queries if present
+            if resp.citations.search_queries:
+                md_lines.append("**Search Queries:**")
+                for query in resp.citations.search_queries:
+                    md_lines.append(f"- {query}")
+                md_lines.append("")  # Empty line before URLs
+
+            # Add URL citations
+            md_lines.extend(
                 f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                 for i, citation in enumerate(resp.citations.urls)
                 if citation.url  # Only include citations with valid URLs
             )
+
+            md_content = "\n".join(md_lines)
             if md_content:  # Only create panel if there are citations
                 citations_panel = create_panel(
                     content=Markdown(md_content),
@@ -1096,11 +1162,23 @@ async def aprint_response(
                     panels.append(member_response_panel)
 
                     if member_response.citations is not None and member_response.citations.urls is not None:
-                        md_content = "\n".join(
+                        md_lines = []
+
+                        # Add search queries if present
+                        if member_response.citations.search_queries:
+                            md_lines.append("**Search Queries:**")
+                            for query in member_response.citations.search_queries:
+                                md_lines.append(f"- {query}")
+                            md_lines.append("")  # Empty line before URLs
+
+                        # Add URL citations
+                        md_lines.extend(
                             f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                             for i, citation in enumerate(member_response.citations.urls)
                             if citation.url  # Only include citations with valid URLs
                         )
+
+                        md_content = "\n".join(md_lines)
                         if md_content:
                             citations_panel = create_panel(
                                 content=Markdown(md_content),
@@ -1158,11 +1236,23 @@ async def aprint_response(
 
             # Add citations
             if run_response.citations is not None and run_response.citations.urls is not None:
-                md_content = "\n".join(
+                md_lines = []
+
+                # Add search queries if present
+                if run_response.citations.search_queries:
+                    md_lines.append("**Search Queries:**")
+                    for query in run_response.citations.search_queries:
+                        md_lines.append(f"- {query}")
+                    md_lines.append("")  # Empty line before URLs
+
+                # Add URL citations
+                md_lines.extend(
                     f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                     for i, citation in enumerate(run_response.citations.urls)
                     if citation.url  # Only include citations with valid URLs
                 )
+
+                md_content = "\n".join(md_lines)
                 if md_content:  # Only create panel if there are citations
                     citations_panel = create_panel(
                         content=Markdown(md_content),
@@ -1328,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
@@ -1524,11 +1619,23 @@ async def aprint_response_stream(
 
         # Add citations
         if hasattr(resp, "citations") and resp.citations is not None and resp.citations.urls is not None:
-            md_content = "\n".join(
+            md_lines = []
+
+            # Add search queries if present
+            if resp.citations.search_queries:
+                md_lines.append("**Search Queries:**")
+                for query in resp.citations.search_queries:
+                    md_lines.append(f"- {query}")
+                md_lines.append("")  # Empty line before URLs
+
+            # Add URL citations
+            md_lines.extend(
                 f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                 for i, citation in enumerate(resp.citations.urls)
                 if citation.url  # Only include citations with valid URLs
             )
+
+            md_content = "\n".join(md_lines)
             if md_content:  # Only create panel if there are citations
                 citations_panel = create_panel(
                     content=Markdown(md_content),
@@ -1685,11 +1792,23 @@ async def aprint_response_stream(
 
                 # Add citations if any
                 if member_response.citations is not None and member_response.citations.urls is not None:
-                    md_content = "\n".join(
+                    md_lines = []
+
+                    # Add search queries if present
+                    if member_response.citations.search_queries:
+                        md_lines.append("**Search Queries:**")
+                        for query in member_response.citations.search_queries:
+                            md_lines.append(f"- {query}")
+                        md_lines.append("")  # Empty line before URLs
+
+                    # Add URL citations
+                    md_lines.extend(
                         f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                         for i, citation in enumerate(member_response.citations.urls)
                         if citation.url  # Only include citations with valid URLs
                     )
+
+                    md_content = "\n".join(md_lines)
                     if md_content:  # Only create panel if there are citations
                         citations_panel = create_panel(
                             content=Markdown(md_content),
@@ -1749,11 +1868,23 @@ async def aprint_response_stream(
 
         # Add team citations
         if hasattr(resp, "citations") and resp.citations is not None and resp.citations.urls is not None:
-            md_content = "\n".join(
+            md_lines = []
+
+            # Add search queries if present
+            if resp.citations.search_queries:
+                md_lines.append("**Search Queries:**")
+                for query in resp.citations.search_queries:
+                    md_lines.append(f"- {query}")
+                md_lines.append("")  # Empty line before URLs
+
+            # Add URL citations
+            md_lines.extend(
                 f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
                 for i, citation in enumerate(resp.citations.urls)
                 if citation.url  # Only include citations with valid URLs
             )
+
+            md_content = "\n".join(md_lines)
             if md_content:  # Only create panel if there are citations
                 citations_panel = create_panel(
                     content=Markdown(md_content),

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.