agno 2.2.0__py3-none-any.whl → 2.2.2__py3-none-any.whl

agno/memory/manager.py

@@ -89,8 +89,6 @@ class MemoryManager:
         self.add_memories = add_memories
         self.clear_memories = clear_memories
         self.debug_mode = debug_mode
-        self._tools_for_model: Optional[List[Dict[str, Any]]] = None
-        self._functions_for_model: Optional[Dict[str, Function]] = None
 
     def get_model(self) -> Model:
         if self.model is None:
@@ -710,23 +708,26 @@ class MemoryManager:
         return sorted_memories_list
 
     # --Memory Manager Functions--
-    def determine_tools_for_model(self, tools: List[Callable]) -> None:
+    def determine_tools_for_model(self, tools: List[Callable]) -> List[Union[Function, dict]]:
         # Have to reset each time, because of different user IDs
-        self._tools_for_model = []
-        self._functions_for_model = {}
+        _function_names = []
+        _functions: List[Union[Function, dict]] = []
 
         for tool in tools:
             try:
                 function_name = tool.__name__
-                if function_name not in self._functions_for_model:
-                    func = Function.from_callable(tool, strict=True)  # type: ignore
-                    func.strict = True
-                    self._functions_for_model[func.name] = func
-                    self._tools_for_model.append({"type": "function", "function": func.to_dict()})
-                    log_debug(f"Added function {func.name}")
+                if function_name in _function_names:
+                    continue
+                _function_names.append(function_name)
+                func = Function.from_callable(tool, strict=True)  # type: ignore
+                func.strict = True
+                _functions.append(func)
+                log_debug(f"Added function {func.name}")
             except Exception as e:
                 log_warning(f"Could not add function {tool}: {e}")
 
