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

agno/memory/manager.py

@@ -236,8 +236,11 @@ class MemoryManager:
             memory_id (str): The id of the memory to delete
             user_id (Optional[str]): The user id to delete the memory from. If not provided, the memory is deleted from the "default" user.
         """
+        if user_id is None:
+            user_id = "default"
+
         if self.db:
-            self._delete_db_memory(memory_id=memory_id)
+            self._delete_db_memory(memory_id=memory_id, user_id=user_id)
         else:
             log_warning("Memory DB not provided.")
             return None
@@ -420,12 +423,16 @@ class MemoryManager:
             log_warning(f"Error storing memory in db: {e}")
             return f"Error adding memory: {e}"
 
-    def _delete_db_memory(self, memory_id: str) -> str:
+    def _delete_db_memory(self, memory_id: str, user_id: Optional[str] = None) -> str:
         """Use this function to delete a memory from the database."""
         try:
             if not self.db:
                 raise ValueError("Memory db not initialized")
-            self.db.delete_user_memory(memory_id=memory_id)
+
+            if user_id is None:
+                user_id = "default"
+
+            self.db.delete_user_memory(memory_id=memory_id, user_id=user_id)
             return "Memory deleted successfully"
         except Exception as e:
             log_warning(f"Error deleting memory in db: {e}")
@@ -1027,6 +1034,7 @@ class MemoryManager:
                         memory_id=memory_id,
                         memory=memory,
                         topics=topics,
+                        user_id=user_id,
                         input=input_string,
                     )
                 )
@@ -1044,7 +1052,7 @@ class MemoryManager:
                 str: A message indicating if the memory was deleted successfully or not.
             """
             try:
-                db.delete_user_memory(memory_id=memory_id)
+                db.delete_user_memory(memory_id=memory_id, user_id=user_id)
                 log_debug("Memory deleted")
                 return "Memory deleted successfully"
             except Exception as e:

agno/models/anthropic/claude.py

@@ -59,7 +59,7 @@ class Claude(Model):
     For more information, see: https://docs.anthropic.com/en/api/messages
     """
 
-    id: str = "claude-3-5-sonnet-20241022"
+    id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
 
@@ -78,6 +78,7 @@ class Claude(Model):
     # Client parameters
     api_key: Optional[str] = None
     default_headers: Optional[Dict[str, Any]] = None
+    timeout: Optional[float] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Anthropic clients
@@ -93,6 +94,8 @@ class Claude(Model):
 
         # Add API key to client parameters
         client_params["api_key"] = self.api_key
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
 
         # Add additional client parameters
         if self.client_params is not None:

agno/models/aws/bedrock.py

@@ -6,7 +6,7 @@ from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Ty
 from pydantic import BaseModel
 
 from agno.exceptions import AgnoError, ModelProviderError
-from agno.models.base import MessageData, Model
+from agno.models.base import Model
 from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
@@ -360,7 +360,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -408,7 +408,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -426,10 +426,14 @@ class AwsBedrock(Model):
 
             assistant_message.metrics.start_timer()
 
+            # Track current tool being built across chunks
+            current_tool: Dict[str, Any] = {}
+
             for chunk in self.get_client().converse_stream(modelId=self.id, messages=formatted_messages, **body)[
                 "stream"
             ]:
-                yield self._parse_provider_response_delta(chunk)
+                model_response, current_tool = self._parse_provider_response_delta(chunk, current_tool)
+                yield model_response
 
             assistant_message.metrics.stop_timer()
 
@@ -456,7 +460,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -507,7 +511,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -525,10 +529,14 @@ class AwsBedrock(Model):
 
             assistant_message.metrics.start_timer()
 
+            # Track current tool being built across chunks
+            current_tool: Dict[str, Any] = {}
+
             async with self.get_async_client() as client:
                 response = await client.converse_stream(modelId=self.id, messages=formatted_messages, **body)
                 async for chunk in response["stream"]:
-                    yield self._parse_provider_response_delta(chunk)
+                    model_response, current_tool = self._parse_provider_response_delta(chunk, current_tool)
+                    yield model_response
 
             assistant_message.metrics.stop_timer()
 
@@ -617,122 +625,54 @@ class AwsBedrock(Model):
 
         return model_response
 
-    def process_response_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        stream_data: MessageData,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-        run_response: Optional[RunOutput] = None,
-    ) -> Iterator[ModelResponse]:
-        """
-        Process the synchronous response stream.
-
-        Args:
-            messages (List[Message]): The messages to include in the request.
-            assistant_message (Message): The assistant message.
-            stream_data (MessageData): The stream data.
-        """
-        for response_delta in self.invoke_stream(
-            messages=messages,
-            assistant_message=assistant_message,
-            response_format=response_format,
-            tools=tools,
-            tool_choice=tool_choice,
-            run_response=run_response,
-        ):
-            should_yield = False
-
-            if response_delta.content:
-                stream_data.response_content += response_delta.content
-                should_yield = True
-
-            if response_delta.tool_calls:
-                if stream_data.response_tool_calls is None:
-                    stream_data.response_tool_calls = []
-                stream_data.response_tool_calls.extend(response_delta.tool_calls)
-                should_yield = True
-
-            if should_yield:
-                yield response_delta
-
-    async def aprocess_response_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        stream_data: MessageData,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-        run_response: Optional[RunOutput] = None,
-    ) -> AsyncIterator[ModelResponse]:
-        """
-        Process the asynchronous response stream.
-
-        Args:
-            messages (List[Message]): The messages to include in the request.
-            assistant_message (Message): The assistant message.
-            stream_data (MessageData): The stream data.
-        """
-        async for response_delta in self.ainvoke_stream(
-            messages=messages,
-            assistant_message=assistant_message,
-            response_format=response_format,
-            tools=tools,
-            tool_choice=tool_choice,
-            run_response=run_response,
-        ):
-            should_yield = False
-
-            if response_delta.content:
-                stream_data.response_content += response_delta.content
-                should_yield = True
-
-            if response_delta.tool_calls:
-                if stream_data.response_tool_calls is None:
-                    stream_data.response_tool_calls = []
-                stream_data.response_tool_calls.extend(response_delta.tool_calls)
-                should_yield = True
-
-            if should_yield:
-                yield response_delta
-
-        self._populate_assistant_message(assistant_message=assistant_message, provider_response=response_delta)
-
-    def _parse_provider_response_delta(self, response_delta: Dict[str, Any]) -> ModelResponse:  # type: ignore
+    def _parse_provider_response_delta(
+        self, response_delta: Dict[str, Any], current_tool: Dict[str, Any]
+    ) -> Tuple[ModelResponse, Dict[str, Any]]:
         """Parse the provider response delta for streaming.
 
         Args:
             response_delta: The streaming response delta from AWS Bedrock
