agno 2.2.13__py3-none-any.whl → 2.4.3__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_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_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_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/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
@@ -21,6 +21,8 @@ def is_openai_reasoning_model(reasoning_model: Model) -> bool:
             or ("o1" in reasoning_model.id)
             or ("4.1" in reasoning_model.id)
             or ("4.5" in reasoning_model.id)
+            or ("5.1" in reasoning_model.id)
+            or ("5.2" in reasoning_model.id)
         )
     ) or (isinstance(reasoning_model, OpenAILike) and "deepseek-r1" in reasoning_model.id.lower())
 
@@ -84,3 +86,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_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:
+                    # 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_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:
+                    # 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_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_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_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/registry/__init__.py

@@ -0,0 +1,3 @@
+from agno.registry.registry import Registry
+
+__all__ = ["Registry"]

agno/registry/registry.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Any, Callable, Dict, List, Optional, Type
+from uuid import uuid4
+
+from pydantic import BaseModel
+
+from agno.db.base import BaseDb
+from agno.models.base import Model
+from agno.tools.function import Function
+from agno.tools.toolkit import Toolkit
+from agno.vectordb.base import VectorDb
+
+
+@dataclass
+class Registry:
+    """
+    Registry is used to manage non serializable objects like tools, models, databases and vector databases.
+    """
+
+    name: Optional[str] = None
+    description: Optional[str] = None
+    id: str = field(default_factory=lambda: str(uuid4()))
+    tools: List[Any] = field(default_factory=list)
+    models: List[Model] = field(default_factory=list)
+    dbs: List[BaseDb] = field(default_factory=list)
+    vector_dbs: List[VectorDb] = field(default_factory=list)
+    schemas: List[Type[BaseModel]] = field(default_factory=list)
+
+    @cached_property
+    def _entrypoint_lookup(self) -> Dict[str, Callable]:
+        lookup: Dict[str, Callable] = {}
+        for tool in self.tools:
+            if isinstance(tool, Toolkit):
+                for func in tool.functions.values():
+                    if func.entrypoint is not None:
+                        lookup[func.name] = func.entrypoint
+            elif isinstance(tool, Function):
+                if tool.entrypoint is not None:
+                    lookup[tool.name] = tool.entrypoint
+            elif callable(tool):
+                lookup[tool.__name__] = tool
+        return lookup
+
+    def rehydrate_function(self, func_dict: Dict[str, Any]) -> Function:
+        """Reconstruct a Function from dict, reattaching its entrypoint."""
+        func = Function.from_dict(func_dict)
+        func.entrypoint = self._entrypoint_lookup.get(func.name)
+        return func
+
+    def get_schema(self, name: str) -> Optional[Type[BaseModel]]:
+        """Get a schema by name."""
+        if self.schemas:
+            return next((s for s in self.schemas if s.__name__ == name), None)
+        return None
+
+    def get_db(self, db_id: str) -> Optional[BaseDb]:
+        """Get a database by id from the registry.
+
+        Args:
+            db_id: The database id to look up
+
+        Returns:
+            The database instance if found, None otherwise
+        """
+        if self.dbs:
+            return next((db for db in self.dbs if db.id == db_id), None)
+        return None

agno/remote/__init__.py

@@ -0,0 +1,3 @@
+from agno.remote.base import BaseRemote
+
+__all__ = ["BaseRemote"]