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

agno/os/interfaces/a2a/utils.py

@@ -95,7 +95,6 @@ async def map_a2a_request_to_run_input(request_body: dict, stream: bool = True)
         ```json
         {
             "jsonrpc": "2.0",
-            "method": "message/send",
             "id": "id",
             "params": {
                 "message": {
@@ -325,7 +324,7 @@ async def stream_a2a_response(
                 final=False,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # 2. Send all content and secondary events
 
@@ -341,7 +340,7 @@ async def stream_a2a_response(
                 metadata={"agno_content_category": "content"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=message)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: Message\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send tool call events
         elif isinstance(event, (ToolCallStartedEvent, TeamToolCallStartedEvent)):
@@ -361,7 +360,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (ToolCallCompletedEvent, TeamToolCallCompletedEvent)):
             metadata = {"agno_event_type": "tool_call_completed"}
@@ -380,7 +379,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send reasoning events
         elif isinstance(event, (ReasoningStartedEvent, TeamReasoningStartedEvent)):
@@ -392,7 +391,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "reasoning_started"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (ReasoningStepEvent, TeamReasoningStepEvent)):
             if event.reasoning_content:
@@ -415,7 +414,7 @@ async def stream_a2a_response(
                     metadata={"agno_content_category": "reasoning", "agno_event_type": "reasoning_step"},
                 )
                 response = SendStreamingMessageSuccessResponse(id=request_id, result=reasoning_message)
-                yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+                yield f"event: Message\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (ReasoningCompletedEvent, TeamReasoningCompletedEvent)):
             status_event = TaskStatusUpdateEvent(
@@ -426,7 +425,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "reasoning_completed"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send memory update events
         elif isinstance(event, (MemoryUpdateStartedEvent, TeamMemoryUpdateStartedEvent)):
@@ -438,7 +437,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "memory_update_started"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (MemoryUpdateCompletedEvent, TeamMemoryUpdateCompletedEvent)):
             status_event = TaskStatusUpdateEvent(
@@ -449,7 +448,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "memory_update_completed"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send workflow events
         elif isinstance(event, WorkflowStepStartedEvent):
@@ -465,7 +464,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, WorkflowStepCompletedEvent):
             metadata = {"agno_event_type": "workflow_step_completed"}
@@ -480,7 +479,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, WorkflowStepErrorEvent):
             metadata = {"agno_event_type": "workflow_step_error"}
@@ -497,7 +496,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send loop events
         elif isinstance(event, LoopExecutionStartedEvent):
@@ -515,7 +514,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, LoopIterationStartedEvent):
             metadata = {"agno_event_type": "loop_iteration_started"}
@@ -534,7 +533,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, LoopIterationCompletedEvent):
             metadata = {"agno_event_type": "loop_iteration_completed"}
@@ -553,7 +552,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, LoopExecutionCompletedEvent):
             metadata = {"agno_event_type": "loop_execution_completed"}
@@ -570,7 +569,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send parallel events
         elif isinstance(event, ParallelExecutionStartedEvent):
@@ -588,7 +587,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, ParallelExecutionCompletedEvent):
             metadata = {"agno_event_type": "parallel_execution_completed"}
@@ -605,7 +604,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send condition events
         elif isinstance(event, ConditionExecutionStartedEvent):
@@ -623,7 +622,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, ConditionExecutionCompletedEvent):
             metadata = {"agno_event_type": "condition_execution_completed"}
@@ -642,7 +641,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send router events
         elif isinstance(event, RouterExecutionStartedEvent):
@@ -660,7 +659,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, RouterExecutionCompletedEvent):
             metadata = {"agno_event_type": "router_execution_completed"}
@@ -679,7 +678,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send steps events
         elif isinstance(event, StepsExecutionStartedEvent):
@@ -697,7 +696,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, StepsExecutionCompletedEvent):
             metadata = {"agno_event_type": "steps_execution_completed"}
@@ -716,7 +715,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Capture completion event for final task construction
         elif isinstance(event, (RunCompletedEvent, TeamRunCompletedEvent, WorkflowCompletedEvent)):
@@ -748,7 +747,7 @@ async def stream_a2a_response(
             final=True,
         )
     response = SendStreamingMessageSuccessResponse(id=request_id, result=final_status_event)
-    yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+    yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
     # 4. Send final task
     # Handle cancelled case
@@ -778,7 +777,7 @@ async def stream_a2a_response(
             history=[final_message],
         )
         response = SendStreamingMessageSuccessResponse(id=request_id, result=task)
-        yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+        yield f"event: Task\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
         return
 
     # Build from completion_event if available, otherwise use accumulated content
@@ -846,8 +845,8 @@ async def stream_a2a_response(
 
         # Handle all other data as Message metadata
         final_metadata: Dict[str, Any] = {}
-        if hasattr(completion_event, "metrics") and completion_event.metrics:
-            final_metadata["metrics"] = completion_event.metrics.__dict__
+        if hasattr(completion_event, "metrics") and completion_event.metrics:  # type: ignore
+            final_metadata["metrics"] = completion_event.metrics.to_dict()  # type: ignore
         if hasattr(completion_event, "metadata") and completion_event.metadata:
             final_metadata.update(completion_event.metadata)
 
@@ -880,7 +879,7 @@ async def stream_a2a_response(
         artifacts=artifacts if artifacts else None,
     )
     response = SendStreamingMessageSuccessResponse(id=request_id, result=task)
-    yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+    yield f"event: Task\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
 
 async def stream_a2a_response_with_error_handling(
@@ -904,7 +903,7 @@ async def stream_a2a_response_with_error_handling(
             final=True,
         )
         response = SendStreamingMessageSuccessResponse(id=request_id, result=failed_status_event)
-        yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+        yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send failed Task
         error_message = A2AMessage(
@@ -921,4 +920,4 @@ async def stream_a2a_response_with_error_handling(
         )
 
         response = SendStreamingMessageSuccessResponse(id=request_id, result=failed_task)
-        yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+        yield f"event: Task\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"

agno/os/middleware/jwt.py

@@ -389,8 +389,9 @@ class JWTMiddleware(BaseHTTPMiddleware):
                       or JWT_JWKS env var for inline JWKS JSON content.
             secret_key: (deprecated) Use verification_keys instead. If provided, will be added to verification_keys.
             algorithm: JWT algorithm (default: RS256). Common options: RS256 (asymmetric), HS256 (symmetric).
-            validate: Whether to validate the JWT token (default: True). If False, tokens are decoded
-                     without signature verification and no verification key is required.
+            validate: Whether to validate the JWT signature (default: True). If False, tokens are decoded
+                     without signature verification and no verification key is required. Useful when
+                     JWT verification is handled upstream (API Gateway, etc.).
             authorization: Whether to add authorization checks to the request (i.e. validation of scopes)
             token_source: Where to extract JWT token from (header, cookie, or both)
             token_header_key: Header key for Authorization (default: "Authorization")
@@ -642,9 +643,8 @@ class JWTMiddleware(BaseHTTPMiddleware):
         # Extract JWT token
         token = self._extract_token(request)
         if not token:
-            if self.validate:
-                error_msg = self._get_missing_token_error_message()
-                return self._create_error_response(401, error_msg, origin, cors_allowed_origins)
+            error_msg = self._get_missing_token_error_message()
+            return self._create_error_response(401, error_msg, origin, cors_allowed_origins)
 
         try:
             # Validate token and extract claims (with audience verification if configured)

agno/os/routers/agents/schema.py

@@ -215,11 +215,24 @@ class AgentResponse(BaseModel):
             "build_user_context": agent.build_user_context,
         }
 
+        # Handle output_schema name for both Pydantic models and JSON schemas
+        output_schema_name = None
+        if agent.output_schema is not None:
+            if isinstance(agent.output_schema, dict):
+                if "json_schema" in agent.output_schema:
+                    output_schema_name = agent.output_schema["json_schema"].get("name", "JSONSchema")
+                elif "schema" in agent.output_schema and isinstance(agent.output_schema["schema"], dict):
+                    output_schema_name = agent.output_schema["schema"].get("title", "JSONSchema")
+                else:
+                    output_schema_name = agent.output_schema.get("title", "JSONSchema")
+            elif hasattr(agent.output_schema, "__name__"):
+                output_schema_name = agent.output_schema.__name__
+
         response_settings_info: Dict[str, Any] = {
             "retries": agent.retries,
             "delay_between_retries": agent.delay_between_retries,
             "exponential_backoff": agent.exponential_backoff,
-            "output_schema_name": agent.output_schema.__name__ if agent.output_schema else None,
+            "output_schema_name": output_schema_name,
             "parser_model_prompt": agent.parser_model_prompt,
             "parse_response": agent.parse_response,
             "structured_outputs": agent.structured_outputs,

agno/os/routers/teams/schema.py

@@ -197,8 +197,21 @@ class TeamResponse(BaseModel):
             "resolve_in_context": team.resolve_in_context,
         }
 
+        # Handle output_schema name for both Pydantic models and JSON schemas
+        output_schema_name = None
+        if team.output_schema is not None:
+            if isinstance(team.output_schema, dict):
+                if "json_schema" in team.output_schema:
+                    output_schema_name = team.output_schema["json_schema"].get("name", "JSONSchema")
+                elif "schema" in team.output_schema and isinstance(team.output_schema["schema"], dict):
+                    output_schema_name = team.output_schema["schema"].get("title", "JSONSchema")
+                else:
+                    output_schema_name = team.output_schema.get("title", "JSONSchema")
+            elif hasattr(team.output_schema, "__name__"):
+                output_schema_name = team.output_schema.__name__
+
         response_settings_info: Dict[str, Any] = {
-            "output_schema_name": team.output_schema.__name__ if team.output_schema else None,
+            "output_schema_name": output_schema_name,
             "parser_model_prompt": team.parser_model_prompt,
             "parse_response": team.parse_response,
             "use_json_mode": team.use_json_mode,

agno/os/utils.py

@@ -26,12 +26,21 @@ from agno.workflow.workflow import Workflow
 
 async def get_request_kwargs(request: Request, endpoint_func: Callable) -> Dict[str, Any]:
     """Given a Request and an endpoint function, return a dictionary with all extra form data fields.
+
     Args:
         request: The FastAPI Request object
         endpoint_func: The function exposing the endpoint that received the request
 
+    Supported form parameters:
+        - session_state: JSON string of session state dict
+        - dependencies: JSON string of dependencies dict
+        - metadata: JSON string of metadata dict
+        - knowledge_filters: JSON string of knowledge filters
+        - output_schema: JSON schema string (converted to Pydantic model by default)
+        - use_json_schema: If "true", keeps output_schema as dict instead of converting to Pydantic model
+
     Returns:
-        A dictionary of kwargs
+        A dictionary of kwargs to pass to Agent/Team run methods
     """
     import inspect
 
@@ -101,15 +110,25 @@ async def get_request_kwargs(request: Request, endpoint_func: Callable) -> Dict[
             kwargs.pop("knowledge_filters")
             log_warning(f"Invalid FilterExpr in knowledge_filters: {e}")
 
-    # Handle output_schema - convert JSON schema to dynamic Pydantic model
+    # Handle output_schema - convert JSON schema to Pydantic model or keep as dict
+    # use_json_schema is a control flag consumed here (not passed to Agent/Team)
+    # When true, output_schema stays as dict for direct JSON output
+    use_json_schema = kwargs.pop("use_json_schema", False)
+    if isinstance(use_json_schema, str):
+        use_json_schema = use_json_schema.lower() == "true"
+
     if output_schema := kwargs.get("output_schema"):
         try:
             if isinstance(output_schema, str):
-                from agno.os.utils import json_schema_to_pydantic_model
-
                 schema_dict = json.loads(output_schema)
-                dynamic_model = json_schema_to_pydantic_model(schema_dict)
-                kwargs["output_schema"] = dynamic_model
+
+                if use_json_schema:
+                    # Keep as dict schema for direct JSON output
+                    kwargs["output_schema"] = schema_dict
+                else:
+                    # Convert to Pydantic model (default behavior)
+                    dynamic_model = json_schema_to_pydantic_model(schema_dict)
+                    kwargs["output_schema"] = dynamic_model
         except json.JSONDecodeError:
             kwargs.pop("output_schema")
             log_warning(f"Invalid output_schema JSON: {output_schema}")
@@ -281,56 +300,45 @@ def get_session_name(session: Dict[str, Any]) -> str:
     if session_data is not None and session_data.get("session_name") is not None:
         return session_data["session_name"]
 
-    # Otherwise use the original user message
-    else:
-        runs = session.get("runs", []) or []
-
-        # For teams, identify the first Team run and avoid using the first member's run
-        if session.get("session_type") == "team":
-            run = None
-            for r in runs:
-                # If agent_id is not present, it's a team run
-                if not r.get("agent_id"):
-                    run = r
-                    break
-
-            # Fallback to first run if no team run found
-            if run is None and runs:
-                run = runs[0]
-
-        elif session.get("session_type") == "workflow":
-            try:
-                workflow_run = runs[0]
-                workflow_input = workflow_run.get("input")
-                if isinstance(workflow_input, str):
-                    return workflow_input
-                elif isinstance(workflow_input, dict):
-                    try:
-                        import json
-
-                        return json.dumps(workflow_input)
-                    except (TypeError, ValueError):
-                        pass
-
-                workflow_name = session.get("workflow_data", {}).get("name")
-                return f"New {workflow_name} Session" if workflow_name else ""
-            except (KeyError, IndexError, TypeError):
-                return ""
-
-        # For agents, use the first run
-        else:
-            run = runs[0] if runs else None
+    runs = session.get("runs", []) or []
+    session_type = session.get("session_type")
 
-        if run is None:
+    # Handle workflows separately
+    if session_type == "workflow":
+        if not runs:
             return ""
+        workflow_run = runs[0]
+        workflow_input = workflow_run.get("input")
+        if isinstance(workflow_input, str):
+            return workflow_input
+        elif isinstance(workflow_input, dict):
+            try:
+                return json.dumps(workflow_input)
+            except (TypeError, ValueError):
+                pass
+        workflow_name = session.get("workflow_data", {}).get("name")
+        return f"New {workflow_name} Session" if workflow_name else ""
+
+    # For team, filter to team runs (runs without agent_id); for agents, use all runs
+    if session_type == "team":
+        runs_to_check = [r for r in runs if not r.get("agent_id")]
+    else:
+        runs_to_check = runs
 
-        if not isinstance(run, dict):
-            run = run.to_dict()
+    # Find the first user message across runs
+    for r in runs_to_check:
+        if r is None:
+            continue
+        run_dict = r if isinstance(r, dict) else r.to_dict()
+
+        for message in run_dict.get("messages") or []:
+            if message.get("role") == "user" and message.get("content"):
+                return message["content"]
+
+        run_input = r.get("input")
+        if run_input is not None:
+            return run_input.get("input_content")
 
-        if run and run.get("messages"):
-            for message in run["messages"]:
-                if message["role"] == "user":
-                    return message["content"]
     return ""
 
 
@@ -862,7 +870,7 @@ def _get_python_type_from_json_schema(field_schema: Dict[str, Any], field_name:
         # Unknown or unspecified type - fallback to Any
         if json_type:
             logger.warning(f"Unknown JSON schema type '{json_type}' for field '{field_name}', using Any")
-        return Any
+        return Any  # type: ignore
 
 
 def json_schema_to_pydantic_model(schema: Dict[str, Any]) -> Type[BaseModel]:

agno/reasoning/anthropic.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import AsyncIterator, Iterator, List, Optional, Tuple
 
 from agno.models.base import Model
 from agno.models.message import Message
@@ -51,6 +51,48 @@ def get_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Message]) -
     )
 
 
+def get_anthropic_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Anthropic Claude model.
+
+    Yields:
+        Tuple of (reasoning_content_delta, final_message)
+        - During streaming: (reasoning_content_delta, None)
+        - At the end: (None, final_message)
+    """
+    from agno.run.agent import RunEvent
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    try:
+        for event in reasoning_agent.run(input=messages, stream=True, stream_intermediate_steps=True):
+            if hasattr(event, "event"):
+                if event.event == RunEvent.run_content:
+                    # Stream reasoning content as it arrives
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        reasoning_content += event.reasoning_content
+                        yield (event.reasoning_content, None)
+                elif event.event == RunEvent.run_completed:
+                    pass
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return
+
+    # Yield final message
+    if reasoning_content:
+        final_message = Message(
+            role="assistant",
+            content=f"<thinking>\n{reasoning_content}\n</thinking>",
+            reasoning_content=reasoning_content,
+            redacted_reasoning_content=redacted_reasoning_content,
+        )
+        yield (None, final_message)
+
+
 async def aget_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
     """Get reasoning from an Anthropic Claude model asynchronously."""
     from agno.run.agent import RunOutput
@@ -78,3 +120,45 @@ async def aget_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Mess
         reasoning_content=reasoning_content,
         redacted_reasoning_content=redacted_reasoning_content,
     )
+
+
+async def aget_anthropic_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Anthropic Claude model asynchronously.
+
+    Yields:
+        Tuple of (reasoning_content_delta, final_message)
+        - During streaming: (reasoning_content_delta, None)
+        - At the end: (None, final_message)
+    """
+    from agno.run.agent import RunEvent
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    try:
+        async for event in reasoning_agent.arun(input=messages, stream=True, stream_intermediate_steps=True):
+            if hasattr(event, "event"):
+                if event.event == RunEvent.run_content:
+                    # Stream reasoning content as it arrives
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        reasoning_content += event.reasoning_content
+                        yield (event.reasoning_content, None)
+                elif event.event == RunEvent.run_completed:
+                    pass
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return
+
+    # Yield final message
+    if reasoning_content:
+        final_message = Message(
+            role="assistant",
+            content=f"<thinking>\n{reasoning_content}\n</thinking>",
+            reasoning_content=reasoning_content,
+            redacted_reasoning_content=redacted_reasoning_content,
+        )
+        yield (None, final_message)