agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/models/portkey/portkey.py

@@ -1,8 +1,8 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, Optional, cast
 
-from agno.exceptions import ModelProviderError
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 try:
@@ -30,20 +30,21 @@ class Portkey(OpenAILike):
     name: str = "Portkey"
     provider: str = "Portkey"
 
-    portkey_api_key: Optional[str] = field(default_factory=lambda: getenv("PORTKEY_API_KEY"))
-    virtual_key: Optional[str] = field(default_factory=lambda: getenv("PORTKEY_VIRTUAL_KEY"))
+    portkey_api_key: Optional[str] = None
+    virtual_key: Optional[str] = None
     config: Optional[Dict[str, Any]] = None
     base_url: str = PORTKEY_GATEWAY_URL
 
     def _get_client_params(self) -> Dict[str, Any]:
         # Check for required keys
         if not self.portkey_api_key:
-            raise ModelProviderError(
+            raise ModelAuthenticationError(
                 message="PORTKEY_API_KEY not set. Please set the PORTKEY_API_KEY environment variable.",
                 model_name=self.name,
-                model_id=self.id,
             )
 
+        self.virtual_key = self.virtual_key or getenv("PORTKEY_VIRTUAL_KEY")
+
         # Create headers using Portkey's createHeaders function
         header_params: Dict[str, Any] = {
             "api_key": self.portkey_api_key,

agno/models/requesty/requesty.py

@@ -1,9 +1,10 @@
-from dataclasses import dataclass, field
+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.like import OpenAILike
 from agno.run.agent import RunOutput
 from agno.run.team import TeamRunOutput
@@ -26,10 +27,26 @@ class Requesty(OpenAILike):
     name: str = "Requesty"
     provider: str = "Requesty"
 
-    api_key: Optional[str] = field(default_factory=lambda: getenv("REQUESTY_API_KEY"))
+    api_key: Optional[str] = None
     base_url: str = "https://router.requesty.ai/v1"
     max_tokens: int = 1024
 
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for REQUESTY_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("REQUESTY_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="REQUESTY_API_KEY not set. Please set the REQUESTY_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()
+
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,

agno/models/response.py

@@ -16,6 +16,10 @@ class ModelResponseEvent(str, Enum):
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
     assistant_response = "AssistantResponse"
+    compression_started = "CompressionStarted"
+    compression_completed = "CompressionCompleted"
+    model_request_started = "ModelRequestStarted"
+    model_request_completed = "ModelRequestCompleted"
 
 
 @dataclass
@@ -35,9 +39,9 @@ class ToolExecution:
     # If True, the agent will stop executing after this tool call.
     stop_after_tool_call: bool = False
 
-    created_at: int = int(time())
+    created_at: int = field(default_factory=lambda: int(time()))
 
-    # User control flow requirements
+    # User control flow (HITL) fields
     requires_confirmation: Optional[bool] = None
     confirmed: Optional[bool] = None
     confirmation_note: Optional[str] = None
@@ -81,6 +85,7 @@ class ToolExecution:
             else None,
             external_execution_required=data.get("external_execution_required"),
             metrics=Metrics(**(data.get("metrics", {}) or {})),
+            **{"created_at": data["created_at"]} if "created_at" in data else {},
         )
 
 
@@ -123,6 +128,18 @@ class ModelResponse:
 
     updated_session_state: Optional[Dict[str, Any]] = None
 
+    # Compression stats
+    compression_stats: Optional[Dict[str, Any]] = None
+
+    # Model request metrics (for model_request_completed events)
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+    time_to_first_token: Optional[float] = None
+    reasoning_tokens: Optional[int] = None
+    cache_read_tokens: Optional[int] = None
+    cache_write_tokens: Optional[int] = None
+
     def to_dict(self) -> Dict[str, Any]:
         """Serialize ModelResponse to dictionary for caching."""
         _dict = asdict(self)
@@ -197,3 +214,4 @@ class FileType(str, Enum):
     MP4 = "mp4"
     GIF = "gif"
     MP3 = "mp3"
+    WAV = "wav"

agno/models/sambanova/sambanova.py

@@ -1,7 +1,8 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
@@ -22,7 +23,23 @@ class Sambanova(OpenAILike):
     name: str = "Sambanova"
     provider: str = "Sambanova"
 
-    api_key: Optional[str] = field(default_factory=lambda: getenv("SAMBANOVA_API_KEY"))
+    api_key: Optional[str] = None
     base_url: str = "https://api.sambanova.ai/v1"
 
     supports_native_structured_outputs: bool = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for SAMBANOVA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("SAMBANOVA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="SAMBANOVA_API_KEY not set. Please set the SAMBANOVA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/siliconflow/siliconflow.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
@@ -21,5 +22,21 @@ class Siliconflow(OpenAILike):
     id: str = "Qwen/QwQ-32B"
     name: str = "Siliconflow"
     provider: str = "Siliconflow"
-    api_key: Optional[str] = getenv("SILICONFLOW_API_KEY")
+    api_key: Optional[str] = None
     base_url: str = "https://api.siliconflow.com/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for SILICONFLOW_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("SILICONFLOW_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="SILICONFLOW_API_KEY not set. Please set the SILICONFLOW_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/together/together.py

@@ -1,7 +1,8 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
@@ -21,5 +22,21 @@ class Together(OpenAILike):
     id: str = "mistralai/Mixtral-8x7B-Instruct-v0.1"
     name: str = "Together"
     provider: str = "Together"
-    api_key: Optional[str] = field(default_factory=lambda: getenv("TOGETHER_API_KEY"))
+    api_key: Optional[str] = None
     base_url: str = "https://api.together.xyz/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for TOGETHER_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("TOGETHER_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="TOGETHER_API_KEY not set. Please set the TOGETHER_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/vercel/v0.py

@@ -1,7 +1,8 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
@@ -22,5 +23,21 @@ class V0(OpenAILike):
     name: str = "v0"
     provider: str = "Vercel"
 
-    api_key: Optional[str] = field(default_factory=lambda: getenv("V0_API_KEY"))
+    api_key: Optional[str] = None
     base_url: str = "https://api.v0.dev/v1/"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for V0_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("V0_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="V0_API_KEY not set. Please set the V0_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/vertexai/claude.py

@@ -1,8 +1,14 @@
 from dataclasses import dataclass
 from os import getenv
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Type, Union
+
+import httpx
+from pydantic import BaseModel
 
 from agno.models.anthropic import Claude as AnthropicClaude
+from agno.utils.http import get_default_async_client, get_default_sync_client
+from agno.utils.log import log_debug, log_warning
+from agno.utils.models.claude import format_tools_for_model
 
 try:
     from anthropic import AnthropicVertex, AsyncAnthropicVertex
@@ -22,14 +28,23 @@ class Claude(AnthropicClaude):
     name: str = "Claude"
     provider: str = "VertexAI"
 
-    client: Optional[AnthropicVertex] = None  # type: ignore
-    async_client: Optional[AsyncAnthropicVertex] = None  # type: ignore
-
     # Client parameters
     region: Optional[str] = None
     project_id: Optional[str] = None
     base_url: Optional[str] = None
 
+    client: Optional[AnthropicVertex] = None  # type: ignore
+    async_client: Optional[AsyncAnthropicVertex] = None  # type: ignore
+
+    def __post_init__(self):
+        """Validate model configuration after initialization"""
+        # Validate thinking support immediately at model creation
+        if self.thinking:
+            self._validate_thinking_support()
+        # Overwrite output schema support for VertexAI Claude
+        self.supports_native_structured_outputs = False
+        self.supports_json_schema_outputs = False
+
     def _get_client_params(self) -> Dict[str, Any]:
         client_params: Dict[str, Any] = {}
 
@@ -55,6 +70,16 @@ class Claude(AnthropicClaude):
             return self.client
 
         _client_params = self._get_client_params()
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                _client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
+                # Use global sync client when user http_client is invalid
+                _client_params["http_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            _client_params["http_client"] = get_default_sync_client()
         self.client = AnthropicVertex(**_client_params)
         return self.client
 
@@ -66,5 +91,100 @@ class Claude(AnthropicClaude):
             return self.async_client
 
         _client_params = self._get_client_params()
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                _client_params["http_client"] = self.http_client
+            else:
+                log_warning(
+                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
+                )
+                # Use global async client when user http_client is invalid
+                _client_params["http_client"] = get_default_async_client()
+        else:
+            # Use global async client when no custom http_client is provided
+            _client_params["http_client"] = get_default_async_client()
         self.async_client = AsyncAnthropicVertex(**_client_params)
         return self.async_client
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Generate keyword arguments for API requests.
+
+        Returns:
+            Dict[str, Any]: The keyword arguments for API requests.
+        """
+        # Validate thinking support if thinking is enabled
+        if self.thinking:
+            self._validate_thinking_support()
+
+        _request_params: Dict[str, Any] = {}
+        if self.max_tokens:
+            _request_params["max_tokens"] = self.max_tokens
+        if self.thinking:
+            _request_params["thinking"] = self.thinking
+        if self.temperature:
+            _request_params["temperature"] = self.temperature
+        if self.stop_sequences:
+            _request_params["stop_sequences"] = self.stop_sequences
+        if self.top_p:
+            _request_params["top_p"] = self.top_p
+        if self.top_k:
+            _request_params["top_k"] = self.top_k
+        if self.timeout:
+            _request_params["timeout"] = self.timeout
+
+        # Build betas list - include existing betas and add new one if needed
+        betas_list = list(self.betas) if self.betas else []
+
+        # Include betas if any are present
+        if betas_list:
+            _request_params["betas"] = betas_list
+
+        if self.request_params:
+            _request_params.update(self.request_params)
+
+        if _request_params:
+            log_debug(f"Calling {self.provider} with request parameters: {_request_params}", log_level=2)
+        return _request_params
+
+    def _prepare_request_kwargs(
+        self,
+        system_message: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Prepare the request keyword arguments for the API call.
+
+        Args:
+            system_message (str): The concatenated system messages.
+            tools: Optional list of tools
+            response_format: Optional response format (Pydantic model or dict)
+
+        Returns:
+            Dict[str, Any]: The request keyword arguments.
+        """
+        # Pass response_format and tools to get_request_params for beta header handling
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools).copy()
+        if system_message:
+            if self.cache_system_prompt:
+                cache_control = (
+                    {"type": "ephemeral", "ttl": "1h"}
+                    if self.extended_cache_time is not None and self.extended_cache_time is True
+                    else {"type": "ephemeral"}
+                )
+                request_kwargs["system"] = [{"text": system_message, "type": "text", "cache_control": cache_control}]
+            else:
+                request_kwargs["system"] = [{"text": system_message, "type": "text"}]
+
+        # Format tools (this will handle strict mode)
+        if tools:
+            request_kwargs["tools"] = format_tools_for_model(tools)
+
+        if request_kwargs:
+            log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
+        return request_kwargs

agno/models/vllm/vllm.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 from agno.utils.log import log_debug
 
@@ -29,8 +30,8 @@ class VLLM(OpenAILike):
     name: str = "VLLM"
     provider: str = "VLLM"
 
-    api_key: Optional[str] = getenv("VLLM_API_KEY") or "EMPTY"
-    base_url: Optional[str] = getenv("VLLM_BASE_URL", "http://localhost:8000/v1/")
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
 
     temperature: float = 0.7
     top_p: float = 0.8
@@ -38,19 +39,23 @@ class VLLM(OpenAILike):
     top_k: Optional[int] = None
     enable_thinking: Optional[bool] = None
 
-    def __post_init__(self):
-        """Validate required configuration"""
-        if not self.base_url:
-            raise ValueError("VLLM_BASE_URL must be set via environment variable or explicit initialization")
-        if self.id == "not-set":
-            raise ValueError("Model ID must be set via environment variable or explicit initialization")
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for VLLM_API_KEY.
 
-        body: Dict[str, Any] = {}
-        if self.top_k is not None:
-            body["top_k"] = self.top_k
-        if self.enable_thinking is not None:
-            body["chat_template_kwargs"] = {"enable_thinking": self.enable_thinking}
-        self.extra_body = body or None
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("VLLM_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="VLLM_API_KEY not set. Please set the VLLM_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        if not self.base_url:
+            self.base_url = getenv("VLLM_BASE_URL", "http://localhost:8000/v1/")
+        return super()._get_client_params()
 
     def get_request_params(
         self,

agno/models/xai/xai.py

@@ -1,9 +1,10 @@
-from dataclasses import dataclass, field
+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.message import Citations, UrlCitation
 from agno.models.openai.like import OpenAILike
 from agno.models.response import ModelResponse
@@ -34,11 +35,27 @@ class xAI(OpenAILike):
     name: str = "xAI"
     provider: str = "xAI"
 
-    api_key: Optional[str] = field(default_factory=lambda: getenv("XAI_API_KEY"))
+    api_key: Optional[str] = None
     base_url: str = "https://api.x.ai/v1"
 
     search_parameters: Optional[Dict[str, Any]] = None
 
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for XAI_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("XAI_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="XAI_API_KEY not set. Please set the XAI_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()
+
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,