agno 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

agno/models/ollama/responses.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.models.openai.open_responses import OpenResponses
+from agno.utils.log import log_debug
+
+
+@dataclass
+class OllamaResponses(OpenResponses):
+    """
+    A class for interacting with Ollama models using the OpenAI Responses API.
+
+    This uses Ollama's OpenAI-compatible `/v1/responses` endpoint, which was added
+    in Ollama v0.13.3. It allows using Ollama models with the Responses API format.
+
+    Note: Ollama's Responses API is stateless - it does not support `previous_response_id`
+    or conversation chaining. Each request is independent.
+
+    Requirements:
+    - Ollama v0.13.3 or later
+    - For local usage: Ollama server running at http://localhost:11434
+    - For Ollama Cloud: Set OLLAMA_API_KEY environment variable
+
+    For more information, see: https://docs.ollama.com/api/openai-compatibility
+
+    Attributes:
+        id (str): The model id. Defaults to "gpt-oss:20b".
+        name (str): The model name. Defaults to "OllamaResponses".
+        provider (str): The provider name. Defaults to "Ollama".
+        host (Optional[str]): The Ollama server host. Defaults to "http://localhost:11434".
+        api_key (Optional[str]): The API key for Ollama Cloud. Not required for local usage.
+    """
+
+    id: str = "gpt-oss:20b"
+    name: str = "OllamaResponses"
+    provider: str = "Ollama"
+
+    # Ollama server host - defaults to local instance
+    host: Optional[str] = None
+
+    # API key for Ollama Cloud (not required for local)
+    api_key: Optional[str] = field(default_factory=lambda: getenv("OLLAMA_API_KEY"))
+
+    # Ollama's Responses API is stateless
+    store: Optional[bool] = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Get client parameters for API requests.
+
+        Returns:
+            Dict[str, Any]: Client parameters including base_url and optional api_key.
+        """
+        # Determine the base URL
+        if self.host:
+            base_url = self.host.rstrip("/")
+            if not base_url.endswith("/v1"):
+                base_url = f"{base_url}/v1"
+        elif self.api_key:
+            # Ollama Cloud
+            base_url = "https://ollama.com/v1"
+            log_debug(f"Using Ollama Cloud endpoint: {base_url}")
+        else:
+            # Local Ollama instance
+            base_url = "http://localhost:11434/v1"
+
+        # Build client params
+        base_params: Dict[str, Any] = {
+            "base_url": base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Add API key if provided (required for Ollama Cloud, ignored for local)
+        if self.api_key:
+            base_params["api_key"] = self.api_key
+        else:
+            # OpenAI client requires an api_key, but Ollama ignores it locally
+            base_params["api_key"] = "ollama"
+
+        # Filter out None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+
+        return client_params
+
+    def _using_reasoning_model(self) -> bool:
+        """
+        Ollama doesn't have native reasoning models like OpenAI's o-series.
+
+        Some models may support thinking/reasoning through their architecture
+        (like DeepSeek-R1), but they don't use OpenAI's reasoning API format.
+        """
+        return False

agno/models/openai/__init__.py

@@ -1,9 +1,11 @@
 from agno.models.openai.chat import OpenAIChat
 from agno.models.openai.like import OpenAILike
+from agno.models.openai.open_responses import OpenResponses
 from agno.models.openai.responses import OpenAIResponses
 
 __all__ = [
     "OpenAIChat",
     "OpenAILike",
     "OpenAIResponses",
+    "OpenResponses",
 ]

agno/models/openai/chat.py

@@ -43,6 +43,8 @@ class OpenAIChat(Model):
     name: str = "OpenAIChat"
     provider: str = "OpenAI"
     supports_native_structured_outputs: bool = True
+    # If True, only collect metrics on the final streaming chunk (for providers with cumulative token counts)
+    collect_metrics_on_completion: bool = False
 
     # Request parameters
     store: Optional[bool] = None
@@ -752,6 +754,21 @@ class OpenAIChat(Model):
                     tool_call_entry["type"] = _tool_call_type
         return tool_calls
 
+    def _should_collect_metrics(self, response: ChatCompletionChunk) -> bool:
+        """
+        Determine if metrics should be collected from the response.
+        """
+        if not response.usage:
+            return False
+
+        if not self.collect_metrics_on_completion:
+            return True
+
+        if not response.choices:
+            return False
+
+        return response.choices[0].finish_reason is not None
+
     def _parse_provider_response(
         self,
         response: ChatCompletion,
@@ -920,7 +937,7 @@ class OpenAIChat(Model):
                         log_warning(f"Error processing audio: {e}")
 
         # Add usage metrics if present
-        if response_delta.usage is not None:
+        if self._should_collect_metrics(response_delta) and response_delta.usage is not None:
             model_response.response_usage = self._get_metrics(response_delta.usage)
 
         return model_response

agno/models/openai/open_responses.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from agno.models.openai.responses import OpenAIResponses
+
+
+@dataclass
+class OpenResponses(OpenAIResponses):
+    """
+    A base class for interacting with any provider using the Open Responses API specification.
+
+    Open Responses is an open-source specification for building multi-provider, interoperable
+    LLM interfaces based on the OpenAI Responses API. This class provides a foundation for
+    providers that implement the spec (e.g., Ollama, OpenRouter).
+
+    For more information, see: https://openresponses.org
+
+    Key differences from OpenAIResponses:
+    - Configurable base_url for pointing to different API endpoints
+    - Stateless by default (no previous_response_id chaining)
+    - Flexible api_key handling for providers that don't require authentication
+
+    Args:
+        id (str): The model id. Defaults to "not-provided".
+        name (str): The model name. Defaults to "OpenResponses".
+        api_key (Optional[str]): The API key. Defaults to "not-provided".
+    """
+
+    id: str = "not-provided"
+    name: str = "OpenResponses"
+    provider: str = "OpenResponses"
+    api_key: Optional[str] = "not-provided"
+
+    # Disable stateful features by default for compatible providers
+    # Most OpenAI-compatible providers don't support previous_response_id chaining
+    store: Optional[bool] = False
+
+    def _using_reasoning_model(self) -> bool:
+        """
+        Override to disable reasoning model detection for compatible providers.
+
+        Most compatible providers don't support OpenAI's reasoning models,
+        so we disable the special handling by default. Subclasses can override
+        this if they support specific reasoning models.
+        """
+        return False

agno/models/openrouter/__init__.py

@@ -1,5 +1,7 @@
 from agno.models.openrouter.openrouter import OpenRouter
+from agno.models.openrouter.responses import OpenRouterResponses
 
 __all__ = [
     "OpenRouter",
+    "OpenRouterResponses",
 ]

agno/models/openrouter/responses.py

@@ -0,0 +1,146 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.open_responses import OpenResponses
+from agno.models.message import Message
+
+
+@dataclass
+class OpenRouterResponses(OpenResponses):
+    """
+    A class for interacting with OpenRouter models using the OpenAI Responses API.
+
+    OpenRouter's Responses API (currently in beta) provides OpenAI-compatible access
+    to multiple AI models through a unified interface. It supports tools, reasoning,
+    streaming, and plugins.
+
+    Note: OpenRouter's Responses API is stateless - each request is independent and
+    no server-side state is persisted.
+
+    For more information, see: https://openrouter.ai/docs/api/reference/responses/overview
+
+    Attributes:
+        id (str): The model id. Defaults to "openai/gpt-oss-20b".
+        name (str): The model name. Defaults to "OpenRouterResponses".
+        provider (str): The provider name. Defaults to "OpenRouter".
+        api_key (Optional[str]): The API key. Uses OPENROUTER_API_KEY env var if not set.
+        base_url (str): The base URL. Defaults to "https://openrouter.ai/api/v1".
+        models (Optional[List[str]]): List of fallback model IDs to use if the primary model
+            fails due to rate limits, timeouts, or unavailability. OpenRouter will automatically
+            try these models in order. Example: ["anthropic/claude-sonnet-4", "deepseek/deepseek-r1"]
+
+    Example:
+        ```python
+        from agno.agent import Agent
+        from agno.models.openrouter import OpenRouterResponses
+
+        agent = Agent(
+            model=OpenRouterResponses(id="anthropic/claude-sonnet-4"),
+            markdown=True,
+        )
+        agent.print_response("Write a haiku about coding")
+        ```
+    """
+
+    id: str = "openai/gpt-oss-20b"
+    name: str = "OpenRouterResponses"
+    provider: str = "OpenRouter"
+
+    api_key: Optional[str] = None
+    base_url: str = "https://openrouter.ai/api/v1"
+
+    # Dynamic model routing - fallback models if primary fails
+    # https://openrouter.ai/docs/features/model-routing
+    models: Optional[List[str]] = None
+
+    # OpenRouter's Responses API is stateless
+    store: Optional[bool] = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for OPENROUTER_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+
+        Raises:
+            ModelAuthenticationError: If OPENROUTER_API_KEY is not set.
+        """
+        # Fetch API key from env if not already set
+        if not self.api_key:
+            self.api_key = getenv("OPENROUTER_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="OPENROUTER_API_KEY not set. Please set the OPENROUTER_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Build client params
+        base_params: Dict[str, Any] = {
+            "api_key": self.api_key,
+            "base_url": self.base_url,
+            "organization": self.organization,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Filter out None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+
+        return client_params
+
+    def get_request_params(
+        self,
+        messages: Optional[List[Message]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Returns keyword arguments for API requests, including fallback models configuration.
+
+        Returns:
+            Dict[str, Any]: A dictionary of keyword arguments for API requests.
+        """
+        # Get base request params from parent class
+        request_params = super().get_request_params(
+            messages=messages,
+            response_format=response_format,
+            tools=tools,
+            tool_choice=tool_choice,
+        )
+
+        # Add fallback models to extra_body if specified
+        if self.models:
+            # Get existing extra_body or create new dict
+            extra_body = request_params.get("extra_body") or {}
+
+            # Merge fallback models into extra_body
+            extra_body["models"] = self.models
+
+            # Update request params
+            request_params["extra_body"] = extra_body
+
+        return request_params
+
+    def _using_reasoning_model(self) -> bool:
+        """
+        Check if the model is a reasoning model that requires special handling.
+
+        OpenRouter hosts various reasoning models, but they may not all use
+        OpenAI's reasoning API format. We check for known reasoning model patterns.
+        """
+        # Check for OpenAI reasoning models hosted on OpenRouter
+        if self.id.startswith("openai/o3") or self.id.startswith("openai/o4"):
+            return True
+        return False

agno/models/perplexity/perplexity.py

@@ -41,6 +41,8 @@ class Perplexity(OpenAILike):
     id: str = "sonar"
     name: str = "Perplexity"
     provider: str = "Perplexity"
+    # Perplexity returns cumulative token counts in each streaming chunk, so only collect on final chunk
+    collect_metrics_on_completion: bool = True
 
     api_key: Optional[str] = field(default_factory=lambda: getenv("PERPLEXITY_API_KEY"))
     base_url: str = "https://api.perplexity.ai/"

agno/os/interfaces/slack/router.py

@@ -7,7 +7,7 @@ from agno.agent import Agent, RemoteAgent
 from agno.os.interfaces.slack.security import verify_slack_signature
 from agno.team import RemoteTeam, Team
 from agno.tools.slack import SlackTools
-from agno.utils.log import log_info
+from agno.utils.log import log_error, log_info
 from agno.workflow import RemoteWorkflow, Workflow
 
 
@@ -112,6 +112,15 @@ def attach_routes(
             response = await workflow.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
 
         if response:
+            if response.status == "ERROR":
+                log_error(f"Error processing message: {response.content}")
+                _send_slack_message(
+                    channel=channel_id,
+                    message="Sorry, there was an error processing your message. Please try again later.",
+                    thread_ts=ts,
+                )
+                return
+
             if hasattr(response, "reasoning_content") and response.reasoning_content:
                 _send_slack_message(
                     channel=channel_id,

agno/os/interfaces/whatsapp/router.py

@@ -162,6 +162,12 @@ def attach_routes(
                     videos=[Video(content=await get_media_async(message_video))] if message_video else None,
                     audio=[Audio(content=await get_media_async(message_audio))] if message_audio else None,
                 )
+            if response.status == "ERROR":
+                await _send_whatsapp_message(
+                    phone_number, "Sorry, there was an error processing your message. Please try again later."
+                )
+                log_error(response.content)
+                return
 
             if response.reasoning_content:
                 await _send_whatsapp_message(phone_number, f"Reasoning: \n{response.reasoning_content}", italics=True)

agno/os/routers/components/components.py

@@ -25,7 +25,7 @@ from agno.os.schema import (
 )
 from agno.os.settings import AgnoAPISettings
 from agno.registry import Registry
-from agno.utils.log import log_error
+from agno.utils.log import log_error, log_warning
 from agno.utils.string import generate_id_from_name
 
 logger = logging.getLogger(__name__)
@@ -167,6 +167,15 @@ def attach_routes(
             config = body.config or {}
             config = _resolve_db_in_config(config, db, registry)
 
+            # Warn if creating a team without members
+            if body.component_type == ComponentType.TEAM:
+                members = config.get("members")
+                if not members or len(members) == 0:
+                    log_warning(
+                        f"Creating team '{body.name}' without members. "
+                        "If this is unintended, add members to the config."
+                    )
+
             component, _config = db.create_component_with_config(
                 component_id=component_id,
                 component_type=DbComponentType(body.component_type.value),

agno/os/routers/knowledge/knowledge.py

@@ -206,6 +206,113 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
         )
         return response
 
+    @router.post(
+        "/knowledge/remote-content",
+        response_model=ContentResponseSchema,
+        status_code=202,
+        operation_id="upload_remote_content",
+        summary="Upload Remote Content",
+        description=(
+            "Upload content from a remote source (S3, GCS, SharePoint, GitHub) to the knowledge base. "
+            "Content is processed asynchronously in the background. "
+            "Use the /knowledge/config endpoint to see available remote content sources."
+        ),
+        responses={
+            202: {
+                "description": "Remote content upload accepted for processing",
+                "content": {
+                    "application/json": {
+                        "example": {
+                            "id": "content-456",
+                            "name": "reports/q1-2024.pdf",
+                            "description": "Q1 Report from S3",
+                            "metadata": {"source": "s3-docs"},
+                            "status": "processing",
+                        }
+                    }
+                },
+            },
+            400: {
+                "description": "Invalid request - unknown config or missing path",
+                "model": BadRequestResponse,
+            },
+            422: {"description": "Validation error in request body", "model": ValidationErrorResponse},
+        },
+    )
+    async def upload_remote_content(
+        request: Request,
+        background_tasks: BackgroundTasks,
+        config_id: str = Form(..., description="ID of the configured remote content source (from /knowledge/config)"),
+        path: str = Form(..., description="Path to file or folder in the remote source"),
+        name: Optional[str] = Form(None, description="Content name (auto-generated if not provided)"),
+        description: Optional[str] = Form(None, description="Content description"),
+        metadata: Optional[str] = Form(None, description="JSON metadata object"),
+        reader_id: Optional[str] = Form(None, description="ID of the reader to use for processing"),
+        chunker: Optional[str] = Form(None, description="Chunking strategy to apply"),
+        chunk_size: Optional[int] = Form(None, description="Chunk size for processing"),
+        chunk_overlap: Optional[int] = Form(None, description="Chunk overlap for processing"),
+        db_id: Optional[str] = Query(default=None, description="Database ID to use for content storage"),
+    ):
+        knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
+
+        if isinstance(knowledge, RemoteKnowledge):
+            # TODO: Forward to remote knowledge instance
+            raise HTTPException(status_code=501, detail="Remote content upload not yet supported for RemoteKnowledge")
+
+        # Validate that the config_id exists in configured sources
+        config = knowledge._get_remote_config_by_id(config_id)
+        if config is None:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unknown content source: {config_id}. Check /knowledge/config for available sources.",
+            )
+
+        # Parse metadata if provided
+        parsed_metadata = None
+        if metadata:
+            try:
+                parsed_metadata = json.loads(metadata)
+            except json.JSONDecodeError:
+                parsed_metadata = {"value": metadata}
+
+        # Use the config's factory methods to create the remote content object
+        # If path ends with '/', treat as folder, otherwise treat as file
+        is_folder = path.endswith("/")
+        if is_folder:
+            if hasattr(config, "folder"):
+                remote_content = config.folder(path.rstrip("/"))
+            else:
+                raise HTTPException(status_code=400, detail=f"Config {config_id} does not support folder uploads")
+        else:
+            if hasattr(config, "file"):
+                remote_content = config.file(path)
+            else:
+                raise HTTPException(status_code=400, detail=f"Config {config_id} does not support file uploads")
+
+        # Set name from path if not provided
+        content_name = name or path
+
+        content = Content(
+            name=content_name,
+            description=description,
+            metadata=parsed_metadata,
+            remote_content=remote_content,
+        )
+        content_hash = knowledge._build_content_hash(content)
+        content.content_hash = content_hash
+        content.id = generate_id(content_hash)
+
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker, chunk_size, chunk_overlap)
+
+        response = ContentResponseSchema(
+            id=content.id,
+            name=content_name,
+            description=description,
+            metadata=parsed_metadata,
+            status=ContentStatus.PROCESSING,
+        )
+        return response
+
     @router.patch(
         "/knowledge/content/{content_id}",
         response_model=ContentResponseSchema,
@@ -1048,12 +1155,30 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
                 )
             )
         filters = await knowledge.aget_valid_filters()
+
+        # Get remote content sources if available
+        remote_content_sources = None
+        if hasattr(knowledge, "_get_remote_configs") and callable(knowledge._get_remote_configs):
+            remote_configs = knowledge._get_remote_configs()
+            if remote_configs:
+                from agno.os.routers.knowledge.schemas import RemoteContentSourceSchema
+
+                remote_content_sources = [
+                    RemoteContentSourceSchema(
+                        id=config.id,
+                        name=config.name,
+                        type=config.__class__.__name__.replace("Config", "").lower(),
+                        metadata=config.metadata,
+                    )
+                    for config in remote_configs
+                ]
         return ConfigResponseSchema(
             readers=reader_schemas,
             vector_dbs=vector_dbs,
             readersForType=types_of_readers,
             chunkers=chunkers_dict,
             filters=filters,
+            remote_content_sources=remote_content_sources,
         )
 
     return router

agno/os/routers/knowledge/schemas.py

@@ -170,9 +170,21 @@ class VectorSearchRequestSchema(BaseModel):
     )
 
 
+class RemoteContentSourceSchema(BaseModel):
+    """Schema for remote content source configuration."""
+
+    id: str = Field(..., description="Unique identifier for the content source")
+    name: str = Field(..., description="Display name for the content source")
+    type: str = Field(..., description="Type of content source (s3, gcs, sharepoint, github, azureblob)")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Custom metadata for the content source")
+
+
 class ConfigResponseSchema(BaseModel):
     readers: Optional[Dict[str, ReaderSchema]] = Field(None, description="Available content readers")
     readersForType: Optional[Dict[str, List[str]]] = Field(None, description="Mapping of content types to reader IDs")
     chunkers: Optional[Dict[str, ChunkerSchema]] = Field(None, description="Available chunking strategies")
     filters: Optional[List[str]] = Field(None, description="Available filter tags")
     vector_dbs: Optional[List[VectorDbSchema]] = Field(None, description="Configured vector databases")
+    remote_content_sources: Optional[List[RemoteContentSourceSchema]] = Field(
+        None, description="Configured remote content sources (S3, GCS, SharePoint, GitHub)"
+    )

agno/run/agent.py

@@ -485,6 +485,8 @@ class CompressionCompletedEvent(BaseAgentRunEvent):
 @dataclass
 class CustomEvent(BaseAgentRunEvent):
     event: str = RunEvent.custom_event.value
+    # tool_call_id for ToolExecution
+    tool_call_id: Optional[str] = None
 
     def __init__(self, **kwargs):
         # Store arbitrary attributes directly on the instance

agno/team/team.py

@@ -7852,7 +7852,7 @@ class Team:
                         stream_events=stream_events or self.stream_member_events,
                         debug_mode=debug_mode,
                         knowledge_filters=run_context.knowledge_filters
-                        if not member_agent.knowledge_filters and member_agent.knowledge
+                        if not agent.knowledge_filters and agent.knowledge
                         else None,
                         dependencies=run_context.dependencies,
                         add_dependencies_to_context=add_dependencies_to_context,
@@ -7877,7 +7877,7 @@ class Team:
                     finally:
                         _process_delegate_task_to_member(
                             member_agent_run_response,
-                            member_agent,
+                            agent,
                             member_agent_task,  # type: ignore
                             member_session_state_copy,  # type: ignore
                         )
@@ -7915,10 +7915,15 @@ class Team:
                     current_agent = member_agent
                     member_agent_task, history = _setup_delegate_task_to_member(member_agent=current_agent, task=task)
 
-                    async def run_member_agent(agent=current_agent) -> str:
+                    async def run_member_agent(
+                        member_agent=current_agent,
+                        member_agent_task=member_agent_task,
+                        history=history,
+                        member_agent_index=member_agent_index,
+                    ) -> str:
                         member_session_state_copy = copy(run_context.session_state)
 
-                        member_agent_run_response = await agent.arun(
+                        member_agent_run_response = await member_agent.arun(
                             input=member_agent_task if not history else history,
                             user_id=user_id,
                             # All members have the same session_id
@@ -8536,6 +8541,7 @@ class Team:
         # --- Handle Members reconstruction ---
         members: Optional[List[Union[Agent, "Team"]]] = None
         from agno.agent import get_agent_by_id
+        from agno.team import get_team_by_id
 
         if "members" in config and config["members"]:
             members = []
@@ -8551,6 +8557,16 @@ class Team:
                         members.append(agent)
                     else:
                         log_warning(f"Agent not found: {member_data['agent_id']}")
+                elif member_type == "team":
+                    # Handle nested teams as members
+                    if db is None:
+                        log_warning(f"Cannot load member team {member_data['team_id']}: db is None")
+                        continue
+                    nested_team = get_team_by_id(id=member_data["team_id"], db=db, registry=registry)
+                    if nested_team:
+                        members.append(nested_team)
+                    else:
+                        log_warning(f"Team not found: {member_data['team_id']}")
 
         # --- Handle reasoning_model reconstruction ---
         # TODO: implement reasoning model deserialization