agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/os/utils.py

@@ -1,13 +1,17 @@
-from typing import Any, Callable, Dict, List, Optional, Union
-from uuid import uuid4
+from typing import Any, Callable, Dict, List, Optional, Set, Union
 
-from fastapi import HTTPException, UploadFile
+from fastapi import FastAPI, HTTPException, UploadFile
+from fastapi.routing import APIRoute, APIRouter
+from pydantic import BaseModel
+from starlette.middleware.cors import CORSMiddleware
 
 from agno.agent.agent import Agent
-from agno.db.base import BaseDb
+from agno.db.base import AsyncBaseDb, BaseDb
 from agno.knowledge.knowledge import Knowledge
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
+from agno.models.message import Message
+from agno.os.config import AgentOSConfig
 from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import Function
@@ -15,23 +19,69 @@ from agno.utils.log import logger
 from agno.workflow.workflow import Workflow
 
 
-def get_db(dbs: dict[str, BaseDb], db_id: Optional[str] = None) -> BaseDb:
-    """Return the database with the given ID, or the first database if no ID is provided."""
+async def get_db(
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]], db_id: Optional[str] = None, table: Optional[str] = None
+) -> Union[BaseDb, AsyncBaseDb]:
+    """Return the database with the given ID and/or table, or the first database if no ID/table is provided."""
+
+    if table and not db_id:
+        raise HTTPException(status_code=400, detail="The db_id query parameter is required when passing a table")
+
+    async def _has_table(db: Union[BaseDb, AsyncBaseDb], table_name: str) -> bool:
+        """Check if this database has the specified table (configured and actually exists)."""
+        # First check if table name is configured
+        is_configured = (
+            hasattr(db, "session_table_name")
+            and db.session_table_name == table_name
+            or hasattr(db, "memory_table_name")
+            and db.memory_table_name == table_name
+            or hasattr(db, "metrics_table_name")
+            and db.metrics_table_name == table_name
+            or hasattr(db, "eval_table_name")
+            and db.eval_table_name == table_name
+            or hasattr(db, "knowledge_table_name")
+            and db.knowledge_table_name == table_name
+        )
+
+        if not is_configured:
+            return False
+
+        # Then check if table actually exists in the database
+        try:
+            if isinstance(db, AsyncBaseDb):
+                # For async databases, await the check
+                return await db.table_exists(table_name)
+            else:
+                # For sync databases, call directly
+                return db.table_exists(table_name)
+        except (NotImplementedError, AttributeError):
+            # If table_exists not implemented, fall back to configuration check
+            return is_configured
+
+    # If db_id is provided, first find the database with that ID
+    if db_id:
+        target_db_list = dbs.get(db_id)
+        if not target_db_list:
+            raise HTTPException(status_code=404, detail=f"No database found with id '{db_id}'")
+
+        # If table is also specified, search through all databases with this ID to find one with the table
+        if table:
+            for db in target_db_list:
+                if await _has_table(db, table):
+                    return db
+            raise HTTPException(status_code=404, detail=f"No database with id '{db_id}' has table '{table}'")
+
+        # If no table specified, return the first database with this ID
+        return target_db_list[0]
 
     # Raise if multiple databases are provided but no db_id is provided
-    if not db_id and len(dbs) > 1:
+    if len(dbs) > 1:
         raise HTTPException(
             status_code=400, detail="The db_id query parameter is required when using multiple databases"
         )
 
-    # Get and return the database with the given ID, or raise if not found
-    if db_id:
-        db = dbs.get(db_id)
-        if not db:
-            raise HTTPException(status_code=404, detail=f"Database with id '{db_id}' not found")
-    else:
-        db = next(iter(dbs.values()))
-    return db
+    # Return the first (and only) database
+    return next(db for dbs in dbs.values() for db in dbs)
 
 
 def get_knowledge_instance_by_db_id(knowledge_instances: List[Knowledge], db_id: Optional[str] = None) -> Knowledge:
