agno 2.1.3__py3-none-any.whl → 2.1.5__py3-none-any.whl

agno/memory/manager.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Dict, List, Literal, Optional, Type, Union
 
 from pydantic import BaseModel, Field
 
-from agno.db.base import BaseDb
+from agno.db.base import AsyncBaseDb, BaseDb
 from agno.db.schemas import UserMemory
 from agno.models.base import Model
 from agno.models.message import Message
@@ -53,7 +53,7 @@ class MemoryManager:
     add_memories: bool = True
 
     # The database to store memories
-    db: Optional[BaseDb] = None
+    db: Optional[Union[BaseDb, AsyncBaseDb]] = None
 
     debug_mode: bool = False
 
@@ -63,11 +63,11 @@ class MemoryManager:
         system_message: Optional[str] = None,
         memory_capture_instructions: Optional[str] = None,
         additional_instructions: Optional[str] = None,
-        db: Optional[BaseDb] = None,
-        delete_memories: bool = True,
+        db: Optional[Union[BaseDb, AsyncBaseDb]] = None,
+        delete_memories: bool = False,
         update_memories: bool = True,
         add_memories: bool = True,
-        clear_memories: bool = True,
+        clear_memories: bool = False,
         debug_mode: bool = False,
     ):
         self.model = model
@@ -114,6 +114,22 @@ class MemoryManager:
             return memories
         return None
 
+    async def aread_from_db(self, user_id: Optional[str] = None):
+        if self.db:
+            # If no user_id is provided, read all memories
+            if user_id is None:
+                all_memories: List[UserMemory] = await self.db.get_user_memories()  # type: ignore
+            else:
+                all_memories = await self.db.get_user_memories(user_id=user_id)  # type: ignore
+
+            memories: Dict[str, List[UserMemory]] = {}
+            for memory in all_memories:
+                if memory.user_id is not None and memory.memory_id is not None:
+                    memories.setdefault(memory.user_id, []).append(memory)
+
+            return memories
+        return None
+
     def set_log_level(self):
         if self.debug_mode or getenv("AGNO_DEBUG", "false").lower() == "true":
             self.debug_mode = True
@@ -139,6 +155,20 @@ class MemoryManager:
             log_warning("Memory Db not provided.")
             return []
 
+    async def aget_user_memories(self, user_id: Optional[str] = None) -> Optional[List[UserMemory]]:
+        """Get the user memories for a given user id"""
+        if self.db:
+            if user_id is None:
+                user_id = "default"
+            # Refresh from the Db
+            memories = await self.aread_from_db(user_id=user_id)
+            if memories is None:
+                return []
+            return memories.get(user_id, [])
+        else:
+            log_warning("Memory Db not provided.")
+            return []
+
     def get_user_memory(self, memory_id: str, user_id: Optional[str] = None) -> Optional[UserMemory]:
         """Get the user memory for a given user id"""
         if self.db:
@@ -261,6 +291,11 @@ class MemoryManager:
             log_warning("MemoryDb not provided.")
             return "Please provide a db to store memories"
 
+        if isinstance(self.db, AsyncBaseDb):
+            raise ValueError(
+                "create_user_memories() is not supported with an async DB. Please use acreate_user_memories() instead."
+            )
+
         if not messages and not message:
             raise ValueError("You must provide either a message or a list of messages")
 
@@ -321,7 +356,10 @@ class MemoryManager:
         if user_id is None:
             user_id = "default"
 
-        memories = self.read_from_db(user_id=user_id)
+        if isinstance(self.db, AsyncBaseDb):
+            memories = await self.aread_from_db(user_id=user_id)
+        else:
+            memories = self.read_from_db(user_id=user_id)
         if memories is None:
             memories = {}
 
@@ -340,7 +378,10 @@ class MemoryManager:
         )
 
         # We refresh from the DB
-        self.read_from_db(user_id=user_id)
+        if isinstance(self.db, AsyncBaseDb):
+            memories = await self.aread_from_db(user_id=user_id)
+        else:
+            memories = self.read_from_db(user_id=user_id)
 
         return response
 
@@ -351,6 +392,11 @@ class MemoryManager:
             log_warning("MemoryDb not provided.")
             return "Please provide a db to store memories"
 
+        if not isinstance(self.db, BaseDb):
+            raise ValueError(
+                "update_memory_task() is not supported with an async DB. Please use aupdate_memory_task() instead."
+            )
+
         if user_id is None:
             user_id = "default"
 
@@ -807,7 +853,7 @@ class MemoryManager:
         messages: List[Message],
         existing_memories: List[Dict[str, Any]],
         user_id: str,
