chore: Release 2.0.7 (#4679)

# Changelog

## New Features:

- **LlamaCpp Model:** Added a new LlamaCpp Model class

## Improvements:

- **AgentOS CORS Middleware**: AgentOS now automatically merges existing
CORSMiddleware allow_origin lists with what is required for the AgentOS
UI to function.
- **Update create_agent_run and File.valid_mime_types:**
1. Couldn’t get some info about files injected in tools, e.g., filename,
content type, etc. So added it in function create_agent_run.
2.
add `application/json` and `application/vnd.openxmlformats-officedocument.wordprocessingml.document` in
`File.valid_mime_types`

## Bug Fixes:

- **`input_schema` in UI breaking workflows:** for
[[this](https://gist.github.com/ysolanky/54b5361be9908a22f5b93149bd0b7acc)](https://gist.github.com/ysolanky/54b5361be9908a22f5b93149bd0b7acc)
type of workflow config where the steps are not wrapped in `Step`class,
the UI does not show the `input_schema` form for them.
- **Improve functionality of send_media_to_model flag:**
- we currently use the `send_media_to_model` flag for the case where the
input image to agent is to be accessed by a tool and should not be
available to the model.
- In this usecase if we use a tool to generate an image (custom or
DallE) and using a non-multimodal model, so in this case case we append
the tool generated media now as a user message to model, we can also use
the same `send_media_to_model` to decide to not send to model, otherwise
the non multimodal model throws error.

Author: dirkbrnd

cookbook/agent_os/mcp/mcp_tools_advanced_example.py

@@ -4,12 +4,13 @@
 AgentOS handles the lifespan of the MCPTools internally.
 """
 
+from os import getenv
+
 from agno.agent import Agent
 from agno.db.sqlite import SqliteDb
 from agno.models.anthropic import Claude
 from agno.os import AgentOS
 from agno.tools.mcp import MCPTools  # noqa: F401
-from os import getenv
 
 # Setup the database
 db = SqliteDb(db_file="tmp/agentos.db")

libs/agno/agno/knowledge/chunking/semantic.py

@@ -1,5 +1,5 @@
-from typing import Any, Dict, List, Optional
 import inspect
+from typing import Any, Dict, List, Optional
 
 from agno.knowledge.chunking.strategy import ChunkingStrategy
 from agno.knowledge.document.base import Document

libs/agno/agno/models/base.py

@@ -302,7 +302,11 @@ def response(
 
                 if any(msg.images or msg.videos or msg.audio or msg.files for msg in function_call_results):
                     # Handle function call media
-                    self._handle_function_call_media(messages=messages, function_call_results=function_call_results, send_media_to_model=send_media_to_model)
+                    self._handle_function_call_media(
+                        messages=messages,
+                        function_call_results=function_call_results,
+                        send_media_to_model=send_media_to_model,
+                    )
 
                 for function_call_result in function_call_results:
                     function_call_result.log(metrics=True)
@@ -443,7 +447,11 @@ async def aresponse(
 
                 if any(msg.images or msg.videos or msg.audio or msg.files for msg in function_call_results):
                     # Handle function call media
-                    self._handle_function_call_media(messages=messages, function_call_results=function_call_results, send_media_to_model=send_media_to_model)
+                    self._handle_function_call_media(
+                        messages=messages,
+                        function_call_results=function_call_results,
+                        send_media_to_model=send_media_to_model,
+                    )
 
                 for function_call_result in function_call_results:
                     function_call_result.log(metrics=True)
@@ -781,7 +789,11 @@ def response_stream(
 
                 # Handle function call media
                 if any(msg.images or msg.videos or msg.audio for msg in function_call_results):
-                    self._handle_function_call_media(messages=messages, function_call_results=function_call_results, send_media_to_model=send_media_to_model)
+                    self._handle_function_call_media(
+                        messages=messages,
+                        function_call_results=function_call_results,
+                        send_media_to_model=send_media_to_model,
+                    )
 
                 for function_call_result in function_call_results:
                     function_call_result.log(metrics=True)
@@ -941,7 +953,11 @@ async def aresponse_stream(
 
                 # Handle function call media
                 if any(msg.images or msg.videos or msg.audio for msg in function_call_results):
-                    self._handle_function_call_media(messages=messages, function_call_results=function_call_results, send_media_to_model=send_media_to_model)
+                    self._handle_function_call_media(
+                        messages=messages,
+                        function_call_results=function_call_results,
+                        send_media_to_model=send_media_to_model,
+                    )
 
                 for function_call_result in function_call_results:
                     function_call_result.log(metrics=True)
@@ -1718,7 +1734,9 @@ def format_function_call_results(
         if len(function_call_results) > 0:
             messages.extend(function_call_results)
 
-    def _handle_function_call_media(self, messages: List[Message], function_call_results: List[Message], send_media_to_model: bool = True) -> None:
+    def _handle_function_call_media(
+        self, messages: List[Message], function_call_results: List[Message], send_media_to_model: bool = True
+    ) -> None:
         """
         Handle media artifacts from function calls by adding follow-up user messages for generated media if needed.
         """

libs/agno/agno/os/utils.py

@@ -132,7 +132,9 @@ def process_document(file: UploadFile) -> Optional[FileMedia]:
         content = file.file.read()
         if not content:
             raise HTTPException(status_code=400, detail="Empty file")
-        return FileMedia(content=content, filename=file.filename, format=extract_format(file), mime_type=file.content_type)
+        return FileMedia(
+            content=content, filename=file.filename, format=extract_format(file), mime_type=file.content_type
+        )
     except Exception as e:
         logger.error(f"Error processing document {file.filename}: {e}")
         return None

libs/agno/agno/team/team.py

@@ -5090,20 +5090,19 @@ def get_team_history(num_chats: Optional[int] = None) -> str:
             import json
 
             history: List[Dict[str, Any]] = []
-            if session is not None:
-                all_chats = self.get_messages_for_session(session_id=session.session_id)
 
-                if len(all_chats) == 0:
-                    return ""
+            all_chats = session.get_messages_from_last_n_runs(
+                team_id=self.id,
+            )
 
-                for chat in all_chats[::-1]:  # type: ignore
-                    history.insert(0, chat.to_dict())  # type: ignore
+            if len(all_chats) == 0:
+                return ""
 
-                if num_chats is not None:
-                    history = history[:num_chats]
+            for chat in all_chats[::-1]:  # type: ignore
+                history.insert(0, chat.to_dict())  # type: ignore
 
-            else:
-                return ""
+            if num_chats is not None:
+                history = history[:num_chats]
 
             return json.dumps(history)
 

libs/agno/agno/tools/decorator.py

@@ -250,8 +250,10 @@ async def async_gen_wrapper(*args: Any, **kwargs: Any) -> Any:
         if kwargs.get("stop_after_tool_call") is True:
             if "show_result" not in kwargs or kwargs.get("show_result") is None:
                 tool_config["show_result"] = True
-
-        return Function(**tool_config)
+        function = Function(**tool_config)
+        # Determine parameters for the function
+        function.process_entrypoint()
+        return function
 
     # Handle both @tool and @tool() cases
     if len(args) == 1 and callable(args[0]) and not kwargs:

libs/agno/agno/tools/mcp.py

@@ -102,7 +102,7 @@ def __init__(
         transport: Literal["stdio", "sse", "streamable-http"] = "stdio",
         server_params: Optional[Union[StdioServerParameters, SSEClientParams, StreamableHTTPClientParams]] = None,
         session: Optional[ClientSession] = None,
-        timeout_seconds: int = 5,
+        timeout_seconds: int = 10,
         client=None,
         include_tools: Optional[list[str]] = None,
         exclude_tools: Optional[list[str]] = None,

libs/agno/agno/tools/memori.py

@@ -1,7 +1,6 @@
 import json
 from typing import Any, Dict, List, Optional
 
-from agno.agent import Agent
 from agno.tools.toolkit import Toolkit
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 
@@ -122,7 +121,6 @@ def __init__(
 
     def search_memory(
         self,
-        agent: Agent,
         query: str,
         limit: Optional[int] = None,
     ) -> str:
@@ -180,7 +178,7 @@ def search_memory(
             log_error(f"Error searching memory: {e}")
             return json.dumps({"success": False, "error": f"Memory search error: {str(e)}"})
 
-    def record_conversation(self, agent: Agent, content: str) -> str:
+    def record_conversation(self, content: str) -> str:
         """
         Add important information or facts to memory.
 
@@ -222,7 +220,6 @@ def record_conversation(self, agent: Agent, content: str) -> str:
 
     def get_memory_stats(
         self,
-        agent: Agent,
     ) -> str:
         """
         Get statistics about the memory system.
@@ -340,52 +337,3 @@ def disable_memory_system(self) -> bool:
         except Exception as e:
             log_error(f"Failed to disable memory system: {e}")
             return False
-
-
-def create_memori_search_tool(memori_toolkit: MemoriTools):
-    """
-    Create a standalone memory search function for use with Agno agents.
-
-    This is a convenience function that creates a memory search tool similar
-    to the pattern shown in the Memori example code.
-
-    Args:
-        memori_toolkit: An initialized MemoriTools instance
-
-    Returns:
-        Callable: A memory search function that can be used as an agent tool
-
-    Example:
-        ```python
-        memori_tools = MemoriTools(database_connect="sqlite:///memory.db")
-        search_tool = create_memori_search_tool(memori_tools)
-
-        agent = Agent(
-            model=OpenAIChat(),
-            tools=[search_tool],
-            description="Agent with memory search capability"
-        )
-        ```
-    """
-
-    def search_memory(query: str) -> str:
-        """
-        Search the agent's memory for past conversations and information.
-
-        Args:
-            query: What to search for in memory
-
-        Returns:
-            str: Search results or error message
-        """
-        try:
-            if not query.strip():
-                return "Please provide a search query"
-
-            result = memori_toolkit._memory_tool.execute(query=query.strip())
-            return str(result) if result else "No relevant memories found"
-
-        except Exception as e:
-            return f"Memory search error: {str(e)}"
-
-    return search_memory

libs/agno/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agno"
-version = "2.0.6"
+version = "2.0.7"
 description = "Agno: a lightweight library for building Multi-Agent Systems"
 requires-python = ">=3.7,<4"
 readme = "README.md"

libs/agno/tests/integration/agent/test_user_confirmation_flows.py

@@ -218,42 +218,6 @@ def get_the_weather(city: str):
     assert len(session_from_db.runs[0].messages) == 5, [m.role for m in session_from_db.runs[0].messages]
 
 
-@pytest.mark.flaky(reruns=2, reason="Asserting against a generated response makes this flaky")
-def test_tool_call_requires_confirmation_stream(shared_db):
-    @tool(requires_confirmation=True)
-    def get_the_weather(city: str):
-        return f"It is currently 70 degrees and cloudy in {city}"
-
-    agent = Agent(
-        model=OpenAIChat(id="gpt-4o-mini"),
-        tools=[get_the_weather],
-        db=shared_db,
-        markdown=True,
-        telemetry=False,
-    )
-
-    found_confirmation = False
-    for response in agent.run("What is the weather in Tokyo?", stream=True):
-        if response.is_paused:
-            assert response.tools is not None
-            assert response.tools[0].requires_confirmation
-            assert response.tools[0].tool_name == "get_the_weather"
-            assert response.tools[0].tool_args == {"city": "Tokyo"}
-            # Mark the tool as confirmed
-            response.tools[0].confirmed = True
-            found_confirmation = True
-
-    assert found_confirmation, "No tools were found to require confirmation"
-    run_response = agent.get_last_run_output()
-
-    found_confirmation = False
-    for response in agent.continue_run(run_response, stream=True):
-        if response.is_paused:
-            found_confirmation = True
-
-    assert found_confirmation is False, "Some tools still require confirmation"
-
-
 @pytest.mark.asyncio
 async def test_tool_call_requires_confirmation_async(shared_db):
     @tool(requires_confirmation=True)
@@ -282,44 +246,6 @@ async def get_the_weather(city: str):
     assert response.tools[0].result == "It is currently 70 degrees and cloudy in Tokyo"
 
 
-@pytest.mark.asyncio
-@pytest.mark.flaky(reruns=2, reason="Async makes this test flaky")
-async def test_tool_call_requires_confirmation_stream_async(shared_db):
-    @tool(requires_confirmation=True)
-    async def get_the_weather(city: str):
-        return f"It is currently 70 degrees and cloudy in {city}"
-
-    agent = Agent(
-        model=OpenAIChat(id="gpt-4o-mini"),
-        tools=[get_the_weather],
-        db=shared_db,
-        markdown=True,
-        telemetry=False,
-    )
-
-    found_confirmation = False
-    async for response in agent.arun("What is the weather in Tokyo?", stream=True):
-        if response.is_paused:
-            assert response.tools[0].requires_confirmation
-            assert response.tools[0].tool_name == "get_the_weather"
-            assert response.tools[0].tool_args == {"city": "Tokyo"}
-
-            # Mark the tool as confirmed
-            for tool_response in response.tools:
-                if tool_response.requires_confirmation:
-                    tool_response.confirmed = True
-            found_confirmation = True
-    assert found_confirmation, "No tools were found to require confirmation"
-
-    run_response = agent.get_last_run_output()
-
-    found_confirmation = False
-    async for response in agent.acontinue_run(run_response, stream=True):
-        if response.is_paused:
-            found_confirmation = True
-    assert found_confirmation is False, "Some tools still require confirmation"
-
-
 def test_tool_call_multiple_requires_confirmation(shared_db):
     @tool(requires_confirmation=True)
     def get_the_weather(city: str):