agno 2.3.26__py3-none-any.whl → 2.4.1__py3-none-any.whl

agno/reasoning/manager.py

@@ -14,7 +14,6 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
-    Any,
     AsyncIterator,
     Callable,
     Dict,
@@ -29,6 +28,7 @@ from typing import (
 from agno.models.base import Model
 from agno.models.message import Message
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
+from agno.run.base import RunContext
 from agno.run.messages import RunMessages
 from agno.tools import Toolkit
 from agno.tools.function import Function
@@ -87,9 +87,7 @@ class ReasoningConfig:
     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
 
 
 @dataclass
@@ -161,9 +159,7 @@ class ReasoningManager:
             telemetry=self.config.telemetry,
             debug_mode=self.config.debug_mode,
             debug_level=self.config.debug_level,
-            session_state=self.config.session_state,
-            dependencies=self.config.dependencies,
-            metadata=self.config.metadata,
+            run_context=self.config.run_context,
         )
 
     def _get_default_reasoning_agent(self, model: Model) -> Optional["Agent"]:
@@ -183,9 +179,7 @@ class ReasoningManager:
             telemetry=self.config.telemetry,
             debug_mode=self.config.debug_mode,
             debug_level=self.config.debug_level,
-            session_state=self.config.session_state,
-            dependencies=self.config.dependencies,
-            metadata=self.config.metadata,
+            run_context=self.config.run_context,
         )
 
     def is_native_reasoning_model(self, model: Optional[Model] = None) -> bool:

agno/reasoning/ollama.py

@@ -86,7 +86,7 @@ def get_ollama_reasoning_stream(
     reasoning_content: str = ""
 
     try:
-        for event in reasoning_agent.run(input=messages, stream=True, stream_intermediate_steps=True):
+        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)
@@ -132,7 +132,7 @@ async def aget_ollama_reasoning_stream(
     reasoning_content: str = ""
 
     try:
-        async for event in reasoning_agent.arun(input=messages, stream=True, stream_intermediate_steps=True):
+        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)

agno/reasoning/openai.py

@@ -112,7 +112,7 @@ def get_openai_reasoning_stream(
     reasoning_content: str = ""
 
     try:
-        for event in reasoning_agent.run(input=messages, stream=True, stream_intermediate_steps=True):
+        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)
@@ -168,7 +168,7 @@ async def aget_openai_reasoning_stream(
     reasoning_content: str = ""
 
     try:
-        async for event in reasoning_agent.arun(input=messages, stream=True, stream_intermediate_steps=True):
+        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)

agno/reasoning/vertexai.py