-        db: BaseDb,
+        db: Union[BaseDb, AsyncBaseDb],
         agent_id: Optional[str] = None,
         team_id: Optional[str] = None,
         update_memories: bool = True,
@@ -826,19 +872,34 @@ class MemoryManager:
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.determine_tools_for_model(
-            self._get_db_tools(
-                user_id,
-                db,
-                input_string,
-                agent_id=agent_id,
-                team_id=team_id,
-                enable_add_memory=add_memories,
-                enable_update_memory=update_memories,
-                enable_delete_memory=False,
-                enable_clear_memory=False,
-            ),
-        )
+        if isinstance(db, AsyncBaseDb):
+            self.determine_tools_for_model(
+                await self._aget_db_tools(
+                    user_id,
+                    db,
+                    input_string,
+                    agent_id=agent_id,
+                    team_id=team_id,
+                    enable_add_memory=add_memories,
+                    enable_update_memory=update_memories,
+                    enable_delete_memory=False,
+                    enable_clear_memory=False,
+                ),
+            )
+        else:
+            self.determine_tools_for_model(
+                self._get_db_tools(
+                    user_id,
+                    db,
+                    input_string,
+                    agent_id=agent_id,
+                    team_id=team_id,
+                    enable_add_memory=add_memories,
+                    enable_update_memory=update_memories,
+                    enable_delete_memory=False,
+                    enable_clear_memory=False,
+                ),
+            )
 
         # Prepare the List of messages to send to the Model
         messages_for_model: List[Message] = [
@@ -923,7 +984,7 @@ class MemoryManager:
         task: str,
         existing_memories: List[Dict[str, Any]],
         user_id: str,
-        db: BaseDb,
+        db: Union[BaseDb, AsyncBaseDb],
         delete_memories: bool = True,
         clear_memories: bool = True,
         update_memories: bool = True,
@@ -937,17 +998,30 @@ class MemoryManager:
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.determine_tools_for_model(
-            self._get_db_tools(
-                user_id,
-                db,
-                task,
-                enable_delete_memory=delete_memories,
-                enable_clear_memory=clear_memories,
-                enable_update_memory=update_memories,
-                enable_add_memory=add_memories,
-            ),
-        )
+        if isinstance(db, AsyncBaseDb):
+            self.determine_tools_for_model(
+                await self._aget_db_tools(
+                    user_id,
+                    db,
+                    task,
+                    enable_delete_memory=delete_memories,
+                    enable_clear_memory=clear_memories,
+                    enable_update_memory=update_memories,
+                    enable_add_memory=add_memories,
+                ),
+            )
+        else:
+            self.determine_tools_for_model(
+                self._get_db_tools(
+                    user_id,
+                    db,
+                    task,
+                    enable_delete_memory=delete_memories,
+                    enable_clear_memory=clear_memories,
+                    enable_update_memory=update_memories,
+                    enable_add_memory=add_memories,
+                ),
+            )
 
         # Prepare the List of messages to send to the Model
         messages_for_model: List[Message] = [
@@ -1079,3 +1153,137 @@ class MemoryManager:
         if enable_clear_memory:
             functions.append(clear_memory)
         return functions
+
+    async def _aget_db_tools(
+        self,
+        user_id: str,
+        db: Union[BaseDb, AsyncBaseDb],
+        input_string: str,
+        enable_add_memory: bool = True,
+        enable_update_memory: bool = True,
+        enable_delete_memory: bool = True,
+        enable_clear_memory: bool = True,
+        agent_id: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> List[Callable]:
+        async def add_memory(memory: str, topics: Optional[List[str]] = None) -> str:
+            """Use this function to add a memory to the database.
+            Args:
+                memory (str): The memory to be added.
+                topics (Optional[List[str]]): The topics of the memory (e.g. ["name", "hobbies", "location"]).
+            Returns:
+                str: A message indicating if the memory was added successfully or not.
+            """
+            from uuid import uuid4
+
+            from agno.db.base import UserMemory
+
+            try:
+                memory_id = str(uuid4())
+                if isinstance(db, AsyncBaseDb):
+                    await db.upsert_user_memory(
+                        UserMemory(
+                            memory_id=memory_id,
+                            user_id=user_id,
+                            agent_id=agent_id,
+                            team_id=team_id,
+                            memory=memory,
+                            topics=topics,
+                            input=input_string,
+                        )
+                    )
+                else:
+                    db.upsert_user_memory(
+                        UserMemory(
+                            memory_id=memory_id,
+                            user_id=user_id,
+                            agent_id=agent_id,
+                            team_id=team_id,
+                            memory=memory,
+                            topics=topics,
+                            input=input_string,
+                        )
+                    )
+                log_debug(f"Memory added: {memory_id}")
+                return "Memory added successfully"
+            except Exception as e:
+                log_warning(f"Error storing memory in db: {e}")
+                return f"Error adding memory: {e}"
+
+        async def update_memory(memory_id: str, memory: str, topics: Optional[List[str]] = None) -> str:
+            """Use this function to update an existing memory in the database.
+            Args:
+                memory_id (str): The id of the memory to be updated.
+                memory (str): The updated memory.
+                topics (Optional[List[str]]): The topics of the memory (e.g. ["name", "hobbies", "location"]).
+            Returns:
+                str: A message indicating if the memory was updated successfully or not.
+            """
+            from agno.db.base import UserMemory
+
+            try:
+                if isinstance(db, AsyncBaseDb):
+                    await db.upsert_user_memory(
+                        UserMemory(
+                            memory_id=memory_id,
+                            memory=memory,
+                            topics=topics,
+                            input=input_string,
+                        )
+                    )
+                else:
+                    db.upsert_user_memory(
+                        UserMemory(
+                            memory_id=memory_id,
+                            memory=memory,
+                            topics=topics,
+                            input=input_string,
+                        )
+                    )
+                log_debug("Memory updated")
+                return "Memory updated successfully"
+            except Exception as e:
+                log_warning(f"Error storing memory in db: {e}")
+                return f"Error adding memory: {e}"
+
+        async def delete_memory(memory_id: str) -> str:
+            """Use this function to delete a single memory from the database.
+            Args:
+                memory_id (str): The id of the memory to be deleted.
+            Returns:
+                str: A message indicating if the memory was deleted successfully or not.
+            """
+            try:
+                if isinstance(db, AsyncBaseDb):
+                    await db.delete_user_memory(memory_id=memory_id)
+                else:
+                    db.delete_user_memory(memory_id=memory_id)
+                log_debug("Memory deleted")
+                return "Memory deleted successfully"
+            except Exception as e:
+                log_warning(f"Error deleting memory in db: {e}")
+                return f"Error deleting memory: {e}"
+
+        async def clear_memory() -> str:
+            """Use this function to remove all (or clear all) memories from the database.
+
+            Returns:
+                str: A message indicating if the memory was cleared successfully or not.
+            """
+            if isinstance(db, AsyncBaseDb):
+                await db.clear_memories()
+            else:
+                db.clear_memories()
+            log_debug("Memory cleared")
+            return "Memory cleared successfully"
+
+        functions: List[Callable] = []
+        if enable_add_memory:
+            functions.append(add_memory)
+        if enable_update_memory:
+            functions.append(update_memory)
+        if enable_delete_memory:
+            functions.append(delete_memory)
+        if enable_clear_memory:
+            functions.append(clear_memory)
+        return functions

agno/models/anthropic/claude.py

@@ -59,6 +59,17 @@ class Claude(Model):
     For more information, see: https://docs.anthropic.com/en/api/messages
     """
 
+    # Models that DO NOT support extended thinking
+    # All future models are assumed to support thinking
+    # Based on official Anthropic documentation: https://docs.claude.com/en/docs/about-claude/models/overview
+    NON_THINKING_MODELS = {
+        # Claude Haiku 3 family (does not support thinking)
+        "claude-3-haiku-20240307",
+        # Claude Haiku 3.5 family (does not support thinking)
+        "claude-3-5-haiku-20241022",
+        "claude-3-5-haiku-latest",
+    }
+
     id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
@@ -85,6 +96,12 @@ class Claude(Model):
     client: Optional[AnthropicClient] = None
     async_client: Optional[AsyncAnthropicClient] = None
 
+    def __post_init__(self):
+        """Validate model configuration after initialization"""
+        # Validate thinking support immediately at model creation
+        if self.thinking:
+            self._validate_thinking_support()
+
     def _get_client_params(self) -> Dict[str, Any]:
         client_params: Dict[str, Any] = {}
 
@@ -126,10 +143,30 @@ class Claude(Model):
         self.async_client = AsyncAnthropicClient(**_client_params)
         return self.async_client
 
+    def _validate_thinking_support(self) -> None:
+        """
+        Validate that the current model supports extended thinking.
+
+        Raises:
+            ValueError: If thinking is enabled but the model doesn't support it
+        """
+        if self.thinking and self.id in self.NON_THINKING_MODELS:
+            non_thinking_models = "\n  - ".join(sorted(self.NON_THINKING_MODELS))
+            raise ValueError(
+                f"Model '{self.id}' does not support extended thinking.\n\n"
+                f"The following models do NOT support thinking:\n  - {non_thinking_models}\n\n"
+                f"All other Claude models support extended thinking by default.\n"
+                f"For more information, see: https://docs.anthropic.com/en/docs/about-claude/models/overview"
+            )
+
     def get_request_params(self) -> Dict[str, Any]:
         """
         Generate keyword arguments for API requests.
         """
+        # Validate thinking support if thinking is enabled
+        if self.thinking:
+            self._validate_thinking_support()
+
         _request_params: Dict[str, Any] = {}
         if self.max_tokens:
             _request_params["max_tokens"] = self.max_tokens

agno/os/app.py

@@ -12,7 +12,7 @@ from rich.panel import Panel
 from starlette.requests import Request
 
 from agno.agent.agent import Agent
-from agno.db.base import BaseDb
+from agno.db.base import AsyncBaseDb, BaseDb
 from agno.os.config import (
     AgentOSConfig,
     DatabaseConfig,
@@ -207,9 +207,6 @@ class AgentOS:
 
                 team.initialize_team()
 
-                # Required for the built-in routes to work
-                team.store_events = True
-
                 for member in team.members:
                     if isinstance(member, Agent):
                         member.team_id = None
@@ -217,13 +214,20 @@ class AgentOS:
                     elif isinstance(member, Team):
                         member.initialize_team()
 
+                # Required for the built-in routes to work
+                team.store_events = True
+
         if self.workflows:
             for workflow in self.workflows:
                 # Track MCP tools recursively in workflow members
                 collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
+
                 if not workflow.id:
                     workflow.id = generate_id_from_name(workflow.name)
 
+                # Required for the built-in routes to work
+                workflow.store_events = True
+
         if self.telemetry:
             from agno.api.os import OSLaunch, log_os_telemetry
 
@@ -455,10 +459,10 @@ class AgentOS:
 
     def _auto_discover_databases(self) -> None:
         """Auto-discover the databases used by all contextual agents, teams and workflows."""
-        from agno.db.base import BaseDb
+        from agno.db.base import AsyncBaseDb, BaseDb
 
-        dbs: Dict[str, BaseDb] = {}
-        knowledge_dbs: Dict[str, BaseDb] = {}  # Track databases specifically used for knowledge
+        dbs: Dict[str, Union[BaseDb, AsyncBaseDb]] = {}
+        knowledge_dbs: Dict[str, Union[BaseDb, AsyncBaseDb]] = {}  # Track databases specifically used for knowledge
 
         for agent in self.agents or []:
             if agent.db:
@@ -485,7 +489,7 @@ class AgentOS:
         self.dbs = dbs
         self.knowledge_dbs = knowledge_dbs
 
-    def _register_db_with_validation(self, registered_dbs: Dict[str, Any], db: BaseDb) -> None:
+    def _register_db_with_validation(self, registered_dbs: Dict[str, Any], db: Union[BaseDb, AsyncBaseDb]) -> None:
         """Register a database in the contextual OS after validating it is not conflicting with registered databases"""
         if db.id in registered_dbs:
             existing_db = registered_dbs[db.id]
@@ -496,7 +500,7 @@ class AgentOS:
                 )
         registered_dbs[db.id] = db
 
-    def _are_db_instances_compatible(self, db1: BaseDb, db2: BaseDb) -> bool:
+    def _are_db_instances_compatible(self, db1: Union[BaseDb, AsyncBaseDb], db2: Union[BaseDb, AsyncBaseDb]) -> bool:
         """
         Return True if the two given database objects are compatible
         Two database objects are compatible if they point to the same database with identical configuration.
@@ -645,6 +649,7 @@ class AgentOS:
         port: int = 7777,
         reload: bool = False,
         workers: Optional[int] = None,
+        access_log: bool = False,
         **kwargs,
     ):
         import uvicorn
@@ -677,4 +682,4 @@ class AgentOS:
             )
         )
 