+            current_tool: The current tool being built across chunks
 
         Returns:
-            ModelResponse: The parsed model response delta
+            Tuple[ModelResponse, Dict[str, Any]]: The parsed model response delta and updated current_tool
         """
         model_response = ModelResponse(role="assistant")
 
-        # Handle contentBlockDelta - text content
-        if "contentBlockDelta" in response_delta:
-            delta = response_delta["contentBlockDelta"]["delta"]
-            if "text" in delta:
-                model_response.content = delta["text"]
-
         # Handle contentBlockStart - tool use start
-        elif "contentBlockStart" in response_delta:
+        if "contentBlockStart" in response_delta:
             start = response_delta["contentBlockStart"]["start"]
             if "toolUse" in start:
-                tool_use = start["toolUse"]
-                model_response.tool_calls = [
-                    {
-                        "id": tool_use.get("toolUseId", ""),
-                        "type": "function",
-                        "function": {
-                            "name": tool_use.get("name", ""),
-                            "arguments": "",  # Will be filled in subsequent deltas
-                        },
-                    }
-                ]
+                # Start a new tool
+                tool_use_data = start["toolUse"]
+                current_tool = {
+                    "id": tool_use_data.get("toolUseId", ""),
+                    "type": "function",
+                    "function": {
+                        "name": tool_use_data.get("name", ""),
+                        "arguments": "",  # Will be filled in subsequent deltas
+                    },
+                }
+
+        # Handle contentBlockDelta - text content or tool input
+        elif "contentBlockDelta" in response_delta:
+            delta = response_delta["contentBlockDelta"]["delta"]
+            if "text" in delta:
+                model_response.content = delta["text"]
+            elif "toolUse" in delta and current_tool:
+                # Accumulate tool input
+                tool_input = delta["toolUse"].get("input", "")
+                if tool_input:
+                    current_tool["function"]["arguments"] += tool_input
+
+        # Handle contentBlockStop - tool use complete
+        elif "contentBlockStop" in response_delta and current_tool:
+            # Tool is complete, add it to model response
+            model_response.tool_calls = [current_tool]
+            # Track tool_id in extra for format_function_call_results
+            model_response.extra = {"tool_ids": [current_tool["id"]]}
+            # Reset current_tool for next tool
+            current_tool = {}
 
         # Handle metadata/usage information
         elif "metadata" in response_delta or "messageStop" in response_delta:
@@ -740,7 +680,7 @@ class AwsBedrock(Model):
             if "usage" in body:
                 model_response.response_usage = self._get_metrics(body["usage"])
 
-        return model_response
+        return model_response, current_tool
 
     def _get_metrics(self, response_usage: Dict[str, Any]) -> Metrics:
         """

