agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/{app/playground → os}/settings.py

@@ -6,32 +6,24 @@ from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings
 
 
-class PlaygroundSettings(BaseSettings):
-    """Playground API settings that can be set using environment variables.
+class AgnoAPISettings(BaseSettings):
+    """App settings for API-based apps that can be set using environment variables.
 
     Reference: https://pydantic-docs.helpmanual.io/usage/settings/
     """
 
     env: str = "dev"
-    title: str = "agno-playground"
+    title: str = "Agno AgentOS"
 
     # Set to False to disable docs server at /docs and /redoc
     docs_enabled: bool = True
 
-    secret_key: Optional[str] = None
+    # Authentication settings
+    os_security_key: Optional[str] = Field(default=None, description="Bearer token for API authentication")
 
     # Cors origin list to allow requests from.
     # This list is set using the set_cors_origin_list validator
-    cors_origin_list: Optional[List[str]] = Field(None, validate_default=True)
-
-    @field_validator("env", mode="before")
-    def validate_playground_env(cls, env):
-        """Validate playground_env."""
-
-        valid_runtime_envs = ["dev", "stg", "prd"]
-        if env not in valid_runtime_envs:
-            raise ValueError(f"Invalid Playground Env: {env}")
-        return env
+    cors_origin_list: Optional[List[str]] = Field(default=None, validate_default=True)
 
     @field_validator("cors_origin_list", mode="before")
     def set_cors_origin_list(cls, cors_origin_list):
@@ -44,7 +36,8 @@ class PlaygroundSettings(BaseSettings):
                 "https://agno.com",
                 "https://www.agno.com",
                 "https://app.agno.com",
-                "https://app-stg.agno.com",
+                "https://os-stg.agno.com",
+                "https://os.agno.com",
             ]
         )
 

agno/os/utils.py

@@ -0,0 +1,270 @@
+from typing import Any, Callable, Dict, List, Optional, Union
+from uuid import uuid4
+
+from fastapi import HTTPException, UploadFile
+
+from agno.agent.agent import Agent
+from agno.db.base import BaseDb
+from agno.knowledge.knowledge import Knowledge
+from agno.media import Audio, Image, Video
+from agno.media import File as FileMedia
+from agno.team.team import Team
+from agno.tools import Toolkit
+from agno.tools.function import Function
+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."""
+
+    # Raise if multiple databases are provided but no db_id is provided
+    if not db_id and 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
+
+
+def get_knowledge_instance_by_db_id(knowledge_instances: List[Knowledge], db_id: Optional[str] = None) -> Knowledge:
+    """Return the knowledge instance with the given ID, or the first knowledge instance if no ID is provided."""
+    if not db_id and len(knowledge_instances) == 1:
+        return next(iter(knowledge_instances))
+
+    if not db_id:
+        raise HTTPException(
+            status_code=400, detail="The db_id query parameter is required when using multiple databases"
+        )
+
+    for knowledge in knowledge_instances:
+        if knowledge.contents_db and knowledge.contents_db.id == db_id:
+            return knowledge
+
+    raise HTTPException(status_code=404, detail=f"Knowledge instance with id '{db_id}' not found")
+
+
+def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> str:
+    """Get the run input from the given run dictionary"""
+
+    if is_workflow_run:
+        step_executor_runs = run_dict.get("step_executor_runs", [])
+        if step_executor_runs:
+            for message in step_executor_runs[0].get("messages", []):
+                if message.get("role") == "user":
+                    return message.get("content", "")
+
+    if run_dict.get("messages") is not None:
+        for message in run_dict["messages"]:
+            if message.get("role") == "user":
+                return message.get("content", "")
+
+    return ""
+
+
+def get_session_name(session: Dict[str, Any]) -> str:
+    """Get the session name from the given session dictionary"""
+
+    # If session_data.session_name is set, return that
+    session_data = session.get("session_data")
+    if session_data is not None and session_data.get("session_name") is not None:
+        return session_data["session_name"]
+
+    # Otherwise use the original user message
+    else:
+        runs = session.get("runs", [])
+
+        # 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]
+
+        # For workflows, pass along the first step_executor_run
+        elif session.get("session_type") == "workflow":
+            try:
+                run = session["runs"][0]["step_executor_runs"][0]
+            except (KeyError, IndexError, TypeError):
+                return ""
+
+        # For agents, use the first run
+        else:
+            run = runs[0]
+
+        if not isinstance(run, dict):
+            run = run.to_dict()
+
+        if run and run.get("messages"):
+            for message in run["messages"]:
+                if message["role"] == "user":
+                    return message["content"]
+    return ""
+
+
+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)
+
+
+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)
+
+
+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)
+
+
+def process_document(file: UploadFile) -> Optional[FileMedia]:
+    try:
+        content = file.file.read()
+        if not content:
+            raise HTTPException(status_code=400, detail="Empty file")
+
+        return FileMedia(content=content)
+    except Exception as e:
+        logger.error(f"Error processing document {file.filename}: {e}")
+        return None
+
+
+def format_tools(agent_tools: List[Union[Dict[str, Any], Toolkit, Function, Callable]]):
+    formatted_tools = []
+    if agent_tools is not None:
+        for tool in agent_tools:
+            if isinstance(tool, dict):
+                formatted_tools.append(tool)
+            elif isinstance(tool, Toolkit):
+                for _, f in tool.functions.items():
+                    formatted_tools.append(f.to_dict())
+            elif isinstance(tool, Function):
+                formatted_tools.append(tool.to_dict())
+            elif callable(tool):
+                func = Function.from_callable(tool)
+                formatted_tools.append(func.to_dict())
+            else:
+                logger.warning(f"Unknown tool type: {type(tool)}")
+    return formatted_tools
+
+
+def format_team_tools(team_tools: List[Function]):
+    return [tool.to_dict() for tool in team_tools]
+
+
+def get_agent_by_id(agent_id: str, agents: Optional[List[Agent]] = None) -> Optional[Agent]:
+    if agent_id is None or agents is None:
+        return None
+
+    for agent in agents:
+        if agent.id == agent_id:
+            return agent
+    return None
+
+
+def get_team_by_id(team_id: str, teams: Optional[List[Team]] = None) -> Optional[Team]:
+    if team_id is None or teams is None:
+        return None
+
+    for team in teams:
+        if team.id == team_id:
+            return team
+    return None
+
+
+def get_workflow_by_id(workflow_id: str, workflows: Optional[List[Workflow]] = None) -> Optional[Workflow]:
+    if workflow_id is None or workflows is None:
+        return None
+
+    for workflow in workflows:
+        if workflow.id == workflow_id:
+            return workflow
+    return None
+
+
+def get_workflow_input_schema_dict(workflow: Workflow) -> Optional[Dict[str, Any]]:
+    """Get input schema as dictionary for API responses"""
+
+    # Priority 1: Explicit input_schema (Pydantic model)
+    if workflow.input_schema is not None:
+        try:
+            return workflow.input_schema.model_json_schema()
+        except Exception:
+            return None
+
+    # Priority 2: Auto-generate from custom kwargs
+    if workflow.steps and callable(workflow.steps):
+        custom_params = workflow.run_parameters
+        if custom_params and len(custom_params) > 1:  # More than just 'message'
+            return _generate_schema_from_params(custom_params)
+
+    # Priority 3: No schema (expects string message)
+    return None
+
+
+def _generate_schema_from_params(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert function parameters to JSON schema"""
+    properties: Dict[str, Any] = {}
+    required: List[str] = []
+
+    for param_name, param_info in params.items():
+        # Skip the default 'message' parameter for custom kwargs workflows
+        if param_name == "message":
+            continue
+
+        # Map Python types to JSON schema types
+        param_type = param_info.get("annotation", "str")
+        default_value = param_info.get("default")
+        is_required = param_info.get("required", False)
+
+        # Convert Python type annotations to JSON schema types
+        if param_type == "str":
+            properties[param_name] = {"type": "string"}
+        elif param_type == "bool":
+            properties[param_name] = {"type": "boolean"}
+        elif param_type == "int":
+            properties[param_name] = {"type": "integer"}
+        elif param_type == "float":
+            properties[param_name] = {"type": "number"}
+        elif "List" in str(param_type):
+            properties[param_name] = {"type": "array", "items": {"type": "string"}}
+        else:
+            properties[param_name] = {"type": "string"}  # fallback
+
+        # Add default value if present
+        if default_value is not None:
+            properties[param_name]["default"] = default_value
+
+        # Add to required if no default value
+        if is_required and default_value is None:
+            required.append(param_name)
+
+    schema = {"type": "object", "properties": properties}
+
+    if required:
+        schema["required"] = required
+
+    return schema
+
+
+def generate_id(name: Optional[str] = None) -> str:
+    if name:
+        return name.lower().replace(" ", "-").replace("_", "-")
+    else:
+        return str(uuid4())

agno/reasoning/azure_ai_foundry.py

@@ -17,10 +17,10 @@ def is_ai_foundry_reasoning_model(reasoning_model: Model) -> bool:
 
 
 def get_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunResponse = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -43,10 +43,10 @@ def get_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message])
 
 
 async def aget_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunResponse = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/deepseek.py

@@ -12,7 +12,7 @@ def is_deepseek_reasoning_model(reasoning_model: Model) -> bool:
 
 
 def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     # Update system message role to "system"
     for message in messages:
@@ -20,7 +20,7 @@ def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) ->
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunResponse = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -38,7 +38,7 @@ def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) ->
 
 
 async def aget_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     # Update system message role to "system"
     for message in messages:
@@ -46,7 +46,7 @@ async def aget_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Messa
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunResponse = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/default.py

@@ -5,8 +5,8 @@ from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from agno.models.base import Model
 from agno.reasoning.step import ReasoningSteps
+from agno.tools import Toolkit
 from agno.tools.function import Function
-from agno.tools.toolkit import Toolkit
 
 
 def get_default_reasoning_agent(
@@ -15,13 +15,12 @@ def get_default_reasoning_agent(
     max_steps: int,
     tools: Optional[List[Union[Toolkit, Callable, Function, Dict]]] = None,
     use_json_mode: bool = False,
-    monitoring: bool = False,
     telemetry: bool = True,
     debug_mode: bool = False,
     debug_level: Literal[1, 2] = 1,
     session_state: Optional[Dict[str, Any]] = None,
-    context: Optional[Dict[str, Any]] = None,
-    extra_data: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
 ) -> Optional["Agent"]:  # type: ignore  # noqa: F821
     from agno.agent import Agent
 
@@ -83,18 +82,14 @@ def get_default_reasoning_agent(
         - Only create a single instance of ReasoningSteps for your response.\
         """),
         tools=tools,
