agno 2.1.1__py3-none-any.whl → 2.1.2__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/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,40 @@ 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 +172,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/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",
 ]
 

agno/workflow/parallel.py

@@ -1,5 +1,6 @@
 import asyncio
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Iterator, List, Optional, Union
 from uuid import uuid4
@@ -13,6 +14,7 @@ from agno.run.workflow import (
     WorkflowRunOutput,
     WorkflowRunOutputEvent,
 )
+from agno.utils.merge_dict import merge_parallel_session_states
 from agno.utils.log import log_debug, logger
 from agno.workflow.condition import Condition
 from agno.workflow.step import Step
@@ -205,9 +207,20 @@ class Parallel:
 
         self._prepare_steps()
 
+        # Create individual session_state copies for each step to prevent race conditions
+        session_state_copies = []
+        for _ in range(len(self.steps)):
+            if session_state is not None:
+                session_state_copies.append(deepcopy(session_state))
+            else:
+                session_state_copies.append({})
+
         def execute_step_with_index(step_with_index):
             """Execute a single step and preserve its original index"""
             idx, step = step_with_index
+            # Use the individual session_state copy for this step
+            step_session_state = session_state_copies[idx]
+            
             try:
                 step_result = step.execute(
                     step_input,
@@ -215,9 +228,9 @@ class Parallel:
                     user_id=user_id,
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
-                    session_state=session_state,
+                    session_state=step_session_state,
                 )  # type: ignore[union-attr]
-                return idx, step_result
+                return idx, step_result, step_session_state
             except Exception as exc:
                 parallel_step_name = getattr(step, "name", f"step_{idx}")
                 logger.error(f"Parallel step {parallel_step_name} failed: {exc}")
@@ -229,6 +242,7 @@ class Parallel:
                         success=False,
                         error=str(exc),
                     ),
+                    step_session_state,
                 )
 
         # Use index to preserve order
@@ -241,12 +255,14 @@ class Parallel:
                 for indexed_step in indexed_steps
             }
 
-            # Collect results
+            # Collect results and modified session_state copies
             results_with_indices = []
+            modified_session_states = []
             for future in as_completed(future_to_index):
                 try:
-                    index, result = future.result()
+                    index, result, modified_session_state = future.result()
                     results_with_indices.append((index, result))
+                    modified_session_states.append(modified_session_state)
                     step_name = getattr(self.steps[index], "name", f"step_{index}")
                     log_debug(f"Parallel step {step_name} completed")
                 except Exception as e:
@@ -265,6 +281,9 @@ class Parallel:
                         )
                     )
 
+        if session_state is not None:
+            merge_parallel_session_states(session_state, modified_session_states)
+
         # Sort by original index to preserve order
         results_with_indices.sort(key=lambda x: x[0])
         results = [result for _, result in results_with_indices]
@@ -304,6 +323,14 @@ class Parallel:
 
         self._prepare_steps()
 
+        # Create individual session_state copies for each step to prevent race conditions
+        session_state_copies = []
+        for _ in range(len(self.steps)):
+            if session_state is not None:
+                session_state_copies.append(deepcopy(session_state))
+            else:
+                session_state_copies.append({})
+
         if stream_intermediate_steps and workflow_run_response:
             # Yield parallel step started event
             yield ParallelExecutionStartedEvent(
@@ -321,6 +348,9 @@ class Parallel:
         def execute_step_stream_with_index(step_with_index):
             """Execute a single step with streaming and preserve its original index"""
             idx, step = step_with_index
+            # Use the individual session_state copy for this step
+            step_session_state = session_state_copies[idx]
+            
             try:
                 step_events = []
 
@@ -342,11 +372,11 @@ class Parallel:
                     workflow_run_response=workflow_run_response,
                     step_index=sub_step_index,
                     store_executor_outputs=store_executor_outputs,
-                    session_state=session_state,
+                    session_state=step_session_state,
                     parent_step_id=parallel_step_id,
                 ):
                     step_events.append(event)
-                return idx, step_events
+                return idx, step_events, step_session_state
             except Exception as exc:
                 parallel_step_name = getattr(step, "name", f"step_{idx}")
                 logger.error(f"Parallel step {parallel_step_name} streaming failed: {exc}")
@@ -360,12 +390,14 @@ class Parallel:
                             error=str(exc),
                         )
                     ],
+                    step_session_state,
                 )
 
         # Use index to preserve order
         indexed_steps = list(enumerate(self.steps))
         all_events_with_indices = []
         step_results = []
+        modified_session_states = []
 
         with ThreadPoolExecutor(max_workers=len(self.steps)) as executor:
             # Submit all tasks with their original indices
@@ -374,11 +406,12 @@ class Parallel:
                 for indexed_step in indexed_steps
             }
 
-            # Collect results as they complete
+            # Collect results and modified session_state copies
             for future in as_completed(future_to_index):
                 try:
-                    index, events = future.result()
+                    index, events, modified_session_state = future.result()
                     all_events_with_indices.append((index, events))
+                    modified_session_states.append(modified_session_state)
 
                     # Extract StepOutput from events for the final result
                     step_outputs = [event for event in events if isinstance(event, StepOutput)]
@@ -400,6 +433,10 @@ class Parallel:
                     all_events_with_indices.append((index, [error_event]))
                     step_results.append(error_event)
 
+        # Merge all session_state changes back into the original session_state
+        if session_state is not None:
+            merge_parallel_session_states(session_state, modified_session_states)
+
         # Sort events by original index to preserve order
         all_events_with_indices.sort(key=lambda x: x[0])
 