@@ -52,17 +102,33 @@ def get_knowledge_instance_by_db_id(knowledge_instances: List[Knowledge], db_id:
 
 
 def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> str:
-    """Get the run input from the given run dictionary"""
+    """Get the run input from the given run dictionary
+
+    Uses the RunInput/TeamRunInput object which stores the original user input.
+    """
+
+    # For agent or team runs, use the stored input_content
+    if not is_workflow_run and run_dict.get("input") is not None:
+        input_data = run_dict.get("input")
+        if isinstance(input_data, dict) and input_data.get("input_content") is not None:
+            return stringify_input_content(input_data["input_content"])
 
     if is_workflow_run:
+        # Check the input field directly
+        if run_dict.get("input") is not None:
+            input_value = run_dict.get("input")
+            return str(input_value)
+
+        # Check the step executor runs for fallback
         step_executor_runs = run_dict.get("step_executor_runs", [])
         if step_executor_runs:
-            for message in step_executor_runs[0].get("messages", []):
+            for message in reversed(step_executor_runs[0].get("messages", [])):
                 if message.get("role") == "user":
                     return message.get("content", "")
 
+    # Final fallback: scan messages
     if run_dict.get("messages") is not None:
-        for message in run_dict["messages"]:
+        for message in reversed(run_dict["messages"]):
             if message.get("role") == "user":
                 return message.get("content", "")
 
@@ -79,22 +145,46 @@ def get_session_name(session: Dict[str, Any]) -> str:
 
     # Otherwise use the original user message
     else:
-        runs = session.get("runs", [])
+        runs = session.get("runs", []) or []
 
         # 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()
@@ -106,31 +196,42 @@ def get_session_name(session: Dict[str, Any]) -> str:
     return ""
 
 
+def extract_input_media(run_dict: Dict[str, Any]) -> Dict[str, Any]:
+    input_media: Dict[str, List[Any]] = {
+        "images": [],
+        "videos": [],
+        "audios": [],
+        "files": [],
+    }
+
+    input = run_dict.get("input", {})
+    input_media["images"].extend(input.get("images", []))
+    input_media["videos"].extend(input.get("videos", []))
+    input_media["audios"].extend(input.get("audios", []))
+    input_media["files"].extend(input.get("files", []))
+
+    return input_media
+
+
 def process_image(file: UploadFile) -> Image:
     content = file.file.read()
     if not content:
         raise HTTPException(status_code=400, detail="Empty file")
-    return Image(content=content)
+    return Image(content=content, format=extract_format(file), mime_type=file.content_type)
 
 
 def process_audio(file: UploadFile) -> Audio:
     content = file.file.read()
     if not content:
         raise HTTPException(status_code=400, detail="Empty file")
-    format = None
-    if file.filename and "." in file.filename:
-        format = file.filename.split(".")[-1].lower()
-    elif file.content_type:
-        format = file.content_type.split("/")[-1]
-
-    return Audio(content=content, format=format)
+    return Audio(content=content, format=extract_format(file), mime_type=file.content_type)
 
 
 def process_video(file: UploadFile) -> Video:
     content = file.file.read()
     if not content:
         raise HTTPException(status_code=400, detail="Empty file")
-    return Video(content=content, format=file.content_type)
+    return Video(content=content, format=extract_format(file), mime_type=file.content_type)
 
 
 def process_document(file: UploadFile) -> Optional[FileMedia]:
@@ -138,15 +239,29 @@ 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)
+        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
 
 
+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:
+        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]]):
-    formatted_tools = []
+    formatted_tools: List[Dict] = []
     if agent_tools is not None:
         for tool in agent_tools:
             if isinstance(tool, dict):
