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

agno/models/sambanova/sambanova.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -22,7 +22,7 @@ class Sambanova(OpenAILike):
     name: str = "Sambanova"
     provider: str = "Sambanova"
 
-    api_key: Optional[str] = getenv("SAMBANOVA_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("SAMBANOVA_API_KEY"))
     base_url: str = "https://api.sambanova.ai/v1"
 
     supports_native_structured_outputs: bool = False

agno/models/siliconflow/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.siliconflow.siliconflow import Siliconflow
+
+__all__ = [
+    "Siliconflow",
+]

agno/models/siliconflow/siliconflow.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Optional
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Siliconflow(OpenAILike):
+    """
+    A class for interacting with Siliconflow API.
+
+    Attributes:
+        id (str): The id of the Siliconflow model to use. Default is "Qwen/QwQ-32B".
+        name (str): The name of this chat model instance. Default is "Siliconflow".
+        provider (str): The provider of the model. Default is "Siliconflow".
+        api_key (str): The api key to authorize request to Siliconflow.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.siliconflow.cn/v1".
+    """
+
+    id: str = "Qwen/QwQ-32B"
+    name: str = "Siliconflow"
+    provider: str = "Siliconflow"
+    api_key: Optional[str] = getenv("SILICONFLOW_API_KEY")
+    base_url: str = "https://api.siliconflow.com/v1"

agno/models/together/together.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -21,5 +21,5 @@ class Together(OpenAILike):
     id: str = "mistralai/Mixtral-8x7B-Instruct-v0.1"
     name: str = "Together"
     provider: str = "Together"
-    api_key: Optional[str] = getenv("TOGETHER_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("TOGETHER_API_KEY"))
     base_url: str = "https://api.together.xyz/v1"

agno/models/utils.py

@@ -1,20 +1,266 @@
+from typing import Optional, Union
+
 from agno.models.base import Model
 
 
-# TODO: add all supported models
-def get_model(model_id: str, model_provider: str) -> Model:
-    """Return the right Agno model instance given a pair of model provider and id"""
-    if model_provider == "openai":
-        from agno.models.openai import OpenAIChat
+def _get_model_class(model_id: str, model_provider: str) -> Model:
+    if model_provider == "aimlapi":
+        from agno.models.aimlapi import AIMLAPI
+
+        return AIMLAPI(id=model_id)
 
-        return OpenAIChat(id=model_id)
     elif model_provider == "anthropic":
         from agno.models.anthropic import Claude
 
         return Claude(id=model_id)
-    elif model_provider == "gemini":
+
+    elif model_provider == "aws-bedrock":
+        from agno.models.aws import AwsBedrock
+
+        return AwsBedrock(id=model_id)
+
+    elif model_provider == "aws-claude":
+        from agno.models.aws import Claude as AWSClaude
+
+        return AWSClaude(id=model_id)
+
+    elif model_provider == "azure-ai-foundry":
+        from agno.models.azure import AzureAIFoundry
+
+        return AzureAIFoundry(id=model_id)
+
+    elif model_provider == "azure-openai":
+        from agno.models.azure import AzureOpenAI
+
+        return AzureOpenAI(id=model_id)
+
+    elif model_provider == "cerebras":
+        from agno.models.cerebras import Cerebras
+
+        return Cerebras(id=model_id)
+
+    elif model_provider == "cerebras-openai":
+        from agno.models.cerebras import CerebrasOpenAI
+
+        return CerebrasOpenAI(id=model_id)
+
+    elif model_provider == "cohere":
+        from agno.models.cohere import Cohere
+
+        return Cohere(id=model_id)
+
+    elif model_provider == "cometapi":
+        from agno.models.cometapi import CometAPI
+
+        return CometAPI(id=model_id)
+
+    elif model_provider == "dashscope":
+        from agno.models.dashscope import DashScope
+
+        return DashScope(id=model_id)
+
+    elif model_provider == "deepinfra":
+        from agno.models.deepinfra import DeepInfra
+
+        return DeepInfra(id=model_id)
+
+    elif model_provider == "deepseek":
+        from agno.models.deepseek import DeepSeek
+
+        return DeepSeek(id=model_id)
+
+    elif model_provider == "fireworks":
+        from agno.models.fireworks import Fireworks
+
+        return Fireworks(id=model_id)
+
+    elif model_provider == "google":
         from agno.models.google import Gemini
 
         return Gemini(id=model_id)
+
+    elif model_provider == "groq":
+        from agno.models.groq import Groq
+
+        return Groq(id=model_id)
+
+    elif model_provider == "huggingface":
+        from agno.models.huggingface import HuggingFace
+
+        return HuggingFace(id=model_id)
+
+    elif model_provider == "ibm":
+        from agno.models.ibm import WatsonX
+
+        return WatsonX(id=model_id)
+
+    elif model_provider == "internlm":
+        from agno.models.internlm import InternLM
+
+        return InternLM(id=model_id)
+
+    elif model_provider == "langdb":
+        from agno.models.langdb import LangDB
+
+        return LangDB(id=model_id)
+
+    elif model_provider == "litellm":
+        from agno.models.litellm import LiteLLM
+
+        return LiteLLM(id=model_id)
+
+    elif model_provider == "litellm-openai":
+        from agno.models.litellm import LiteLLMOpenAI
+
+        return LiteLLMOpenAI(id=model_id)
+
+    elif model_provider == "llama-cpp":
+        from agno.models.llama_cpp import LlamaCpp
+
+        return LlamaCpp(id=model_id)
+
+    elif model_provider == "llama-openai":
+        from agno.models.meta import LlamaOpenAI
+
+        return LlamaOpenAI(id=model_id)
+
+    elif model_provider == "lmstudio":
+        from agno.models.lmstudio import LMStudio
+
+        return LMStudio(id=model_id)
+
+    elif model_provider == "meta":
+        from agno.models.meta import Llama
+
+        return Llama(id=model_id)
+
+    elif model_provider == "mistral":
+        from agno.models.mistral import MistralChat
+
+        return MistralChat(id=model_id)
+
+    elif model_provider == "nebius":
+        from agno.models.nebius import Nebius
+
+        return Nebius(id=model_id)
+
+    elif model_provider == "nexus":
+        from agno.models.nexus import Nexus
+
+        return Nexus(id=model_id)
+
+    elif model_provider == "nvidia":
+        from agno.models.nvidia import Nvidia
+
+        return Nvidia(id=model_id)
+
+    elif model_provider == "ollama":
+        from agno.models.ollama import Ollama
+
+        return Ollama(id=model_id)
+
+    elif model_provider == "openai":
+        from agno.models.openai import OpenAIChat
+
+        return OpenAIChat(id=model_id)
+
+    elif model_provider == "openai-responses":
+        from agno.models.openai import OpenAIResponses
+
+        return OpenAIResponses(id=model_id)
+
+    elif model_provider == "openrouter":
+        from agno.models.openrouter import OpenRouter
+
+        return OpenRouter(id=model_id)
+
+    elif model_provider == "perplexity":
+        from agno.models.perplexity import Perplexity
+
+        return Perplexity(id=model_id)
+
+    elif model_provider == "portkey":
+        from agno.models.portkey import Portkey
+
+        return Portkey(id=model_id)
+
+    elif model_provider == "requesty":
+        from agno.models.requesty import Requesty
+
+        return Requesty(id=model_id)
+
+    elif model_provider == "sambanova":
+        from agno.models.sambanova import Sambanova
+
+        return Sambanova(id=model_id)
+
+    elif model_provider == "siliconflow":
+        from agno.models.siliconflow import Siliconflow
+
+        return Siliconflow(id=model_id)
+
+    elif model_provider == "together":
+        from agno.models.together import Together
+
+        return Together(id=model_id)
+
+    elif model_provider == "vercel":
+        from agno.models.vercel import V0
+
+        return V0(id=model_id)
+
+    elif model_provider == "vertexai-claude":
+        from agno.models.vertexai.claude import Claude as VertexAIClaude
+
+        return VertexAIClaude(id=model_id)
+
+    elif model_provider == "vllm":
+        from agno.models.vllm import VLLM
+
+        return VLLM(id=model_id)
+
+    elif model_provider == "xai":
+        from agno.models.xai import xAI
+
+        return xAI(id=model_id)
+
+    else:
+        raise ValueError(f"Model provider '{model_provider}' is not supported.")
+
+
+def _parse_model_string(model_string: str) -> Model:
+    if not model_string or not isinstance(model_string, str):
+        raise ValueError(f"Model string must be a non-empty string, got: {model_string}")
+
+    if ":" not in model_string:
+        raise ValueError(
+            f"Invalid model string format: '{model_string}'. Model strings should be in format '<provider>:<model_id>' e.g. 'openai:gpt-4o'"
+        )
+
+    parts = model_string.split(":", 1)
+    if len(parts) != 2:
+        raise ValueError(
+            f"Invalid model string format: '{model_string}'. Model strings should be in format '<provider>:<model_id>' e.g. 'openai:gpt-4o'"
+        )
+
+    model_provider, model_id = parts
+    model_provider = model_provider.strip().lower()
+    model_id = model_id.strip()
+
+    if not model_provider or not model_id:
+        raise ValueError(
+            f"Invalid model string format: '{model_string}'. Model strings should be in format '<provider>:<model_id>' e.g. 'openai:gpt-4o'"
+        )
+
+    return _get_model_class(model_id, model_provider)
+
+
+def get_model(model: Union[Model, str, None]) -> Optional[Model]:
+    if model is None:
+        return None
+    elif isinstance(model, Model):
+        return model
+    elif isinstance(model, str):
+        return _parse_model_string(model)
     else:
-        raise ValueError(f"Model provider {model_provider} not supported")
+        raise ValueError("Model must be a Model instance, string, or None")

agno/models/vercel/v0.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -22,5 +22,5 @@ class V0(OpenAILike):
     name: str = "v0"
     provider: str = "Vercel"
 
-    api_key: Optional[str] = getenv("V0_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("V0_API_KEY"))
     base_url: str = "https://api.v0.dev/v1/"

agno/models/vertexai/claude.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+import httpx
+
+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_warning
+
+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: 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
+
+    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

agno/models/vllm/vllm.py

@@ -57,6 +57,7 @@ class VLLM(OpenAILike):
         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

agno/models/xai/xai.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
@@ -34,7 +34,7 @@ class xAI(OpenAILike):
     name: str = "xAI"
     provider: str = "xAI"
 
-    api_key: Optional[str] = getenv("XAI_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("XAI_API_KEY"))
     base_url: str = "https://api.x.ai/v1"
 
     search_parameters: Optional[Dict[str, Any]] = None
@@ -44,6 +44,7 @@ class xAI(OpenAILike):
         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.