agno/models/openrouter/openrouter.py

@@ -1,8 +1,11 @@
 from dataclasses import dataclass, field
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 from agno.models.openai.like import OpenAILike
+from agno.run.agent import RunOutput
 
 
 @dataclass
@@ -17,6 +20,9 @@ class OpenRouter(OpenAILike):
         api_key (Optional[str]): The API key.
         base_url (str): The base URL. Defaults to "https://openrouter.ai/api/v1".
         max_tokens (int): The maximum number of tokens. Defaults to 1024.
+        fallback_models (Optional[List[str]]): List of fallback model IDs to use if the primary model
+            fails due to rate limits, timeouts, or unavailability. OpenRouter will automatically try
+            these models in order. Example: ["anthropic/claude-sonnet-4", "deepseek/deepseek-r1"]
     """
 
     id: str = "gpt-4o"
@@ -26,3 +32,35 @@ class OpenRouter(OpenAILike):
     api_key: Optional[str] = field(default_factory=lambda: getenv("OPENROUTER_API_KEY"))
     base_url: str = "https://openrouter.ai/api/v1"
     max_tokens: int = 1024
+    models: Optional[List[str]] = None  # Dynamic model routing https://openrouter.ai/docs/features/model-routing
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> Dict[str, Any]:
+        """
+        Returns keyword arguments for API requests, including fallback models configuration.
+
+        Returns:
+            Dict[str, Any]: A dictionary of keyword arguments for API requests.
+        """
+        # Get base request params from parent class
+        request_params = super().get_request_params(
+            response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+        )
+
+        # Add fallback models to extra_body if specified
+        if self.models:
+            # Get existing extra_body or create new dict
+            extra_body = request_params.get("extra_body") or {}
+
+            # Merge fallback models into extra_body
+            extra_body["models"] = self.models
+
+            # Update request params
+            request_params["extra_body"] = extra_body
+
+        return request_params

agno/models/vertexai/claude.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.models.anthropic import Claude as AnthropicClaude
+
+try:
+    from anthropic import AnthropicVertex as AnthropicClient
+    from anthropic import (
+        AsyncAnthropicVertex as AsyncAnthropicClient,
+    )
+except ImportError as e:
+    raise ImportError("`anthropic` not installed. Please install it with `pip install anthropic`") from e
+
+
+@dataclass
+class Claude(AnthropicClaude):
+    """
+    A class representing Anthropic Claude model.
+
+    For more information, see: https://docs.anthropic.com/en/api/messages
+    """
+
+    id: str = "claude-sonnet-4@20250514"
+    name: str = "Claude"
+    provider: str = "VertexAI"
+
+    # Client parameters
+    region: Optional[str] = None
+    project_id: Optional[str] = None
+    base_url: Optional[str] = None
+
+    # Anthropic clients
+    client: Optional[AnthropicClient] = None
+    async_client: Optional[AsyncAnthropicClient] = None
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        client_params: Dict[str, Any] = {}
+
+        # Add API key to client parameters
+        client_params["region"] = self.region or getenv("CLOUD_ML_REGION")
+        client_params["project_id"] = self.project_id or getenv("ANTHROPIC_VERTEX_PROJECT_ID")
+        client_params["base_url"] = self.base_url or getenv("ANTHROPIC_VERTEX_BASE_URL")
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
+        # Add additional client parameters
+        if self.client_params is not None:
+            client_params.update(self.client_params)
+        if self.default_headers is not None:
+            client_params["default_headers"] = self.default_headers
+        return client_params
+
+    def get_client(self) -> AnthropicClient:
+        """
+        Returns an instance of the Anthropic client.
+        """
+        if self.client and not self.client.is_closed():
+            return self.client
+
+        _client_params = self._get_client_params()
+        self.client = AnthropicClient(**_client_params)
+        return self.client
+
+    def get_async_client(self) -> AsyncAnthropicClient:
+        """
+        Returns an instance of the async Anthropic client.
+        """
+        if self.async_client:
+            return self.async_client
+
+        _client_params = self._get_client_params()
+        self.async_client = AsyncAnthropicClient(**_client_params)
+        return self.async_client