agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/models/vertexai/claude.py

@@ -0,0 +1,190 @@
+from dataclasses import dataclass
+from os import getenv
+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
+except ImportError as e:
+    raise ImportError("`anthropic` not installed. Please install it with `pip install anthropic`") from e
+
+
+@dataclass
+class Claude(AnthropicClaude):
+    """
+    A class representing Anthropic Claude model.
+
+    For more information, see: https://docs.anthropic.com/en/api/messages
+    """
+
+    id: str = "claude-sonnet-4@20250514"
+    name: str = "Claude"
+    provider: str = "VertexAI"
+
+    # 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] = {}
+
+        # Add API key to client parameters
+        client_params["region"] = self.region or getenv("CLOUD_ML_REGION")
+        client_params["project_id"] = self.project_id or getenv("ANTHROPIC_VERTEX_PROJECT_ID")
+        client_params["base_url"] = self.base_url or getenv("ANTHROPIC_VERTEX_BASE_URL")
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
+        # Add additional client parameters
+        if self.client_params is not None:
+            client_params.update(self.client_params)
+        if self.default_headers is not None:
+            client_params["default_headers"] = self.default_headers
+        return client_params
+
+    def get_client(self):
+        """
+        Returns an instance of the Anthropic client.
+        """
+        if self.client and not self.client.is_closed():
+            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
+
+    def get_async_client(self):
+        """
+        Returns an instance of the async Anthropic client.
+        """
+        if self.async_client and not self.async_client.is_closed():
+            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/__init__.py

@@ -0,0 +1,3 @@
+from agno.models.vllm.vllm import VLLM
+
+__all__ = ["VLLM"]

agno/models/vllm/vllm.py

@@ -0,0 +1,83 @@
+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.utils.log import log_debug
+
+
+@dataclass
+class VLLM(OpenAILike):
+    """
+    Class for interacting with vLLM models via OpenAI-compatible API.
+
+    Attributes:
+        id: Model identifier
+        name: API name
+        provider: API provider
+        base_url: vLLM server URL
+        temperature: Sampling temperature
+        top_p: Nucleus sampling probability
+        presence_penalty: Repetition penalty
+        top_k: Top-k sampling
+        enable_thinking: Special mode flag
+    """
+
+    id: str = "not-set"
+    name: str = "VLLM"
+    provider: str = "VLLM"
+
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    temperature: float = 0.7
+    top_p: float = 0.8
+    presence_penalty: float = 1.5
+    top_k: Optional[int] = None
+    enable_thinking: Optional[bool] = None
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for VLLM_API_KEY.
+
+        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,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        request_kwargs = super().get_request_params(
+            response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
+
+        vllm_body: Dict[str, Any] = {}
+        if self.top_k is not None:
+            vllm_body["top_k"] = self.top_k
+        if self.enable_thinking is not None:
+            vllm_body.setdefault("chat_template_kwargs", {})["enable_thinking"] = self.enable_thinking
+
+        if vllm_body:
+            existing_body = request_kwargs.get("extra_body") or {}
+            request_kwargs["extra_body"] = {**existing_body, **vllm_body}
+
+        if request_kwargs:
+            log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
+        return request_kwargs

agno/models/xai/__init__.py

@@ -1 +1,3 @@
 from agno.models.xai.xai import xAI
+
+__all__ = ["xAI"]

agno/models/xai/xai.py

@@ -1,8 +1,20 @@
 from dataclasses import dataclass
 from os import getenv
-from typing import Optional
+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
+from agno.utils.log import log_debug
+
+try:
+    from openai.types.chat.chat_completion import ChatCompletion
+    from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+except (ImportError, ModuleNotFoundError):
+    raise ImportError("`openai` not installed. Please install using `pip install openai`")
 
 
 @dataclass
@@ -11,16 +23,108 @@ class xAI(OpenAILike):
     Class for interacting with the xAI API.
 
     Attributes:
-        id (str): The ID of the language model.
-        name (str): The name of the API.
-        provider (str): The provider of the API.
+        id (str): The ID of the language model. Defaults to "grok-beta".
+        name (str): The name of the API. Defaults to "xAI".
+        provider (str): The provider of the API. Defaults to "xAI".
         api_key (Optional[str]): The API key for the xAI API.
-        base_url (Optional[str]): The base URL for the xAI API.
+        base_url (Optional[str]): The base URL for the xAI API. Defaults to "https://api.x.ai/v1".
+        search_parameters (Optional[Dict[str, Any]]): Search parameters for enabling live search.
     """
 
     id: str = "grok-beta"
     name: str = "xAI"
     provider: str = "xAI"
 
-    api_key: Optional[str] = getenv("XAI_API_KEY")
-    base_url: Optional[str] = "https://api.x.ai/v1"
+    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,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """
+        Returns keyword arguments for API requests, including search parameters.
+
+        Returns:
+            Dict[str, Any]: A dictionary of keyword arguments for API requests.
+        """
+        request_params = super().get_request_params(
+            response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
+
+        if self.search_parameters:
+            existing_body = request_params.get("extra_body") or {}
+            existing_body.update({"search_parameters": self.search_parameters})
+            request_params["extra_body"] = existing_body
+
+        if request_params:
+            log_debug(f"Calling {self.provider} with request parameters: {request_params}", log_level=2)
+
+        return request_params
+
+    def _parse_provider_response(
+        self,
+        response: ChatCompletion,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> ModelResponse:
+        """
+        Parse the xAI response into a ModelResponse.
+        """
+        model_response = super()._parse_provider_response(response, response_format)
+
+        if hasattr(response, "citations") and response.citations:  # type: ignore
+            citations = Citations()
+            url_citations = []
+            for citation_url in response.citations:  # type: ignore
+                url_citations.append(UrlCitation(url=str(citation_url)))
+
+            citations.urls = url_citations
+            citations.raw = response.citations  # type: ignore
+            model_response.citations = citations
+
+        return model_response
+
+    def _parse_provider_response_delta(self, response_delta: ChatCompletionChunk) -> ModelResponse:
+        """
+        Parse the xAI streaming response.
+
+        Args:
+            response_delta: Raw response chunk
+
+        Returns:
+            ModelResponse: Parsed response data
+        """
+        model_response = super()._parse_provider_response_delta(response_delta)
+
+        if hasattr(response_delta, "citations") and response_delta.citations:  # type: ignore
+            citations = Citations()
+            url_citations = []
+            for citation_url in response_delta.citations:  # type: ignore
+                url_citations.append(UrlCitation(url=str(citation_url)))
+
+            citations.urls = url_citations
+            citations.raw = response_delta.citations  # type: ignore
+            model_response.citations = citations
+
+        return model_response

agno/os/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.app import AgentOS
+
+__all__ = ["AgentOS"]