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

agno/os/interfaces/agui/router.py

@@ -34,12 +34,18 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
         messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
+        # Look for user_id in run_input.forwarded_props
+        user_id = None
+        if run_input.forwarded_props and isinstance(run_input.forwarded_props, dict):
+            user_id = run_input.forwarded_props.get("user_id")
+
         # Request streaming response from agent
         response_stream = agent.arun(
             input=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
+            user_id=user_id,
         )
 
         # Stream the response content in AG-UI format
@@ -64,12 +70,18 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         messages = convert_agui_messages_to_agno_messages(input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
 
+        # Look for user_id in input.forwarded_props
+        user_id = None
+        if input.forwarded_props and isinstance(input.forwarded_props, dict):
+            user_id = input.forwarded_props.get("user_id")
+
         # Request streaming response from team
         response_stream = team.arun(
             input=messages,
             session_id=input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
+            user_id=user_id,
         )
 
         # Stream the response content in AG-UI format

agno/os/mcp.py

@@ -78,21 +78,21 @@ def get_mcp_server(
         agent = get_agent_by_id(agent_id, os.agents)
         if agent is None:
             raise Exception(f"Agent {agent_id} not found")
-        return agent.run(message)
+        return await agent.arun(message)
 
     @mcp.tool(name="run_team", description="Run a team", tags={"core"})  # type: ignore
     async def run_team(team_id: str, message: str) -> TeamRunOutput:
         team = get_team_by_id(team_id, os.teams)
         if team is None:
             raise Exception(f"Team {team_id} not found")
-        return team.run(message)
+        return await team.arun(message)
 
     @mcp.tool(name="run_workflow", description="Run a workflow", tags={"core"})  # type: ignore
     async def run_workflow(workflow_id: str, message: str) -> WorkflowRunOutput:
         workflow = get_workflow_by_id(workflow_id, os.workflows)
         if workflow is None:
             raise Exception(f"Workflow {workflow_id} not found")
-        return workflow.run(message)
+        return await workflow.arun(message)
 
     # Session Management Tools
     @mcp.tool(name="get_sessions_for_agent", description="Get list of sessions for an agent", tags={"session"})  # type: ignore

agno/os/router.py

@@ -1,4 +1,5 @@
 import json
+from itertools import chain
 from typing import TYPE_CHECKING, Any, AsyncGenerator, Callable, Dict, List, Optional, Union, cast
 from uuid import uuid4
 
@@ -643,7 +644,7 @@ def get_base_router(
             os_id=os.id or "Unnamed OS",
             description=os.description,
             available_models=os.config.available_models if os.config else [],
-            databases=[db.id for db in os.dbs.values()],
+            databases=list({db.id for db in chain(os.dbs.values(), os.knowledge_dbs.values())}),
             chat=os.config.chat if os.config else None,
             session=os._get_session_config(),
             memory=os._get_memory_config(),
@@ -784,19 +785,39 @@ def get_base_router(
 
         if files:
             for file in files:
-                if file.content_type in ["image/png", "image/jpeg", "image/jpg", "image/webp"]:
+                if file.content_type in [
+                    "image/png",
+                    "image/jpeg",
+                    "image/jpg",
+                    "image/gif",
+                    "image/webp",
+                    "image/bmp",
+                    "image/tiff",
+                    "image/tif",
+                    "image/avif",
+                ]:
                     try:
                         base64_image = process_image(file)
                         base64_images.append(base64_image)
                     except Exception as e:
                         log_error(f"Error processing image {file.filename}: {e}")
                         continue
-                elif file.content_type in ["audio/wav", "audio/mp3", "audio/mpeg"]:
+                elif file.content_type in [
+                    "audio/wav",
+                    "audio/wave",
+                    "audio/mp3",
+                    "audio/mpeg",
+                    "audio/ogg",
+                    "audio/mp4",
+                    "audio/m4a",
+                    "audio/aac",
+                    "audio/flac",
+                ]:
                     try:
-                        base64_audio = process_audio(file)
-                        base64_audios.append(base64_audio)
+                        audio = process_audio(file)
+                        base64_audios.append(audio)
                     except Exception as e:
-                        log_error(f"Error processing audio {file.filename}: {e}")
+                        log_error(f"Error processing audio {file.filename} with content type {file.content_type}: {e}")
                         continue
                 elif file.content_type in [
                     "video/x-flv",
@@ -819,10 +840,19 @@ def get_base_router(
                         continue
                 elif file.content_type in [
                     "application/pdf",
-                    "text/csv",
+                    "application/json",
+                    "application/x-javascript",
                     "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                    "text/javascript",
+                    "application/x-python",
+                    "text/x-python",
                     "text/plain",
-                    "application/json",
+                    "text/html",
+                    "text/css",
+                    "text/md",
+                    "text/csv",
+                    "text/xml",
+                    "text/rtf",
                 ]:
                     # Process document files
                     try:

agno/os/routers/memory/memory.py

@@ -120,10 +120,11 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
     )
     async def delete_memory(
         memory_id: str = Path(description="Memory ID to delete"),
+        user_id: Optional[str] = Query(default=None, description="User ID to delete memory for"),
         db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
     ) -> None:
         db = get_db(dbs, db_id)
-        db.delete_user_memory(memory_id=memory_id)
+        db.delete_user_memory(memory_id=memory_id, user_id=user_id)
 
     @router.delete(
         "/memories",
@@ -145,7 +146,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
     ) -> None:
         db = get_db(dbs, db_id)
-        db.delete_user_memories(memory_ids=request.memory_ids)
+        db.delete_user_memories(memory_ids=request.memory_ids, user_id=request.user_id)
 
     @router.get(
         "/memories",
@@ -249,10 +250,11 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
     )
     async def get_memory(
         memory_id: str = Path(description="Memory ID to retrieve"),
+        user_id: Optional[str] = Query(default=None, description="User ID to query memory for"),
         db_id: Optional[str] = Query(default=None, description="Database ID to query memory from"),
     ) -> UserMemorySchema:
         db = get_db(dbs, db_id)
-        user_memory = db.get_user_memory(memory_id=memory_id, deserialize=False)
+        user_memory = db.get_user_memory(memory_id=memory_id, user_id=user_id, deserialize=False)
         if not user_memory:
             raise HTTPException(status_code=404, detail=f"Memory with ID {memory_id} not found")
 

agno/os/routers/memory/schemas.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 
 class DeleteMemoriesRequest(BaseModel):
     memory_ids: List[str]
+    user_id: Optional[str] = None
 
 
 class UserMemorySchema(BaseModel):

agno/os/utils.py

@@ -93,18 +93,41 @@ def get_session_name(session: Dict[str, Any]) -> str:
 
         # For teams, identify the first Team run and avoid using the first member's run
         if session.get("session_type") == "team":
-            run = runs[0] if not runs[0].get("agent_id") else runs[1]
+            run = None
+            for r in runs:
+                # If agent_id is not present, it's a team run
+                if not r.get("agent_id"):
+                    run = r
+                    break
+            # Fallback to first run if no team run found
+            if run is None and runs:
+                run = runs[0]
 
-        # For workflows, pass along the first step_executor_run
         elif session.get("session_type") == "workflow":
             try:
-                run = session["runs"][0]["step_executor_runs"][0]
+                workflow_run = runs[0]
+                workflow_input = workflow_run.get("input")
+                if isinstance(workflow_input, str):
+                    return workflow_input
+                elif isinstance(workflow_input, dict):
+                    try:
+                        import json
+
+                        return json.dumps(workflow_input)
+                    except (TypeError, ValueError):
+                        pass
+
+                workflow_name = session.get("workflow_data", {}).get("name")
+                return f"New {workflow_name} Session" if workflow_name else ""
             except (KeyError, IndexError, TypeError):
                 return ""
 
         # For agents, use the first run
         else:
-            run = runs[0]
+            run = runs[0] if runs else None
+
+        if run is None:
+            return ""
 
         if not isinstance(run, dict):
             run = run.to_dict()
@@ -150,13 +173,17 @@ def process_document(file: UploadFile) -> Optional[FileMedia]:
         return None
 
 
-def extract_format(file: UploadFile):
-    _format = None
+def extract_format(file: UploadFile) -> Optional[str]:
+    """Extract the File format from file name or content_type."""
+    # Get the format from the filename
     if file.filename and "." in file.filename:
-        _format = file.filename.split(".")[-1].lower()
-    elif file.content_type:
-        _format = file.content_type.split("/")[-1]
-    return _format
+        return file.filename.split(".")[-1].lower()
+
+    # Fallback to the file content_type
+    if file.content_type:
+        return file.content_type.strip().split("/")[-1]
+
+    return None
 
 
 def format_tools(agent_tools: List[Union[Dict[str, Any], Toolkit, Function, Callable]]):

agno/team/team.py

@@ -4035,6 +4035,12 @@ class Team:
                         log_warning("Reasoning error. Reasoning response is empty, continuing regular session...")
                         break
 
+                    if isinstance(reasoning_agent_response.content, str):
+                        log_warning(
+                            "Reasoning error. Content is a string, not structured output. Continuing regular session..."
+                        )
+                        break
+
                     if reasoning_agent_response.content.reasoning_steps is None:
                         log_warning("Reasoning error. Reasoning steps are empty, continuing regular session...")
                         break
@@ -4261,6 +4267,12 @@ class Team:
                         log_warning("Reasoning error. Reasoning response is empty, continuing regular session...")
                         break
 
+                    if isinstance(reasoning_agent_response.content, str):
+                        log_warning(
+                            "Reasoning error. Content is a string, not structured output. Continuing regular session..."
+                        )
+                        break
+
                     if reasoning_agent_response.content.reasoning_steps is None:
                         log_warning("Reasoning error. Reasoning steps are empty, continuing regular session...")
                         break

agno/tools/file.py

@@ -75,7 +75,9 @@ class FileTools(Toolkit):
         """
         try:
             log_info(f"Reading files in : {self.base_dir}")
-            return json.dumps([str(file_path) for file_path in self.base_dir.iterdir()], indent=4)
+            return json.dumps(
+                [str(file_path.relative_to(self.base_dir)) for file_path in self.base_dir.iterdir()], indent=4
+            )
         except Exception as e:
             log_error(f"Error reading files: {e}")
             return f"Error reading files: {e}"
@@ -93,7 +95,7 @@ class FileTools(Toolkit):
             log_debug(f"Searching files in {self.base_dir} with pattern {pattern}")
             matching_files = list(self.base_dir.glob(pattern))
 
-            file_paths = [str(file_path) for file_path in matching_files]
+            file_paths = [str(file_path.relative_to(self.base_dir)) for file_path in matching_files]
 
             result = {
                 "pattern": pattern,

agno/tools/mcp.py

@@ -22,6 +22,8 @@ except (ImportError, ModuleNotFoundError):
 
 def _prepare_command(command: str) -> list[str]:
     """Sanitize a command and split it into parts before using it to run a MCP server."""
+    import os
+    import shutil
     from shlex import split
 
     # Block dangerous characters
@@ -55,10 +57,53 @@ def _prepare_command(command: str) -> list[str]:
     }
 
     executable = parts[0].split("/")[-1]
+
+    # Check if it's a relative path starting with ./ or ../
+    if executable.startswith("./") or executable.startswith("../"):
+        # Allow relative paths to binaries
+        return parts
+
+    # Check if it's an absolute path to a binary
+    if executable.startswith("/") and os.path.isfile(executable):
+        # Allow absolute paths to existing files
+        return parts
+
+    # Check if it's a binary in current directory without ./
+    if "/" not in executable and os.path.isfile(executable):
+        # Allow binaries in current directory
+        return parts
+
+    # Check if it's a binary in PATH
+    if shutil.which(executable):
+        return parts
+
     if executable not in ALLOWED_COMMANDS:
         raise ValueError(f"MCP command needs to use one of the following executables: {ALLOWED_COMMANDS}")
 
-    return parts
+    first_part = parts[0]
+    executable = first_part.split("/")[-1]
+
+    # Allow known commands
+    if executable in ALLOWED_COMMANDS:
+        return parts
+
+    # Allow relative paths to custom binaries
+    if first_part.startswith(("./", "../")):
+        return parts
+
+    # Allow absolute paths to existing files
+    if first_part.startswith("/") and os.path.isfile(first_part):
+        return parts
+
+    # Allow binaries in current directory without ./
+    if "/" not in first_part and os.path.isfile(first_part):
+        return parts
+
+    # Allow binaries in PATH
+    if shutil.which(first_part):
+        return parts
+
+    raise ValueError(f"MCP command needs to use one of the following executables: {ALLOWED_COMMANDS}")
 
 
 @dataclass

agno/utils/merge_dict.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, List
 
 
 def merge_dictionaries(a: Dict[str, Any], b: Dict[str, Any]) -> None:
@@ -18,3 +18,24 @@ def merge_dictionaries(a: Dict[str, Any], b: Dict[str, Any]) -> None:
             merge_dictionaries(a[key], b[key])
         else:
             a[key] = b[key]
+
+
+def merge_parallel_session_states(original_state: Dict[str, Any], modified_states: List[Dict[str, Any]]) -> None:
+    """
+    Smart merge for parallel session states that only applies actual changes.
+    This prevents parallel steps from overwriting each other's changes.
+    """
+    if not original_state or not modified_states:
+        return
+
+    # Collect all actual changes (keys where value differs from original)
+    all_changes = {}
+    for modified_state in modified_states:
+        if modified_state:
+            for key, value in modified_state.items():
+                if key not in original_state or original_state[key] != value:
+                    all_changes[key] = value
+
+    # Apply all collected changes to the original state
+    for key, value in all_changes.items():
+        original_state[key] = value

agno/utils/streamlit.py

@@ -452,7 +452,7 @@ MODELS = [
     "gpt-4o",
     "o3-mini",
     "gpt-5",
-    "claude-4-sonnet",
+    "claude-sonnet-4-5-20250929",
     "gemini-2.5-pro",
 ]