[fix] Make models stateless (#3140)

## Summary

Remove state like `response_format` and `tools` from model state to
avoid issues where models are shared between teams/agents.

Fixes #3095 

## Type of change

- [x] Bug fix
- [ ] New feature
- [ ] Breaking change
- [ ] Improvement
- [ ] Model update
- [ ] Other:

---

## Checklist

- [ ] Code complies with style guidelines
- [ ] Ran format/validation scripts (`./scripts/format.sh` and
`./scripts/validate.sh`)
- [ ] Self-review completed
- [ ] Documentation updated (comments, docstrings)
- [ ] Examples and guides: Relevant cookbook examples have been included
or updated (if applicable)
- [ ] Tested in clean environment
- [ ] Tests added/updated (if applicable)

---

## Additional Notes

Add any important context (deployment instructions, screenshots,
security considerations, etc.)

Author: dirkbrnd

cookbook/models/azure/ai_foundry/async_tool_use.py

@@ -15,10 +15,7 @@
     tools=[DuckDuckGoTools()],
     show_tool_calls=True,
     markdown=True,
+    debug_mode=True,
 )
 
-response: RunResponse = asyncio.run(agent.arun("Whats happening in France?"))
-
-print(response.content)
-print()
-print(response.metrics)
+asyncio.run(agent.aprint_response("Whats happening in France?"))

cookbook/models/azure/ai_foundry/structured_output.py