@@ -456,9 +493,20 @@ class Parallel:
 
         self._prepare_steps()
 
+        # Create individual session_state copies for each step to prevent race conditions
+        session_state_copies = []
+        for _ in range(len(self.steps)):
+            if session_state is not None:
+                session_state_copies.append(deepcopy(session_state))
+            else:
+                session_state_copies.append({})
+
         async def execute_step_async_with_index(step_with_index):
             """Execute a single step asynchronously and preserve its original index"""
             idx, step = step_with_index
+            # Use the individual session_state copy for this step
+            step_session_state = session_state_copies[idx]
+            
             try:
                 inner_step_result = await step.aexecute(
                     step_input,
@@ -466,9 +514,9 @@ class Parallel:
                     user_id=user_id,
                     workflow_run_response=workflow_run_response,
                     store_executor_outputs=store_executor_outputs,
-                    session_state=session_state,
+                    session_state=step_session_state,
                 )  # type: ignore[union-attr]
-                return idx, inner_step_result
+                return idx, inner_step_result, step_session_state
             except Exception as exc:
                 parallel_step_name = getattr(step, "name", f"step_{idx}")
                 logger.error(f"Parallel step {parallel_step_name} failed: {exc}")
@@ -480,6 +528,7 @@ class Parallel:
                         success=False,
                         error=str(exc),
                     ),
+                    step_session_state,
                 )
 
         # Use index to preserve order
@@ -493,6 +542,7 @@ class Parallel:
 
         # Process results and handle exceptions, preserving order
         processed_results_with_indices = []
+        modified_session_states = []
         for i, result in enumerate(results_with_indices):
             if isinstance(result, Exception):
                 step_name = getattr(self.steps[i], "name", f"step_{i}")
@@ -508,12 +558,19 @@ class Parallel:
                         ),
                     )
                 )
+                # Still collect the session state copy for failed steps
+                modified_session_states.append(session_state_copies[i])
             else:
-                index, step_result = result  # type: ignore[misc]
+                index, step_result, modified_session_state = result  # type: ignore[misc]
                 processed_results_with_indices.append((index, step_result))
+                modified_session_states.append(modified_session_state)
                 step_name = getattr(self.steps[index], "name", f"step_{index}")
                 log_debug(f"Parallel step {step_name} completed")
 
+        # Smart merge all session_state changes back into the original session_state
+        if session_state is not None:
+            merge_parallel_session_states(session_state, modified_session_states)
+
         # Sort by original index to preserve order
         processed_results_with_indices.sort(key=lambda x: x[0])
         results = [result for _, result in processed_results_with_indices]
@@ -553,6 +610,14 @@ class Parallel:
 
         self._prepare_steps()
 
+        # Create individual session_state copies for each step to prevent race conditions
+        session_state_copies = []
+        for _ in range(len(self.steps)):
+            if session_state is not None:
+                session_state_copies.append(deepcopy(session_state))
+            else:
+                session_state_copies.append({})
+
         if stream_intermediate_steps and workflow_run_response:
             # Yield parallel step started event
             yield ParallelExecutionStartedEvent(
@@ -570,6 +635,9 @@ class Parallel:
         async def execute_step_stream_async_with_index(step_with_index):
             """Execute a single step with async streaming and preserve its original index"""
             idx, step = step_with_index
+            # Use the individual session_state copy for this step
+            step_session_state = session_state_copies[idx]
+            
             try:
                 step_events = []
 
@@ -591,11 +659,11 @@ class Parallel:
                     workflow_run_response=workflow_run_response,
                     step_index=sub_step_index,
                     store_executor_outputs=store_executor_outputs,
-                    session_state=session_state,
+                    session_state=step_session_state,
                     parent_step_id=parallel_step_id,
                 ):  # type: ignore[union-attr]
                     step_events.append(event)
-                return idx, step_events
+                return idx, step_events, step_session_state
             except Exception as e:
                 parallel_step_name = getattr(step, "name", f"step_{idx}")
                 logger.error(f"Parallel step {parallel_step_name} async streaming failed: {e}")
@@ -609,12 +677,14 @@ class Parallel:
                             error=str(e),
                         )
                     ],
+                    step_session_state,
                 )
 
         # Use index to preserve order
         indexed_steps = list(enumerate(self.steps))
         all_events_with_indices = []
         step_results = []
+        modified_session_states = []
 
         # Create tasks for all steps with their indices
         tasks = [execute_step_stream_async_with_index(indexed_step) for indexed_step in indexed_steps]
@@ -635,9 +705,11 @@ class Parallel:
                 )
                 all_events_with_indices.append((i, [error_event]))
                 step_results.append(error_event)
+                modified_session_states.append(session_state_copies[i])
             else:
-                index, events = result  # type: ignore[misc]
+                index, events, modified_session_state = result  # type: ignore[misc]
                 all_events_with_indices.append((index, events))
+                modified_session_states.append(modified_session_state)
 
                 # Extract StepOutput from events for the final result
                 step_outputs = [event for event in events if isinstance(event, StepOutput)]
@@ -647,6 +719,10 @@ class Parallel:
                 step_name = getattr(self.steps[index], "name", f"step_{index}")
                 log_debug(f"Parallel step {step_name} async streaming completed")
 
+        # Merge all session_state changes back into the original session_state
+        if session_state is not None:
+            merge_parallel_session_states(session_state, modified_session_states)
+
         # Sort events by original index to preserve order
         all_events_with_indices.sort(key=lambda x: x[0])