-        show_tool_calls=False,
-        response_model=ReasoningSteps,
+        output_schema=ReasoningSteps,
         use_json_mode=use_json_mode,
-        monitoring=monitoring,
         telemetry=telemetry,
         debug_mode=debug_mode,
         debug_level=debug_level,
         session_state=session_state,
-        context=context,
-        extra_data=extra_data,
+        dependencies=dependencies,
+        metadata=metadata,
     )
 
-    agent.model.show_tool_calls = False  # type: ignore
-
     return agent

agno/reasoning/groq.py

@@ -12,7 +12,7 @@ def is_groq_reasoning_model(reasoning_model: Model) -> bool:
 
 
 def get_groq_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     # Update system message role to "system"
     for message in messages:
@@ -20,7 +20,7 @@ def get_groq_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Opt
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunResponse = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -42,7 +42,7 @@ def get_groq_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Opt
 
 
 async def aget_groq_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     # Update system message role to "system"
     for message in messages:
@@ -50,7 +50,7 @@ async def aget_groq_reasoning(reasoning_agent: "Agent", messages: List[Message])
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunResponse = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/helpers.py

@@ -9,25 +9,23 @@ from agno.utils.log import logger
 
 def get_reasoning_agent(
     reasoning_model: Model,
-    monitoring: bool = False,
     telemetry: bool = False,
     debug_mode: bool = False,
     debug_level: Literal[1, 2] = 1,
     session_state: Optional[Dict[str, Any]] = None,
-    context: Optional[Dict[str, Any]] = None,
-    extra_data: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
 ) -> "Agent":  # type: ignore  # noqa: F821
     from agno.agent import Agent
 
     return Agent(
         model=reasoning_model,
-        monitoring=monitoring,
         telemetry=telemetry,
         debug_mode=debug_mode,
         debug_level=debug_level,
         session_state=session_state,
-        context=context,
-        extra_data=extra_data,
+        dependencies=dependencies,
+        metadata=metadata,
     )
 
 

agno/reasoning/ollama.py

@@ -17,10 +17,10 @@ def is_ollama_reasoning_model(reasoning_model: Model) -> bool:
 
 
 def get_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunResponse = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -43,10 +43,10 @@ def get_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> O
 
 
 async def aget_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunResponse = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/openai.py

@@ -26,10 +26,10 @@ def is_openai_reasoning_model(reasoning_model: Model) -> bool:
 
 
 def get_openai_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunResponse = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -52,7 +52,7 @@ def get_openai_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> O
 
 
 async def aget_openai_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
-    from agno.run.response import RunResponse
+    from agno.run.agent import RunOutput
 
     # Update system message role to "system"
     for message in messages:
@@ -60,7 +60,7 @@ async def aget_openai_reasoning(reasoning_agent: "Agent", messages: List[Message
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunResponse = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None