@@ -94,7 +94,7 @@ def get_vertexai_reasoning_stream(
     redacted_reasoning_content: Optional[str] = None
 
     try:
-        for event in reasoning_agent.run(input=messages, stream=True, stream_intermediate_steps=True):
+        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
@@ -136,7 +136,7 @@ async def aget_vertexai_reasoning_stream(
     redacted_reasoning_content: Optional[str] = None
 
     try:
-        async for event in reasoning_agent.arun(input=messages, stream=True, stream_intermediate_steps=True):
+        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

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/run/agent.py

@@ -172,6 +172,12 @@ class RunEvent(str, Enum):
     output_model_response_started = "OutputModelResponseStarted"
     output_model_response_completed = "OutputModelResponseCompleted"
 
+    model_request_started = "ModelRequestStarted"
+    model_request_completed = "ModelRequestCompleted"
+
+    compression_started = "CompressionStarted"
+    compression_completed = "CompressionCompleted"
+
     custom_event = "CustomEvent"
 
 
@@ -349,6 +355,7 @@ class MemoryUpdateStartedEvent(BaseAgentRunEvent):
 @dataclass
 class MemoryUpdateCompletedEvent(BaseAgentRunEvent):
     event: str = RunEvent.memory_update_completed.value
+    memories: Optional[List[Any]] = None
 
 
 @dataclass
@@ -433,9 +440,53 @@ class OutputModelResponseCompletedEvent(BaseAgentRunEvent):
     event: str = RunEvent.output_model_response_completed.value
 
 
+@dataclass
+class ModelRequestStartedEvent(BaseAgentRunEvent):
+    """Event sent when a model request is about to be made"""
+
+    event: str = RunEvent.model_request_started.value
+    model: Optional[str] = None
+    model_provider: Optional[str] = None
+
+
+@dataclass
+class ModelRequestCompletedEvent(BaseAgentRunEvent):
+    """Event sent when a model request has completed"""
+
+    event: str = RunEvent.model_request_completed.value
+    model: Optional[str] = None
+    model_provider: Optional[str] = None
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+    time_to_first_token: Optional[float] = None
+    reasoning_tokens: Optional[int] = None
+    cache_read_tokens: Optional[int] = None
+    cache_write_tokens: Optional[int] = None
+
+
+@dataclass
+class CompressionStartedEvent(BaseAgentRunEvent):
+    """Event sent when tool result compression is about to start"""
+
+    event: str = RunEvent.compression_started.value
+
+
+@dataclass
+class CompressionCompletedEvent(BaseAgentRunEvent):
+    """Event sent when tool result compression has completed"""
+
+    event: str = RunEvent.compression_completed.value
+    tool_results_compressed: Optional[int] = None
+    original_size: Optional[int] = None
+    compressed_size: Optional[int] = None
+
+
 @dataclass
 class CustomEvent(BaseAgentRunEvent):
     event: str = RunEvent.custom_event.value
+    # tool_call_id for ToolExecution
+    tool_call_id: Optional[str] = None
 
     def __init__(self, **kwargs):
         # Store arbitrary attributes directly on the instance
@@ -472,6 +523,10 @@ RunOutputEvent = Union[
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
     OutputModelResponseCompletedEvent,
+    ModelRequestStartedEvent,
+    ModelRequestCompletedEvent,
+    CompressionStartedEvent,
+    CompressionCompletedEvent,
     CustomEvent,
 ]
 
@@ -506,6 +561,10 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     RunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,
     RunEvent.output_model_response_completed.value: OutputModelResponseCompletedEvent,
+    RunEvent.model_request_started.value: ModelRequestStartedEvent,
+    RunEvent.model_request_completed.value: ModelRequestCompletedEvent,
+    RunEvent.compression_started.value: CompressionStartedEvent,
+    RunEvent.compression_completed.value: CompressionCompletedEvent,
     RunEvent.custom_event.value: CustomEvent,
 }
 

agno/run/base.py

@@ -18,6 +18,9 @@ class RunContext:
     session_id: str
     user_id: Optional[str] = None
 
+    workflow_id: Optional[str] = None
+    workflow_name: Optional[str] = None
+
     dependencies: Optional[Dict[str, Any]] = None
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     metadata: Optional[Dict[str, Any]] = None
@@ -52,6 +55,7 @@ class BaseRunOutputEvent:
                 "metrics",
                 "run_input",
                 "requirements",
+                "memories",
             ]
         }
 
@@ -142,6 +146,9 @@ class BaseRunOutputEvent:
         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]
 
+        if hasattr(self, "memories") and self.memories is not None:
+            _dict["memories"] = [mem.to_dict() if hasattr(mem, "to_dict") else mem for mem in self.memories]
+
         return _dict
 
     def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:

agno/run/team.py

@@ -165,6 +165,12 @@ class TeamRunEvent(str, Enum):
     output_model_response_started = "TeamOutputModelResponseStarted"
     output_model_response_completed = "TeamOutputModelResponseCompleted"
 
+    model_request_started = "TeamModelRequestStarted"
+    model_request_completed = "TeamModelRequestCompleted"
+
+    compression_started = "TeamCompressionStarted"
+    compression_completed = "TeamCompressionCompleted"
+
     custom_event = "CustomEvent"
 
 
@@ -322,6 +328,7 @@ class MemoryUpdateStartedEvent(BaseTeamRunEvent):
 @dataclass
 class MemoryUpdateCompletedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.memory_update_completed.value
+    memories: Optional[List[Any]] = None
 
 
 @dataclass