@@ -164,8 +279,15 @@ def format_tools(agent_tools: List[Union[Dict[str, Any], Toolkit, Function, Call
     return formatted_tools
 
 
-def format_team_tools(team_tools: List[Function]):
-    return [tool.to_dict() for tool in team_tools]
+def format_team_tools(team_tools: List[Union[Function, dict]]):
+    formatted_tools: List[Dict] = []
+    if team_tools is not None:
+        for tool in team_tools:
+            if isinstance(tool, dict):
+                formatted_tools.append(tool)
+            elif isinstance(tool, Function):
+                formatted_tools.append(tool.to_dict())
+    return formatted_tools
 
 
 def get_agent_by_id(agent_id: str, agents: Optional[List[Agent]] = None) -> Optional[Agent]:
@@ -198,6 +320,33 @@ def get_workflow_by_id(workflow_id: str, workflows: Optional[List[Workflow]] = N
     return None
 
 
+#  INPUT SCHEMA VALIDATIONS
+
+
+def get_agent_input_schema_dict(agent: Agent) -> Optional[Dict[str, Any]]:
+    """Get input schema as dictionary for API responses"""
+
+    if agent.input_schema is not None:
+        try:
+            return agent.input_schema.model_json_schema()
+        except Exception:
+            return None
+
+    return None
+
+
+def get_team_input_schema_dict(team: Team) -> Optional[Dict[str, Any]]:
+    """Get input schema as dictionary for API responses"""
+
+    if team.input_schema is not None:
+        try:
+            return team.input_schema.model_json_schema()
+        except Exception:
+            return None
+
+    return None
+
+
 def get_workflow_input_schema_dict(workflow: Workflow) -> Optional[Dict[str, Any]]:
     """Get input schema as dictionary for API responses"""
 
@@ -263,8 +412,219 @@ def _generate_schema_from_params(params: Dict[str, Any]) -> Dict[str, Any]:
     return schema
 
 
-def generate_id(name: Optional[str] = None) -> str:
-    if name:
-        return name.lower().replace(" ", "-").replace("_", "-")
+def update_cors_middleware(app: FastAPI, new_origins: list):
+    existing_origins: List[str] = []
+
+    # TODO: Allow more options where CORS is properly merged and user can disable this behaviour
+
+    # Extract existing origins from current CORS middleware
+    for middleware in app.user_middleware:
+        if middleware.cls == CORSMiddleware:
+            if hasattr(middleware, "kwargs"):
+                origins_value = middleware.kwargs.get("allow_origins", [])
+                if isinstance(origins_value, list):
+                    existing_origins = origins_value
+                else:
+                    existing_origins = []
+            break
+    # Merge origins
+    merged_origins = list(set(new_origins + existing_origins))
+    final_origins = [origin for origin in merged_origins if origin != "*"]
+
+    # Remove existing CORS
+    app.user_middleware = [m for m in app.user_middleware if m.cls != CORSMiddleware]
+    app.middleware_stack = None
+
+    # Add updated CORS
+    app.add_middleware(
+        CORSMiddleware,  # type: ignore
+        allow_origins=final_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+        expose_headers=["*"],
+    )
+
+
+def get_existing_route_paths(fastapi_app: FastAPI) -> Dict[str, List[str]]:
+    """Get all existing route paths and methods from the FastAPI app.
+
+    Returns:
+        Dict[str, List[str]]: Dictionary mapping paths to list of HTTP methods
+    """
+    existing_paths: Dict[str, Any] = {}
+    for route in fastapi_app.routes:
+        if isinstance(route, APIRoute):
+            path = route.path
+            methods = list(route.methods) if route.methods else []
+            if path in existing_paths:
+                existing_paths[path].extend(methods)
+            else:
+                existing_paths[path] = methods
+    return existing_paths
+
+
+def find_conflicting_routes(fastapi_app: FastAPI, router: APIRouter) -> List[Dict[str, Any]]:
+    """Find conflicting routes in the FastAPI app.
+
+    Args:
+        fastapi_app: The FastAPI app with all existing routes
+        router: The APIRouter to add
+
+    Returns:
+        List[Dict[str, Any]]: List of conflicting routes
+    """
+    existing_paths = get_existing_route_paths(fastapi_app)
+
+    conflicts = []
+
+    for route in router.routes:
+        if isinstance(route, APIRoute):
+            full_path = route.path
+            route_methods = list(route.methods) if route.methods else []
+
+            if full_path in existing_paths:
+                conflicting_methods: Set[str] = set(route_methods) & set(existing_paths[full_path])
+                if conflicting_methods:
+                    conflicts.append({"path": full_path, "methods": list(conflicting_methods), "route": route})
+    return conflicts
+
+
+def load_yaml_config(config_file_path: str) -> AgentOSConfig:
+    """Load a YAML config file and return the configuration as an AgentOSConfig instance."""
+    from pathlib import Path
+
+    import yaml
+
+    # Validate that the path points to a YAML file
+    path = Path(config_file_path)
+    if path.suffix.lower() not in [".yaml", ".yml"]:
+        raise ValueError(f"Config file must have a .yaml or .yml extension, got: {config_file_path}")
+
+    # Load the YAML file
+    with open(config_file_path, "r") as f:
+        return AgentOSConfig.model_validate(yaml.safe_load(f))
+
+
+def collect_mcp_tools_from_team(team: Team, mcp_tools: List[Any]) -> None:
+    """Recursively collect MCP tools from a team and its members."""
+    # Check the team tools
+    if team.tools:
+        for tool in team.tools:
+            type_name = type(tool).__name__
+            if type_name in ("MCPTools", "MultiMCPTools"):
+                if tool not in mcp_tools:
+                    mcp_tools.append(tool)
+
+    # Recursively check team members
+    if team.members:
+        for member in team.members:
+            if isinstance(member, Agent):
+                if member.tools:
+                    for tool in member.tools:
+                        type_name = type(tool).__name__
+                        if type_name in ("MCPTools", "MultiMCPTools"):
+                            if tool not in mcp_tools:
+                                mcp_tools.append(tool)
+
+            elif isinstance(member, Team):
+                # Recursively check nested team
+                collect_mcp_tools_from_team(member, mcp_tools)
+
+
+def collect_mcp_tools_from_workflow(workflow: Workflow, mcp_tools: List[Any]) -> None:
+    """Recursively collect MCP tools from a workflow and its steps."""
+    from agno.workflow.steps import Steps
+
+    # Recursively check workflow steps
+    if workflow.steps:
+        if isinstance(workflow.steps, list):
+            # Handle list of steps
+            for step in workflow.steps:
+                collect_mcp_tools_from_workflow_step(step, mcp_tools)
+
+        elif isinstance(workflow.steps, Steps):
+            # Handle Steps container
+            if steps := workflow.steps.steps:
+                for step in steps:
+                    collect_mcp_tools_from_workflow_step(step, mcp_tools)
+
+        elif callable(workflow.steps):
+            pass
+
+
+def collect_mcp_tools_from_workflow_step(step: Any, mcp_tools: List[Any]) -> None:
+    """Collect MCP tools from a single workflow step."""
+    from agno.workflow.condition import Condition
+    from agno.workflow.loop import Loop
+    from agno.workflow.parallel import Parallel
+    from agno.workflow.router import Router
+    from agno.workflow.step import Step
+    from agno.workflow.steps import Steps
+
+    if isinstance(step, Step):
+        # Check step's agent
+        if step.agent:
+            if step.agent.tools:
+                for tool in step.agent.tools:
+                    type_name = type(tool).__name__
+                    if type_name in ("MCPTools", "MultiMCPTools"):
+                        if tool not in mcp_tools:
+                            mcp_tools.append(tool)
+        # Check step's team
+        if step.team:
+            collect_mcp_tools_from_team(step.team, mcp_tools)
+
+    elif isinstance(step, Steps):
+        if steps := step.steps:
+            for step in steps:
+                collect_mcp_tools_from_workflow_step(step, mcp_tools)
+
+    elif isinstance(step, (Parallel, Loop, Condition, Router)):
+        # These contain other steps - recursively check them
+        if hasattr(step, "steps") and step.steps:
+            for sub_step in step.steps:
+                collect_mcp_tools_from_workflow_step(sub_step, mcp_tools)
+
+    elif isinstance(step, Agent):
+        # Direct agent in workflow steps
+        if step.tools:
+            for tool in step.tools:
+                type_name = type(tool).__name__
+                if type_name in ("MCPTools", "MultiMCPTools"):
+                    if tool not in mcp_tools:
+                        mcp_tools.append(tool)
+
+    elif isinstance(step, Team):
+        # Direct team in workflow steps
+        collect_mcp_tools_from_team(step, mcp_tools)
+
+    elif isinstance(step, Workflow):
+        # Nested workflow
+        collect_mcp_tools_from_workflow(step, mcp_tools)
+
+
+def stringify_input_content(input_content: Union[str, Dict[str, Any], List[Any], BaseModel]) -> str:
+    """Convert any given input_content into its string representation.
+
+    This handles both serialized (dict) and live (object) input_content formats.
+    """
+    import json
+
+    if isinstance(input_content, str):
+        return input_content
+    elif isinstance(input_content, Message):
+        return json.dumps(input_content.to_dict())
+    elif isinstance(input_content, dict):
+        return json.dumps(input_content, indent=2, default=str)
+    elif isinstance(input_content, list):
+        if input_content:
+            # Handle live Message objects
+            if isinstance(input_content[0], Message):
+                return json.dumps([m.to_dict() for m in input_content])
+            # Handle serialized Message dicts
+            elif isinstance(input_content[0], dict) and input_content[0].get("role") == "user":
+                return input_content[0].get("content", str(input_content))
+        return str(input_content)
     else:
-        return str(uuid4())
+        return str(input_content)

agno/reasoning/anthropic.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.utils.log import logger
+
+
+def is_anthropic_reasoning_model(reasoning_model: Model) -> bool:
+    """Check if the model is an Anthropic Claude model with thinking support."""
+    is_claude = reasoning_model.__class__.__name__ == "Claude"
+    if not is_claude:
+        return False
+
+    # Check if provider is Anthropic (not VertexAI)
+    is_anthropic_provider = hasattr(reasoning_model, "provider") and reasoning_model.provider == "Anthropic"
+
+    # Check if thinking parameter is set
+    has_thinking = hasattr(reasoning_model, "thinking") and reasoning_model.thinking is not None
+
+    return is_claude and is_anthropic_provider and has_thinking
+
+
+def get_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from an Anthropic Claude model."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+            if hasattr(msg, "redacted_reasoning_content") and msg.redacted_reasoning_content is not None:
+                redacted_reasoning_content = msg.redacted_reasoning_content
+                break
+
+    return Message(
+        role="assistant",
+        content=f"<thinking>\n{reasoning_content}\n</thinking>",
+        reasoning_content=reasoning_content,
+        redacted_reasoning_content=redacted_reasoning_content,
+    )
+
+
+async def aget_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from an Anthropic Claude model asynchronously."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+            if hasattr(msg, "redacted_reasoning_content") and msg.redacted_reasoning_content is not None:
+                redacted_reasoning_content = msg.redacted_reasoning_content
+                break
+
+    return Message(
+        role="assistant",
+        content=f"<thinking>\n{reasoning_content}\n</thinking>",
+        reasoning_content=reasoning_content,
+        redacted_reasoning_content=redacted_reasoning_content,
+    )

agno/reasoning/azure_ai_foundry.py

@@ -20,7 +20,7 @@ def get_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message])
     from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -46,7 +46,7 @@ async def aget_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Mes
     from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/deepseek.py

@@ -20,7 +20,7 @@ def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) ->
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -46,7 +46,7 @@ async def aget_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Messa
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None