agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

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_events=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_events=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_events=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_events=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
@@ -8,7 +8,17 @@ from agno.utils.log import logger
 
 
 def is_deepseek_reasoning_model(reasoning_model: Model) -> bool:
-    return reasoning_model.__class__.__name__ == "DeepSeek" and reasoning_model.id.lower() == "deepseek-reasoner"
+    """Check if the model is a DeepSeek reasoning model.
+
+    Matches:
+    - deepseek-reasoner
+    - deepseek-r1 and variants (deepseek-r1-distill-*, etc.)
+    """
+    if reasoning_model.__class__.__name__ != "DeepSeek":
+        return False
+
+    model_id = reasoning_model.id.lower()
+    return "reasoner" in model_id or "r1" in model_id
 
 
 def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
@@ -37,6 +47,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_events=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 +116,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_events=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/default.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 from textwrap import dedent
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from typing import Callable, Dict, List, Literal, Optional, Union
 
 from agno.models.base import Model
 from agno.reasoning.step import ReasoningSteps
+from agno.run.base import RunContext
 from agno.tools import Toolkit
 from agno.tools.function import Function
 
@@ -19,9 +20,7 @@ def get_default_reasoning_agent(
     telemetry: bool = True,
     debug_mode: bool = False,
     debug_level: Literal[1, 2] = 1,
-    session_state: Optional[Dict[str, Any]] = None,
-    dependencies: Optional[Dict[str, Any]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    run_context: Optional[RunContext] = None,
 ) -> Optional["Agent"]:  # type: ignore  # noqa: F821
     from agno.agent import Agent
 
@@ -89,9 +88,9 @@ def get_default_reasoning_agent(
         telemetry=telemetry,
         debug_mode=debug_mode,
         debug_level=debug_level,
-        session_state=session_state,
-        dependencies=dependencies,
-        metadata=metadata,
+        session_state=run_context.session_state if run_context else None,
+        dependencies=run_context.dependencies if run_context else None,
+        metadata=run_context.metadata if run_context else None,
     )
 
     return agent

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
@@ -13,9 +13,13 @@ def is_gemini_reasoning_model(reasoning_model: Model) -> bool:
     if not is_gemini_class:
         return False
 
-    # Check if it's a Gemini 2.5+ model (supports thinking)
+    # Check if it's a Gemini model with thinking support
+    # - Gemini 2.5+ models support thinking
+    # - Gemini 3+ models support thinking (including DeepThink variants)
     model_id = reasoning_model.id.lower()
-    has_thinking_support = "2.5" in model_id
+    has_thinking_support = (
+        "2.5" in model_id or "3.0" in model_id or "3.5" in model_id or "deepthink" in model_id or "gemini-3" in model_id
+    )
 
     # Also check if thinking parameters are set
     # Note: thinking_budget=0 explicitly disables thinking mode per Google's API docs
@@ -71,3 +75,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_events=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_events=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
@@ -8,7 +8,12 @@ from agno.utils.log import logger
 
 
 def is_groq_reasoning_model(reasoning_model: Model) -> bool:
-    return reasoning_model.__class__.__name__ == "Groq" and "deepseek" in reasoning_model.id.lower()
+    return reasoning_model.__class__.__name__ == "Groq" and (
+        "deepseek" in reasoning_model.id.lower()
+        or "openai/gpt-oss-20b" in reasoning_model.id.lower()
+        or "openai/gpt-oss-120b" in reasoning_model.id.lower()
+        or "qwen/qwen3-32b" in reasoning_model.id.lower()
+    )
 
 
 def get_groq_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
@@ -69,3 +74,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_events=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_events=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/helpers.py

@@ -1,8 +1,9 @@
-from typing import Any, Dict, List, Literal, Optional
+from typing import List, Literal, Optional
 
 from agno.models.base import Model
 from agno.models.message import Message
 from agno.reasoning.step import NextAction, ReasoningStep
+from agno.run.base import RunContext
 from agno.run.messages import RunMessages
 from agno.utils.log import logger
 
@@ -12,9 +13,7 @@ def get_reasoning_agent(
     telemetry: bool = False,
     debug_mode: bool = False,
     debug_level: Literal[1, 2] = 1,
-    session_state: Optional[Dict[str, Any]] = None,
-    dependencies: Optional[Dict[str, Any]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    run_context: Optional[RunContext] = None,
 ) -> "Agent":  # type: ignore  # noqa: F821
     from agno.agent import Agent
 
@@ -23,9 +22,9 @@ def get_reasoning_agent(
         telemetry=telemetry,
         debug_mode=debug_mode,
         debug_level=debug_level,
-        session_state=session_state,
-        dependencies=dependencies,
-        metadata=metadata,
+        session_state=run_context.session_state if run_context else None,
+        dependencies=run_context.dependencies if run_context else None,
+        metadata=run_context.metadata if run_context else None,
     )