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

agno/reasoning/ollama.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_ollama_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_ollama_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Ollama model.
+
+    For reasoning models on Ollama (qwq, deepseek-r1, etc.), 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_ollama_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from Ollama model asynchronously.
+
+    For reasoning models on Ollama (qwq, deepseek-r1, etc.), 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/openai.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
@@ -84,3 +84,115 @@ async def aget_openai_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_openai_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from OpenAI model.
+
+    For OpenAI reasoning 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
+
+    # 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:
+                    # Check for reasoning_content at completion (OpenAIResponses with reasoning_summary)
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        # If we haven't accumulated any reasoning content yet, use this
+                        if not reasoning_content:
+                            reasoning_content = event.reasoning_content
+                            yield (event.reasoning_content, None)
+    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_openai_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from OpenAI model asynchronously.
+
+    For OpenAI reasoning 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
+
+    # 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:
+                    # Check for reasoning_content at completion (OpenAIResponses with reasoning_summary)
+                    if hasattr(event, "reasoning_content") and event.reasoning_content:
+                        # If we haven't accumulated any reasoning content yet, use this
+                        if not reasoning_content:
+                            reasoning_content = event.reasoning_content
+                            yield (event.reasoning_content, None)
+    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/vertexai.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
@@ -74,3 +74,87 @@ async def aget_vertexai_reasoning(reasoning_agent: "Agent", messages: List[Messa
         reasoning_content=reasoning_content,
         redacted_reasoning_content=redacted_reasoning_content,
     )
+
+
+def get_vertexai_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> Iterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from VertexAI 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_vertexai_reasoning_stream(
+    reasoning_agent: "Agent",  # type: ignore  # noqa: F821
+    messages: List[Message],
+) -> AsyncIterator[Tuple[Optional[str], Optional[Message]]]:
+    """
+    Stream reasoning content from VertexAI 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/run/agent.py

@@ -153,9 +153,11 @@ class RunEvent(str, Enum):
 
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
+    tool_call_error = "ToolCallError"
 
     reasoning_started = "ReasoningStarted"
     reasoning_step = "ReasoningStep"
+    reasoning_content_delta = "ReasoningContentDelta"
     reasoning_completed = "ReasoningCompleted"
 
     memory_update_started = "MemoryUpdateStarted"
@@ -373,6 +375,14 @@ class ReasoningStepEvent(BaseAgentRunEvent):
     reasoning_content: str = ""
 
 
+@dataclass
+class ReasoningContentDeltaEvent(BaseAgentRunEvent):
+    """Event for streaming reasoning content chunks as they arrive."""
+
+    event: str = RunEvent.reasoning_content_delta.value
+    reasoning_content: str = ""  # The delta/chunk of reasoning content
+
+
 @dataclass
 class ReasoningCompletedEvent(BaseAgentRunEvent):
     event: str = RunEvent.reasoning_completed.value
@@ -396,6 +406,13 @@ class ToolCallCompletedEvent(BaseAgentRunEvent):
     audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
+@dataclass
+class ToolCallErrorEvent(BaseAgentRunEvent):
+    event: str = RunEvent.tool_call_error.value
+    tool: Optional[ToolExecution] = None
+    error: Optional[str] = None
+
+
 @dataclass
 class ParserModelResponseStartedEvent(BaseAgentRunEvent):
     event: str = RunEvent.parser_model_response_started.value
@@ -442,6 +459,7 @@ RunOutputEvent = Union[
     PostHookCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
+    ReasoningContentDeltaEvent,
     ReasoningCompletedEvent,
     MemoryUpdateStartedEvent,
     MemoryUpdateCompletedEvent,
@@ -449,6 +467,7 @@ RunOutputEvent = Union[
     SessionSummaryCompletedEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
@@ -474,6 +493,7 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.post_hook_completed.value: PostHookCompletedEvent,
     RunEvent.reasoning_started.value: ReasoningStartedEvent,
     RunEvent.reasoning_step.value: ReasoningStepEvent,
+    RunEvent.reasoning_content_delta.value: ReasoningContentDeltaEvent,
     RunEvent.reasoning_completed.value: ReasoningCompletedEvent,
     RunEvent.memory_update_started.value: MemoryUpdateStartedEvent,
     RunEvent.memory_update_completed.value: MemoryUpdateCompletedEvent,
@@ -481,6 +501,7 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.session_summary_completed.value: SessionSummaryCompletedEvent,
     RunEvent.tool_call_started.value: ToolCallStartedEvent,
     RunEvent.tool_call_completed.value: ToolCallCompletedEvent,
+    RunEvent.tool_call_error.value: ToolCallErrorEvent,
     RunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     RunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     RunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,

agno/run/base.py

@@ -22,7 +22,7 @@ class RunContext:
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     metadata: Optional[Dict[str, Any]] = None
     session_state: Optional[Dict[str, Any]] = None
-    output_schema: Optional[Type[BaseModel]] = None
+    output_schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None
 
 
 @dataclass
@@ -51,6 +51,7 @@ class BaseRunOutputEvent:
                 "session_summary",
                 "metrics",
                 "run_input",
+                "requirements",
             ]
         }
 
@@ -138,6 +139,9 @@ class BaseRunOutputEvent:
         if hasattr(self, "run_input") and self.run_input is not None:
             _dict["run_input"] = self.run_input.to_dict()
 
+        if hasattr(self, "requirements") and self.requirements is not None:
+            _dict["requirements"] = [req.to_dict() if hasattr(req, "to_dict") else req for req in self.requirements]
+
         return _dict
 
     def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
@@ -219,6 +223,21 @@ class BaseRunOutputEvent:
 
                 data["run_input"] = RunInput.from_dict(run_input)
 
+                # Handle requirements
+
+        # Handle requirements
+        requirements_data = data.pop("requirements", None)
+        if requirements_data is not None:
+            from agno.run.requirement import RunRequirement
+
+            requirements_list: List[RunRequirement] = []
+            for item in requirements_data:
+                if isinstance(item, RunRequirement):
+                    requirements_list.append(item)
+                elif isinstance(item, dict):
+                    requirements_list.append(RunRequirement.from_dict(item))
+            data["requirements"] = requirements_list if requirements_list else None
+
         # Filter data to only include fields that are actually defined in the target class
         from dataclasses import fields
 

agno/run/team.py

@@ -146,9 +146,11 @@ class TeamRunEvent(str, Enum):
 
     tool_call_started = "TeamToolCallStarted"
     tool_call_completed = "TeamToolCallCompleted"
+    tool_call_error = "TeamToolCallError"
 
     reasoning_started = "TeamReasoningStarted"
     reasoning_step = "TeamReasoningStep"
+    reasoning_content_delta = "TeamReasoningContentDelta"
     reasoning_completed = "TeamReasoningCompleted"
 
     memory_update_started = "TeamMemoryUpdateStarted"
@@ -346,6 +348,14 @@ class ReasoningStepEvent(BaseTeamRunEvent):
     reasoning_content: str = ""
 
 
+@dataclass
+class ReasoningContentDeltaEvent(BaseTeamRunEvent):
+    """Event for streaming reasoning content chunks as they arrive."""
+
+    event: str = TeamRunEvent.reasoning_content_delta.value
+    reasoning_content: str = ""  # The delta/chunk of reasoning content
+
+
 @dataclass
 class ReasoningCompletedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.reasoning_completed.value
@@ -369,6 +379,13 @@ class ToolCallCompletedEvent(BaseTeamRunEvent):
     audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
+@dataclass
+class ToolCallErrorEvent(BaseTeamRunEvent):
+    event: str = TeamRunEvent.tool_call_error.value
+    tool: Optional[ToolExecution] = None
+    error: Optional[str] = None
+
+
 @dataclass
 class ParserModelResponseStartedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.parser_model_response_started.value
@@ -411,6 +428,7 @@ TeamRunOutputEvent = Union[
     PreHookCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
+    ReasoningContentDeltaEvent,
     ReasoningCompletedEvent,
     MemoryUpdateStartedEvent,
     MemoryUpdateCompletedEvent,
@@ -418,6 +436,7 @@ TeamRunOutputEvent = Union[
     SessionSummaryCompletedEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
@@ -440,6 +459,7 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.post_hook_completed.value: PostHookCompletedEvent,
     TeamRunEvent.reasoning_started.value: ReasoningStartedEvent,
     TeamRunEvent.reasoning_step.value: ReasoningStepEvent,
+    TeamRunEvent.reasoning_content_delta.value: ReasoningContentDeltaEvent,
     TeamRunEvent.reasoning_completed.value: ReasoningCompletedEvent,
     TeamRunEvent.memory_update_started.value: MemoryUpdateStartedEvent,
     TeamRunEvent.memory_update_completed.value: MemoryUpdateCompletedEvent,
@@ -447,6 +467,7 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.session_summary_completed.value: SessionSummaryCompletedEvent,
     TeamRunEvent.tool_call_started.value: ToolCallStartedEvent,
     TeamRunEvent.tool_call_completed.value: ToolCallCompletedEvent,
+    TeamRunEvent.tool_call_error.value: ToolCallErrorEvent,
     TeamRunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     TeamRunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     TeamRunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,

agno/session/team.py

@@ -91,10 +91,7 @@ class TeamSession:
 
     def upsert_run(self, run_response: Union[TeamRunOutput, RunOutput]):
         """Adds a RunOutput, together with some calculated data, to the runs list."""
-
         messages = run_response.messages
-        if messages is None:
-            return
 
         # Make message duration None
         for m in messages or []: