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

agno/models/response.py

@@ -35,9 +35,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 +81,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,8 +124,78 @@ class ModelResponse:
 
     updated_session_state: Optional[Dict[str, Any]] = None
 
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize ModelResponse to dictionary for caching."""
+        _dict = asdict(self)
+
+        # Handle special serialization for audio
+        if self.audio is not None:
+            _dict["audio"] = self.audio.to_dict()
+
+        # Handle lists of media objects
+        if self.images is not None:
+            _dict["images"] = [img.to_dict() for img in self.images]
+        if self.videos is not None:
+            _dict["videos"] = [vid.to_dict() for vid in self.videos]
+        if self.audios is not None:
+            _dict["audios"] = [aud.to_dict() for aud in self.audios]
+        if self.files is not None:
+            _dict["files"] = [f.to_dict() for f in self.files]
+
+        # Handle tool executions
+        if self.tool_executions is not None:
+            _dict["tool_executions"] = [tool_execution.to_dict() for tool_execution in self.tool_executions]
+
+        # Handle response usage which might be a Pydantic BaseModel
+        response_usage = _dict.pop("response_usage", None)
+        if response_usage is not None:
+            try:
+                from pydantic import BaseModel
+
+                if isinstance(response_usage, BaseModel):
+                    _dict["response_usage"] = response_usage.model_dump()
+                else:
+                    _dict["response_usage"] = response_usage
+            except ImportError:
+                _dict["response_usage"] = response_usage
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ModelResponse":
+        """Reconstruct ModelResponse from cached dictionary."""
+        # Reconstruct media objects
+        if data.get("audio"):
+            data["audio"] = Audio(**data["audio"])
+
+        if data.get("images"):
+            data["images"] = [Image(**img) for img in data["images"]]
+        if data.get("videos"):
+            data["videos"] = [Video(**vid) for vid in data["videos"]]
+        if data.get("audios"):
+            data["audios"] = [Audio(**aud) for aud in data["audios"]]
+        if data.get("files"):
+            data["files"] = [File(**f) for f in data["files"]]
+
+        # Reconstruct tool executions
+        if data.get("tool_executions"):
+            data["tool_executions"] = [ToolExecution.from_dict(te) for te in data["tool_executions"]]
+
+        # Reconstruct citations
+        if data.get("citations") and isinstance(data["citations"], dict):
+            data["citations"] = Citations(**data["citations"])
+
+        # Reconstruct response usage (Metrics)
+        if data.get("response_usage") and isinstance(data["response_usage"], dict):
+            from agno.models.metrics import Metrics
+
+            data["response_usage"] = Metrics(**data["response_usage"])
+
+        return cls(**data)
+
 
 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/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,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()