-        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, **kwargs)
+        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, access_log=access_log, **kwargs)

agno/os/interfaces/a2a/router.py

@@ -11,7 +11,7 @@ from typing_extensions import List
 try:
     from a2a.types import SendMessageSuccessResponse, Task, TaskState, TaskStatus
 except ImportError as e:
-    raise ImportError("`a2a` not installed. Please install it with `pip install -U a2a`") from e
+    raise ImportError("`a2a` not installed. Please install it with `pip install -U a2a-sdk`") from e
 
 from agno.agent import Agent
 from agno.os.interfaces.a2a.utils import (
@@ -36,9 +36,8 @@ def attach_routes(
 
     @router.post(
         "/message/send",
-        tags=["A2A"],
         operation_id="send_message",
-        summary="Send message to Agent, Team, or Workflow (A2A Protocol)",
+        name="send_message",
         description="Send a message to an Agno Agent, Team, or Workflow. "
         "The Agent, Team or Workflow is identified via the 'agentId' field in params.message or X-Agent-ID header. "
         "Optional: Pass user ID via X-User-ID header (recommended) or 'userId' in params.message.metadata.",
@@ -159,9 +158,8 @@ def attach_routes(
 
     @router.post(
         "/message/stream",
-        tags=["A2A"],
         operation_id="stream_message",
-        summary="Stream message to Agent, Team, or Workflow (A2A Protocol)",
+        name="stream_message",
         description="Stream a message to an Agno Agent, Team, or Workflow."
         "The Agent, Team or Workflow is identified via the 'agentId' field in params.message or X-Agent-ID header. "
         "Optional: Pass user ID via X-User-ID header (recommended) or 'userId' in params.message.metadata. "

agno/os/interfaces/agui/router.py

@@ -101,7 +101,10 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
 
     encoder = EventEncoder()
 
-    @router.post("/agui")
+    @router.post(
+        "/agui",
+        name="run_agent",
+    )
     async def run_agent_agui(run_input: RunAgentInput):
         async def event_generator():
             if agent:

agno/os/interfaces/agui/utils.py

@@ -8,6 +8,7 @@ from typing import AsyncIterator, List, Set, Tuple, Union
 
 from ag_ui.core import (
     BaseEvent,
+    CustomEvent,
     EventType,
     RunFinishedEvent,
     StepFinishedEvent,
@@ -261,6 +262,11 @@ def _create_events_from_chunk(
         step_finished_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
         events_to_emit.append(step_finished_event)
 
+    # Handle custom events
+    elif chunk.event == RunEvent.custom_event:
+        custom_event = CustomEvent(name=chunk.event, value=chunk.content)
+        events_to_emit.append(custom_event)
+
     return events_to_emit, message_started, message_id
 
 
@@ -291,20 +297,41 @@ def _create_completion_events(
 
     # emit frontend tool calls, i.e. external_execution=True
     if isinstance(chunk, RunPausedEvent) and chunk.tools is not None:
+        # First, emit an assistant message for external tool calls
+        assistant_message_id = str(uuid.uuid4())
+        assistant_start_event = TextMessageStartEvent(
+            type=EventType.TEXT_MESSAGE_START,
+            message_id=assistant_message_id,
+            role="assistant",
+        )
+        events_to_emit.append(assistant_start_event)
+
+        # Add any text content if present for the assistant message
+        if chunk.content:
+            content_event = TextMessageContentEvent(
+                type=EventType.TEXT_MESSAGE_CONTENT,
+                message_id=assistant_message_id,
+                delta=str(chunk.content),
+            )
+            events_to_emit.append(content_event)
+
+        # End the assistant message
+        assistant_end_event = TextMessageEndEvent(
+            type=EventType.TEXT_MESSAGE_END,
+            message_id=assistant_message_id,
+        )
+        events_to_emit.append(assistant_end_event)
+
+        # Now emit the tool call events with the assistant message as parent
         for tool in chunk.tools:
             if tool.tool_call_id is None or tool.tool_name is None:
                 continue
 
-            # Use the current text message ID from event buffer as parent
-            parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
-            if not parent_message_id:
-                parent_message_id = message_id  # Fallback to the passed message_id
-
             start_event = ToolCallStartEvent(
                 type=EventType.TOOL_CALL_START,
                 tool_call_id=tool.tool_call_id,
                 tool_call_name=tool.tool_name,
-                parent_message_id=parent_message_id,
+                parent_message_id=assistant_message_id,  # Use the assistant message as parent
             )
             events_to_emit.append(start_event)
 

agno/os/interfaces/slack/router.py

@@ -28,14 +28,12 @@ def attach_routes(
 ) -> APIRouter:
     # Determine entity type for documentation
     entity_type = "agent" if agent else "team" if team else "workflow" if workflow else "unknown"
-    entity_name = getattr(agent or team or workflow, "name", f"Unnamed {entity_type}")
 
     @router.post(
         "/events",
         operation_id=f"slack_events_{entity_type}",
-        summary=f"Process Slack Events for {entity_type.title()}",
-        description=f"Process incoming Slack events and route them to the configured {entity_type}: {entity_name}",
-        tags=["Slack", f"Slack-{entity_type.title()}"],
+        name="slack_events",
+        description="Process incoming Slack events",
         response_model=SlackEventResponse,
         response_model_exclude_none=True,
         responses={