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

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)

agno/reasoning/azure_ai_foundry.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
@@ -65,3 +65,95 @@ async def aget_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Mes
     return Message(
         role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
     )
+
+
+def get_ai_foundry_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Azure AI Foundry model.
+
+    For DeepSeek-R1 models, we use the main content output as reasoning content.
+
+    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 = ""
+
+    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:
+                    # Check for reasoning_content attribute first (native reasoning)
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        reasoning_content += event.reasoning_content
+                        yield (event.reasoning_content, None)
+                    # Use the main content as reasoning content
+                    elif hasattr(event, "content") and event.content:
+                        reasoning_content += event.content
+                        yield (event.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,
+        )
+        yield (None, final_message)
+
+
+async def aget_ai_foundry_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Azure AI Foundry model asynchronously.
+
+    For DeepSeek-R1 models, we use the main content output as reasoning content.
+
+    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 = ""
+
+    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:
+                    # Check for reasoning_content attribute first (native reasoning)
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        reasoning_content += event.reasoning_content
+                        yield (event.reasoning_content, None)
+                    # Use the main content as reasoning content
+                    elif hasattr(event, "content") and event.content:
+                        reasoning_content += event.content
+                        yield (event.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,
+        )
+        yield (None, final_message)

agno/reasoning/deepseek.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
@@ -37,6 +37,51 @@ def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) ->
     )
 
 
+def get_deepseek_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from DeepSeek 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
+
+    # Update system message role to "system"
+    for message in messages:
+        if message.role == "developer":
+            message.role = "system"
+
+    reasoning_content: str = ""
+
+    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,
+        )
+        yield (None, final_message)
+
+
 async def aget_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
     from agno.run.agent import RunOutput
 
@@ -61,3 +106,48 @@ async def aget_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Messa
     return Message(
         role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
     )
+
+
+async def aget_deepseek_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from DeepSeek 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
+
+    # Update system message role to "system"
+    for message in messages:
+        if message.role == "developer":
+            message.role = "system"
+
+    reasoning_content: str = ""
+
+    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,
+        )
+        yield (None, final_message)

agno/reasoning/gemini.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
@@ -71,3 +71,83 @@ async def aget_gemini_reasoning(reasoning_agent: "Agent", messages: List[Message
     return Message(
         role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
     )
+
+
+def get_gemini_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Gemini 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 = ""
+
+    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,
+        )
+        yield (None, final_message)
+
+
+async def aget_gemini_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Gemini 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 = ""
+
+    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,
+        )
+        yield (None, final_message)

agno/reasoning/groq.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
@@ -69,3 +69,105 @@ async def aget_groq_reasoning(reasoning_agent: "Agent", messages: List[Message])
     return Message(
         role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
     )
+
+
+def get_groq_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Groq model.
+
+    For DeepSeek models on Groq, we use the main content output as reasoning content.
+
+    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
+
+    # Update system message role to "system"
+    for message in messages:
+        if message.role == "developer":
+            message.role = "system"
+
+    reasoning_content: str = ""
+
+    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:
+                    # Check for reasoning_content attribute first (native reasoning)
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        reasoning_content += event.reasoning_content
+                        yield (event.reasoning_content, None)
+                    # Use the main content as reasoning content
+                    elif hasattr(event, "content") and event.content:
+                        reasoning_content += event.content
+                        yield (event.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,
+        )
+        yield (None, final_message)
+
+
+async def aget_groq_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Groq model asynchronously.
+
+    For DeepSeek models on Groq, we use the main content output as reasoning content.
+
+    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
+
+    # Update system message role to "system"
+    for message in messages:
+        if message.role == "developer":
+            message.role = "system"
+
+    reasoning_content: str = ""
+
+    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:
+                    # Check for reasoning_content attribute first (native reasoning)
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        reasoning_content += event.reasoning_content
+                        yield (event.reasoning_content, None)
+                    # Use the main content as reasoning content
+                    elif hasattr(event, "content") and event.content:
+                        reasoning_content += event.content
+                        yield (event.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,
+        )
+        yield (None, final_message)