@@ -406,6 +413,48 @@ class OutputModelResponseCompletedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.output_model_response_completed.value
 
 
+@dataclass
+class ModelRequestStartedEvent(BaseTeamRunEvent):
+    """Event sent when a model request is about to be made"""
+
+    event: str = TeamRunEvent.model_request_started.value
+    model: Optional[str] = None
+    model_provider: Optional[str] = None
+
+
+@dataclass
+class ModelRequestCompletedEvent(BaseTeamRunEvent):
+    """Event sent when a model request has completed"""
+
+    event: str = TeamRunEvent.model_request_completed.value
+    model: Optional[str] = None
+    model_provider: Optional[str] = None
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+    time_to_first_token: Optional[float] = None
+    reasoning_tokens: Optional[int] = None
+    cache_read_tokens: Optional[int] = None
+    cache_write_tokens: Optional[int] = None
+
+
+@dataclass
+class CompressionStartedEvent(BaseTeamRunEvent):
+    """Event sent when tool result compression is about to start"""
+
+    event: str = TeamRunEvent.compression_started.value
+
+
+@dataclass
+class CompressionCompletedEvent(BaseTeamRunEvent):
+    """Event sent when tool result compression has completed"""
+
+    event: str = TeamRunEvent.compression_completed.value
+    tool_results_compressed: Optional[int] = None
+    original_size: Optional[int] = None
+    compressed_size: Optional[int] = None
+
+
 @dataclass
 class CustomEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.custom_event.value
@@ -441,6 +490,10 @@ TeamRunOutputEvent = Union[
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
     OutputModelResponseCompletedEvent,
+    ModelRequestStartedEvent,
+    ModelRequestCompletedEvent,
+    CompressionStartedEvent,
+    CompressionCompletedEvent,
     CustomEvent,
 ]
 
@@ -472,6 +525,10 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     TeamRunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,
     TeamRunEvent.output_model_response_completed.value: OutputModelResponseCompletedEvent,
+    TeamRunEvent.model_request_started.value: ModelRequestStartedEvent,
+    TeamRunEvent.model_request_completed.value: ModelRequestCompletedEvent,
+    TeamRunEvent.compression_started.value: CompressionStartedEvent,
+    TeamRunEvent.compression_completed.value: CompressionCompletedEvent,
     TeamRunEvent.custom_event.value: CustomEvent,
 }
 

agno/skills/agent_skills.py

@@ -106,10 +106,17 @@ class Skills:
             "- **Scripts**: Executable code templates you can use or adapt",
             "- **References**: Supporting documentation (guides, cheatsheets, examples)",
             "",
-            "## Progressive Discovery",
-            "Skill information is designed to be loaded on-demand to keep your context focused:",
+            "## IMPORTANT: How to Use Skills",
+            "**Skill names are NOT callable functions.** You cannot call a skill directly by its name.",
+            "Instead, you MUST use the provided skill access tools:",
+            "",
+            "1. `get_skill_instructions(skill_name)` - Load the full instructions for a skill",
+            "2. `get_skill_reference(skill_name, reference_path)` - Access specific documentation",
+            "3. `get_skill_script(skill_name, script_path, execute=False)` - Read or run scripts",
+            "",
+            "## Progressive Discovery Workflow",
             "1. **Browse**: Review the skill summaries below to understand what's available",
-            "2. **Load**: When a task matches a skill, use `get_skill_instructions` to load full guidance",
+            "2. **Load**: When a task matches a skill, call `get_skill_instructions(skill_name)` first",
             "3. **Reference**: Use `get_skill_reference` to access specific documentation as needed",
             "4. **Scripts**: Use `get_skill_script` to read or execute scripts from a skill",
             "",

agno/team/__init__.py

@@ -16,7 +16,7 @@ from agno.run.team import (
     ToolCallStartedEvent,
 )
 from agno.team.remote import RemoteTeam
-from agno.team.team import Team
+from agno.team.team import Team, get_team_by_id, get_teams
 
 __all__ = [
     "Team",
@@ -36,4 +36,6 @@ __all__ = [
     "ReasoningCompletedEvent",
     "ToolCallStartedEvent",
     "ToolCallCompletedEvent",
+    "get_team_by_id",
+    "get_teams",
 ]