agno 2.2.13__py3-none-any.whl

agno/models/together/together.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Optional
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Together(OpenAILike):
+    """
+    A class for interacting with Together API.
+
+    Attributes:
+        id (str): The id of the Together model to use. Default is "mistralai/Mixtral-8x7B-Instruct-v0.1".
+        name (str): The name of this chat model instance. Default is "Together"
+        provider (str): The provider of the model. Default is "Together".
+        api_key (str): The api key to authorize request to Together.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.together.xyz/v1".
+    """
+
+    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"))
+    base_url: str = "https://api.together.xyz/v1"

agno/models/utils.py

@@ -0,0 +1,266 @@
+from typing import Optional, Union
+
+from agno.models.base import Model
+
+
+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)
+
+    elif model_provider == "anthropic":
+        from agno.models.anthropic import Claude
+
+        return Claude(id=model_id)
+
+    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("Model must be a Model instance, string, or None")

agno/models/vercel/__init__.py

@@ -0,0 +1,3 @@
+from agno.models.vercel.v0 import V0
+
+__all__ = ["V0"]

agno/models/vercel/v0.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Optional
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class V0(OpenAILike):
+    """
+    Class for interacting with the v0 API.
+
+    Attributes:
+        id (str): The ID of the language model. Defaults to "v0-1.0-md".
+        name (str): The name of the API. Defaults to "v0".
+        provider (str): The provider of the API. Defaults to "v0".
+        api_key (Optional[str]): The API key for the v0 API.
+        base_url (Optional[str]): The base URL for the v0 API. Defaults to "https://v0.dev/chat/settings/keys".
+    """
+
+    id: str = "v0-1.0-md"
+    name: str = "v0"
+    provider: str = "Vercel"
+
+    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,70 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.models.anthropic import Claude as AnthropicClaude
+
+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()
+        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()
+        self.async_client = AsyncAnthropicVertex(**_client_params)
+        return self.async_client

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,78 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+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] = getenv("VLLM_API_KEY") or "EMPTY"
+    base_url: Optional[str] = getenv("VLLM_BASE_URL", "http://localhost:8000/v1/")
+
+    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 __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")
+
+        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
+
+    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

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

agno/models/xai/xai.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+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
+class xAI(OpenAILike):
+    """
+    Class for interacting with the xAI API.
+
+    Attributes:
+        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. 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] = field(default_factory=lambda: getenv("XAI_API_KEY"))
+    base_url: str = "https://api.x.ai/v1"
+
+    search_parameters: Optional[Dict[str, Any]] = None
+
+    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"]