@@ -26,7 +26,7 @@ class MovieScript(BaseModel):
 
 
 agent = Agent(
-    model=AzureAIFoundry(id="Phi-4"),
+    model=AzureAIFoundry(id="gpt-4o"),
     description="You help people write movie scripts.",
     response_model=MovieScript,
     # debug_mode=True,

cookbook/models/ollama/tool_use.py

@@ -5,7 +5,7 @@
 from agno.tools.duckduckgo import DuckDuckGoTools
 
 agent = Agent(
-    model=Ollama(id="llama3.1:8b"),
+    model=Ollama(id="llama3.2:latest"),
     tools=[DuckDuckGoTools()],
     show_tool_calls=True,
     markdown=True,

cookbook/models/ollama/tool_use_stream.py

@@ -5,7 +5,7 @@
 from agno.tools.duckduckgo import DuckDuckGoTools
 
 agent = Agent(
-    model=Ollama(id="llama3.1:8b"),
+    model=Ollama(id="llama3.2:latest"),
     tools=[DuckDuckGoTools()],
     show_tool_calls=True,
     markdown=True,

cookbook/models/ollama_tools/tool_use.py

@@ -5,7 +5,7 @@
 from agno.tools.duckduckgo import DuckDuckGoTools
 
 agent = Agent(
-    model=OllamaTools(id="llama3.1:8b"),
+    model=OllamaTools(id="llama3.2:latest"),
     tools=[DuckDuckGoTools()],
     show_tool_calls=True,
     markdown=True,

libs/agno/agno/agent/agent.py

@@ -40,10 +40,7 @@ def update_model(self) -> None:
                 exit(1)
             self.model = OpenAIChat(id="gpt-4o")
 
-        # Add tools to the Model
-        self.add_tools_to_model(model=self.model)
-
-    def add_tools_to_model(self, model: Model) -> None:
+    def determine_tools_for_model(self) -> None:
         if self._tools_for_model is None:
             self._tools_for_model = []
         if self._functions_for_model is None:
@@ -64,10 +61,6 @@ def add_tools_to_model(self, model: Model) -> None:
                     log_debug(f"Added function {func.name}")
             except Exception as e:
                 logger.warning(f"Could not add function {tool}: {e}")
-        # Set tools on the model
-        model.set_tools(tools=self._tools_for_model)
-        # Set functions on the model
-        model.set_functions(functions=self._functions_for_model)
 
     def get_existing_memories(self) -> Optional[List[MemoryRow]]:
         if self.db is None:
@@ -175,6 +168,7 @@ def run(
 
         # Update the Model (set defaults, add logit etc.)
         self.update_model()
+        self.determine_tools_for_model()
 
         # Prepare the List of messages to send to the Model
         messages_for_model: List[Message] = [self.get_system_message()]
@@ -189,7 +183,9 @@ def run(
 
         # Generate a response from the Model (includes running function calls)
         self.model = cast(Model, self.model)
-        response = self.model.response(messages=messages_for_model)
+        response = self.model.response(
+            messages=messages_for_model, tools=self._tools_for_model, functions=self._functions_for_model
+        )
         log_debug("*********** MemoryManager End ***********")
         return response.content
 
@@ -215,6 +211,8 @@ async def arun(
 
         # Generate a response from the Model (includes running function calls)
         self.model = cast(Model, self.model)
-        response = await self.model.aresponse(messages=messages_for_model)
+        response = await self.model.aresponse(
+            messages=messages_for_model, tools=self._tools_for_model, functions=self._functions_for_model
+        )
         log_debug("*********** Async MemoryManager End ***********")
         return response.content

libs/agno/agno/memory/manager.py

@@ -26,13 +26,6 @@ def update_model(self) -> None:
                 exit(1)
             self.model = OpenAIChat(id="gpt-4o")
 
-        # Set response_format if it is not set on the Model
-        if self.use_structured_outputs:
-            self.model.response_format = SessionSummary
-            self.model.structured_outputs = True
-        else:
-            self.model.response_format = {"type": "json_object"}
-
     def get_system_message(self, messages_for_summarization: List[Dict[str, str]]) -> Message:
         # -*- Return a system message for summarization
         system_prompt = dedent("""\
@@ -95,6 +88,12 @@ def run(
         # Update the Model (set defaults, add logit etc.)
         self.update_model()
 
+        # Set response_format if it is not set on the Model
+        if self.use_structured_outputs:
+            response_format: Any = SessionSummary
+        else:
+            response_format = {"type": "json_object"}
+
         # Convert the message pairs to a list of dictionaries
         messages_for_summarization: List[Dict[str, str]] = []
         for message_pair in message_pairs:
@@ -115,7 +114,7 @@ def run(
 
         # Generate a response from the Model (includes running function calls)
         self.model = cast(Model, self.model)
-        response = self.model.response(messages=messages_for_model)
+        response = self.model.response(messages=messages_for_model, response_format=response_format)
         log_debug("*********** MemorySummarizer End ***********")
 
         # If the model natively supports structured outputs, the parsed value is already in the structured format

libs/agno/agno/memory/summarizer.py

@@ -1,7 +1,7 @@
 from copy import deepcopy
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import Any, Callable, Dict, List, Optional, cast
+from typing import Any, Callable, Dict, List, Optional
 
 from agno.memory.v2.db.base import MemoryDb
 from agno.memory.v2.db.schema import MemoryRow
@@ -44,30 +44,25 @@ def __init__(
         self.system_message = system_message
         self.memory_capture_instructions = memory_capture_instructions
         self.additional_instructions = additional_instructions
-
-    def add_tools_to_model(self, model: Model, tools: List[Callable]) -> None:
-        model = cast(Model, model)
-        model.reset_tools_and_functions()
-
-        _tools_for_model = []
-        _functions_for_model = {}
-
-        for tool in tools:
-            try:
-                function_name = tool.__name__
-                if function_name not in _functions_for_model:
-                    func = Function.from_callable(tool, strict=True)  # type: ignore
-                    func.strict = True
-                    _functions_for_model[func.name] = func
-                    _tools_for_model.append({"type": "function", "function": func.to_dict()})
-                    log_debug(f"Added function {func.name}")
-            except Exception as e:
-                log_warning(f"Could not add function {tool}: {e}")
-
-        # Set tools on the model
-        model.set_tools(tools=_tools_for_model)
-        # Set functions on the model
-        model.set_functions(functions=_functions_for_model)
+        self._tools_for_model: Optional[List[Dict[str, Any]]] = None
+        self._functions_for_model: Optional[Dict[str, Function]] = None
+
+    def determine_tools_for_model(self, tools: List[Callable]) -> None:
+        if self._tools_for_model is None:
+            self._tools_for_model = []
+            self._functions_for_model = {}
+
+            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}")
+                except Exception as e:
+                    log_warning(f"Could not add function {tool}: {e}")
 
     def get_system_message(
         self,
@@ -166,8 +161,7 @@ def create_or_update_memories(
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.add_tools_to_model(
-            model_copy,
+        self.determine_tools_for_model(
             self._get_db_tools(
                 user_id, db, input_string, enable_delete_memory=delete_memories, enable_clear_memory=clear_memories
             ),
@@ -184,7 +178,9 @@ def create_or_update_memories(
         ]
 
         # Generate a response from the Model (includes running function calls)
-        response = model_copy.response(messages=messages_for_model)
+        response = model_copy.response(
+            messages=messages_for_model, tools=self._tools_for_model, functions=self._functions_for_model
+        )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
             self.memories_updated = True
@@ -214,8 +210,7 @@ async def acreate_or_update_memories(
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.add_tools_to_model(
-            model_copy,
+        self.determine_tools_for_model(
             self._get_db_tools(
                 user_id, db, input_string, enable_delete_memory=delete_memories, enable_clear_memory=clear_memories
             ),
@@ -232,7 +227,9 @@ async def acreate_or_update_memories(
         ]
 
         # Generate a response from the Model (includes running function calls)
-        response = await model_copy.aresponse(messages=messages_for_model)
+        response = await model_copy.aresponse(
+            messages=messages_for_model, tools=self._tools_for_model, functions=self._functions_for_model
+        )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
             self.memories_updated = True
@@ -257,8 +254,7 @@ def run_memory_task(
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.add_tools_to_model(
-            model_copy,
+        self.determine_tools_for_model(
             self._get_db_tools(
                 user_id, db, task, enable_delete_memory=delete_memories, enable_clear_memory=clear_memories
             ),
@@ -274,7 +270,9 @@ def run_memory_task(
         ]
 
         # Generate a response from the Model (includes running function calls)
-        response = model_copy.response(messages=messages_for_model)
+        response = model_copy.response(
+            messages=messages_for_model, tools=self._tools_for_model, functions=self._functions_for_model
+        )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
             self.memories_updated = True
@@ -299,8 +297,7 @@ async def arun_memory_task(
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self.add_tools_to_model(
-            model_copy,
+        self.determine_tools_for_model(
             self._get_db_tools(
                 user_id, db, task, enable_delete_memory=delete_memories, enable_clear_memory=clear_memories
             ),
@@ -316,7 +313,9 @@ async def arun_memory_task(
         ]
 
         # Generate a response from the Model (includes running function calls)
-        response = await model_copy.aresponse(messages=messages_for_model)
+        response = await model_copy.aresponse(
+            messages=messages_for_model, tools=self._tools_for_model, functions=self._functions_for_model
+        )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
             self.memories_updated = True

libs/agno/agno/memory/v2/manager.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass, field
 from datetime import datetime
 from os import getenv
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Type, Union
 
 from pydantic import BaseModel, Field
 
@@ -789,24 +789,21 @@ def search_user_memories(
         else:  # Default to last_n
             return self._get_last_n_memories(user_id=user_id, limit=limit)
 
-    def _update_model_for_agentic_search(self) -> None:
+    def get_response_format(self) -> Union[Dict[str, Any], Type[BaseModel]]:
         model = self.get_model()
         if model.supports_native_structured_outputs:
-            model.response_format = MemorySearchResponse
-            model.structured_outputs = True
+            return MemorySearchResponse
 
         elif model.supports_json_schema_outputs:
-            model.response_format = {
+            return {
                 "type": "json_schema",
                 "json_schema": {
                     "name": MemorySearchResponse.__name__,
                     "schema": MemorySearchResponse.model_json_schema(),
                 },
             }
-            model.structured_outputs = False
         else:
-            model.response_format = {"type": "json_object"}
-            model.structured_outputs = False
+            return {"type": "json_object"}
 
     def _search_user_memories_agentic(self, user_id: str, query: str, limit: Optional[int] = None) -> List[UserMemory]:
         """Search through user memories using agentic search."""
@@ -815,7 +812,7 @@ def _search_user_memories_agentic(self, user_id: str, query: str, limit: Optiona
 
         model = self.get_model()
 
-        self._update_model_for_agentic_search()
+        response_format = self.get_response_format()
 
         log_debug("Searching for memories", center=True)
 
@@ -833,7 +830,7 @@ def _search_user_memories_agentic(self, user_id: str, query: str, limit: Optiona
         system_message_str += "\n</user_memories>\n\n"
         system_message_str += "REMEMBER: Only return the IDs of the memories that are related to the query."
 
-        if model.response_format == {"type": "json_object"}:
+        if response_format == {"type": "json_object"}:
             system_message_str += "\n" + get_json_output_prompt(MemorySearchResponse)  # type: ignore
 
         messages_for_model = [
@@ -845,7 +842,7 @@ def _search_user_memories_agentic(self, user_id: str, query: str, limit: Optiona
         ]
 
         # Generate a response from the Model (includes running function calls)
-        response = model.response(messages=messages_for_model)
+        response = model.response(messages=messages_for_model, response_format=response_format)
         log_debug("Search for memories complete", center=True)
 
         memory_search: Optional[MemorySearchResponse] = None