+        return _functions
+
     def get_system_message(
         self,
         existing_memories: Optional[List[Dict[str, Any]]] = None,
@@ -833,7 +834,7 @@ class MemoryManager:
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.determine_tools_for_model(
+        _tools = self.determine_tools_for_model(
             self._get_db_tools(
                 user_id,
                 db,
@@ -862,8 +863,7 @@ class MemoryManager:
         # Generate a response from the Model (includes running function calls)
         response = model_copy.response(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -897,7 +897,7 @@ class MemoryManager:
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
         if isinstance(db, AsyncBaseDb):
-            self.determine_tools_for_model(
+            _tools = self.determine_tools_for_model(
                 await self._aget_db_tools(
                     user_id,
                     db,
@@ -911,7 +911,7 @@ class MemoryManager:
                 ),
             )
         else:
-            self.determine_tools_for_model(
+            _tools = self.determine_tools_for_model(
                 self._get_db_tools(
                     user_id,
                     db,
@@ -940,8 +940,7 @@ class MemoryManager:
         # Generate a response from the Model (includes running function calls)
         response = await model_copy.aresponse(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -969,7 +968,7 @@ class MemoryManager:
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.determine_tools_for_model(
+        _tools = self.determine_tools_for_model(
             self._get_db_tools(
                 user_id,
                 db,
@@ -997,8 +996,7 @@ class MemoryManager:
         # Generate a response from the Model (includes running function calls)
         response = model_copy.response(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -1027,7 +1025,7 @@ class MemoryManager:
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
         if isinstance(db, AsyncBaseDb):
-            self.determine_tools_for_model(
+            _tools = self.determine_tools_for_model(
                 await self._aget_db_tools(
                     user_id,
                     db,
@@ -1039,7 +1037,7 @@ class MemoryManager:
                 ),
             )
         else:
-            self.determine_tools_for_model(
+            _tools = self.determine_tools_for_model(
                 self._get_db_tools(
                     user_id,
                     db,
@@ -1067,8 +1065,7 @@ class MemoryManager:
         # Generate a response from the Model (includes running function calls)
         response = await model_copy.aresponse(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -1132,6 +1129,9 @@ class MemoryManager:
             """
             from agno.db.base import UserMemory
 
+            if memory == "":
+                return "Can't update memory with empty string. Use the delete memory function if available."
+
             try:
                 db.upsert_user_memory(
                     UserMemory(
@@ -1251,6 +1251,9 @@ class MemoryManager:
             """
             from agno.db.base import UserMemory
 
+            if memory == "":
+                return "Can't update memory with empty string. Use the delete memory function if available."
+
             try:
                 if isinstance(db, AsyncBaseDb):
                     await db.upsert_user_memory(

agno/models/anthropic/claude.py

@@ -86,6 +86,12 @@ class Claude(Model):
     request_params: Optional[Dict[str, Any]] = None
     mcp_servers: Optional[List[MCPServerConfiguration]] = None
 
+    # Skills configuration
+    skills: Optional[List[Dict[str, str]]] = (
+        None  # e.g., [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
+    )
+    betas: Optional[List[str]] = None  # Enables specific experimental or newly released features.
+
     # Client parameters
     api_key: Optional[str] = None
     default_headers: Optional[Dict[str, Any]] = None
@@ -101,6 +107,9 @@ class Claude(Model):
         # Validate thinking support immediately at model creation
         if self.thinking:
             self._validate_thinking_support()
+        # Set up skills configuration if skills are enabled
+        if self.skills:
+            self._setup_skills_configuration()
 
     def _get_client_params(self) -> Dict[str, Any]:
         client_params: Dict[str, Any] = {}
@@ -159,6 +168,26 @@ class Claude(Model):
                 f"For more information, see: https://docs.anthropic.com/en/docs/about-claude/models/overview"
             )
 
+    def _setup_skills_configuration(self) -> None:
+        """
+        Set up configuration for Claude Agent Skills.
+        Automatically configures betas array with required values.
+
+        Skills enable document creation capabilities (PowerPoint, Excel, Word, PDF).
+        For more information, see: https://docs.claude.com/en/docs/agents-and-tools/agent-skills/quickstart
+        """
+        # Required betas for skills
+        required_betas = ["code-execution-2025-08-25", "skills-2025-10-02"]
+
+        # Initialize or merge betas
+        if self.betas is None:
+            self.betas = required_betas
+        else:
+            # Add required betas if not present
+            for beta in required_betas:
+                if beta not in self.betas:
+                    self.betas.append(beta)
+
     def get_request_params(self) -> Dict[str, Any]:
         """
         Generate keyword arguments for API requests.
@@ -184,6 +213,9 @@ class Claude(Model):
             _request_params["mcp_servers"] = [
                 {k: v for k, v in asdict(server).items() if v is not None} for server in self.mcp_servers
             ]
+        if self.skills:
+            _request_params["betas"] = self.betas
+            _request_params["container"] = {"skills": self.skills}
         if self.request_params:
             _request_params.update(self.request_params)
 
@@ -213,6 +245,15 @@ class Claude(Model):
             else:
                 request_kwargs["system"] = [{"text": system_message, "type": "text"}]
 
+        # Add code execution tool if skills are enabled
+        if self.skills:
+            code_execution_tool = {"type": "code_execution_20250825", "name": "code_execution"}
+            if tools:
+                # Add code_execution to existing tools, code execution is needed for generating and processing files
+                tools = tools + [code_execution_tool]
+            else:
+                tools = [code_execution_tool]
+
         if tools:
             request_kwargs["tools"] = format_tools_for_model(tools)
 
@@ -239,12 +280,12 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None:
+            if self.mcp_servers is not None or self.skills is not None:
                 assistant_message.metrics.start_timer()
                 provider_response = self.get_client().beta.messages.create(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
-                    **self.get_request_params(),
+                    **request_kwargs,
                 )
             else:
                 assistant_message.metrics.start_timer()
@@ -306,7 +347,7 @@ class Claude(Model):
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
-            if self.mcp_servers is not None:
+            if self.mcp_servers is not None or self.skills is not None:
                 assistant_message.metrics.start_timer()
                 with self.get_client().beta.messages.stream(
                     model=self.id,
@@ -361,12 +402,12 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None:
+            if self.mcp_servers is not None or self.skills is not None:
                 assistant_message.metrics.start_timer()
                 provider_response = await self.get_async_client().beta.messages.create(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
-                    **self.get_request_params(),
+                    **request_kwargs,
                 )
             else:
                 assistant_message.metrics.start_timer()
@@ -425,7 +466,7 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None:
+            if self.mcp_servers is not None or self.skills is not None:
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
@@ -542,6 +583,22 @@ class Claude(Model):
         if response.usage is not None:
             model_response.response_usage = self._get_metrics(response.usage)
 
+        # Extract file IDs if skills are enabled
+        if self.skills and response.content:
+            file_ids: List[str] = []
+            for block in response.content:
+                if block.type == "bash_code_execution_tool_result":
+                    if hasattr(block, "content") and hasattr(block.content, "content"):
+                        if isinstance(block.content.content, list):
+                            for output_block in block.content.content:
+                                if hasattr(output_block, "file_id"):
+                                    file_ids.append(output_block.file_id)
+
+            if file_ids:
+                if model_response.provider_data is None:
+                    model_response.provider_data = {}
+                model_response.provider_data["file_ids"] = file_ids
+
         return model_response
 
     def _parse_provider_response_delta(