agno 2.2.5__py3-none-any.whl → 2.2.6__py3-none-any.whl

agno/models/cerebras/cerebras.py

@@ -63,7 +63,7 @@ class Cerebras(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Cerebras clients
@@ -102,12 +102,15 @@ class Cerebras(Model):
         Returns:
             CerebrasClient: An instance of the Cerebras client.
         """
-        if self.client:
+        if self.client and not self.client.is_closed():
             return self.client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client is not None:
-            client_params["http_client"] = self.http_client
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_client"] = self.http_client
+            else:
+                log_debug("http_client is not an instance of httpx.Client.")
         self.client = CerebrasClient(**client_params)
         return self.client
 
@@ -118,13 +121,15 @@ class Cerebras(Model):
         Returns:
             AsyncCerebras: An instance of the asynchronous Cerebras client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client:
+        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
             client_params["http_client"] = self.http_client
         else:
+            if self.http_client:
+                log_debug("The current http_client is not async. A default httpx.AsyncClient will be used instead.")
             # Create a new async HTTP client with custom limits
             client_params["http_client"] = httpx.AsyncClient(
                 limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)

agno/models/groq/groq.py

@@ -61,7 +61,7 @@ class Groq(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Groq clients
@@ -115,18 +115,21 @@ class Groq(Model):
         Returns:
             AsyncGroqClient: An instance of the asynchronous Groq client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client:
+        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
             client_params["http_client"] = self.http_client
         else:
+            if self.http_client:
+                log_debug("The current http_client is not async. A default httpx.AsyncClient will be used instead.")
             # Create a new async HTTP client with custom limits
             client_params["http_client"] = httpx.AsyncClient(
                 limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
             )
-        return AsyncGroqClient(**client_params)
+        self.async_client = AsyncGroqClient(**client_params)
+        return self.async_client
 
     def get_request_params(
         self,

agno/models/meta/llama.py

@@ -61,7 +61,7 @@ class Llama(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # OpenAI clients
@@ -104,8 +104,11 @@ class Llama(Model):
             return self.client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client is not None:
-            client_params["http_client"] = self.http_client
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_client"] = self.http_client
+            else:
+                log_debug("http_client is not an instance of httpx.Client.")
         self.client = LlamaAPIClient(**client_params)
         return self.client
 
@@ -116,18 +119,21 @@ class Llama(Model):
         Returns:
             AsyncLlamaAPIClient: An instance of the asynchronous Llama client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client:
+        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
             client_params["http_client"] = self.http_client
         else:
+            if self.http_client:
+                log_debug("The current http_client is not async. A default httpx.AsyncClient will be used instead.")
             # Create a new async HTTP client with custom limits
             client_params["http_client"] = httpx.AsyncClient(
                 limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
             )
-        return AsyncLlamaAPIClient(**client_params)
+        self.async_client = AsyncLlamaAPIClient(**client_params)
+        return self.async_client
 
     def get_request_params(
         self,

agno/models/meta/llama_openai.py

@@ -62,6 +62,9 @@ class LlamaOpenAI(OpenAILike):
 
     def get_async_client(self):
         """Override to provide custom httpx client that properly handles redirects"""
+        if self.async_client and not self.async_client.is_closed():
+            return self.async_client
+
         client_params = self._get_client_params()
 
         # Llama gives a 307 redirect error, so we need to set up a custom client to allow redirects
@@ -71,4 +74,5 @@ class LlamaOpenAI(OpenAILike):
             timeout=httpx.Timeout(30.0),
         )
 
-        return AsyncOpenAIClient(**client_params)
+        self.async_client = AsyncOpenAIClient(**client_params)
+        return self.async_client

agno/models/openai/chat.py

@@ -81,6 +81,10 @@ class OpenAIChat(Model):
     http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
+    # OpenAI clients
+    client: Optional[OpenAIClient] = None
+    async_client: Optional[AsyncOpenAIClient] = None
+
     # The role to map the message role to.
     default_role_map = {
         "system": "developer",
@@ -123,13 +127,18 @@ class OpenAIChat(Model):
         Returns:
             OpenAIClient: An instance of the OpenAI client.
         """
+        if self.client and not self.client.is_closed():
+            return self.client
+
         client_params: Dict[str, Any] = 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.")
-        return OpenAIClient(**client_params)
+                log_debug("http_client is not an instance of httpx.Client.")
+
+        self.client = OpenAIClient(**client_params)
+        return self.client
 
     def get_async_client(self) -> AsyncOpenAIClient:
         """
@@ -138,22 +147,21 @@ class OpenAIChat(Model):
         Returns:
             AsyncOpenAIClient: An instance of the asynchronous OpenAI client.
         """
+        if self.async_client and not self.async_client.is_closed():
+            return self.async_client
+
         client_params: Dict[str, Any] = 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 httpx.AsyncClient.")
-                # Create a new async HTTP client with custom limits
-                client_params["http_client"] = httpx.AsyncClient(
-                    limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
-                )
+        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
+            client_params["http_client"] = self.http_client
         else:
+            if self.http_client:
+                log_debug("The current http_client is not async. A default httpx.AsyncClient will be used instead.")
             # Create a new async HTTP client with custom limits
             client_params["http_client"] = httpx.AsyncClient(
                 limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
             )
-        return AsyncOpenAIClient(**client_params)
+        self.async_client = AsyncOpenAIClient(**client_params)
+        return self.async_client
 
     def get_request_params(
         self,

agno/models/openai/responses.py

@@ -66,7 +66,7 @@ class OpenAIResponses(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Dict[str, str]] = None
     default_query: Optional[Dict[str, str]] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Parameters affecting built-in tools
@@ -148,8 +148,11 @@ class OpenAIResponses(Model):
             return self.client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client is not None:
-            client_params["http_client"] = self.http_client
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_client"] = self.http_client
+            else:
+                log_debug("http_client is not an instance of httpx.Client.")
 
         self.client = OpenAI(**client_params)
         return self.client
@@ -161,13 +164,15 @@ class OpenAIResponses(Model):
         Returns:
             AsyncOpenAI: An instance of the asynchronous OpenAI client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client:
+        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
             client_params["http_client"] = self.http_client
         else:
+            if self.http_client:
+                log_debug("The current http_client is not async. A default httpx.AsyncClient will be used instead.")
             # Create a new async HTTP client with custom limits
             client_params["http_client"] = httpx.AsyncClient(
                 limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)

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/vertexai/claude.py

@@ -5,10 +5,7 @@ from typing import Any, Dict, Optional
 from agno.models.anthropic import Claude as AnthropicClaude
 
 try:
-    from anthropic import AnthropicVertex as AnthropicClient
-    from anthropic import (
-        AsyncAnthropicVertex as AsyncAnthropicClient,
-    )
+    from anthropic import AnthropicVertex, AsyncAnthropicVertex
 except ImportError as e:
     raise ImportError("`anthropic` not installed. Please install it with `pip install anthropic`") from e
 
@@ -25,15 +22,14 @@ 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
 
-    # Anthropic clients
-    client: Optional[AnthropicClient] = None
-    async_client: Optional[AsyncAnthropicClient] = None
-
     def _get_client_params(self) -> Dict[str, Any]:
         client_params: Dict[str, Any] = {}
 
@@ -51,7 +47,7 @@ class Claude(AnthropicClaude):
             client_params["default_headers"] = self.default_headers
         return client_params
 
-    def get_client(self) -> AnthropicClient:
+    def get_client(self):
         """
         Returns an instance of the Anthropic client.
         """
@@ -59,16 +55,16 @@ class Claude(AnthropicClaude):
             return self.client
 
         _client_params = self._get_client_params()
-        self.client = AnthropicClient(**_client_params)
+        self.client = AnthropicVertex(**_client_params)
         return self.client
 
-    def get_async_client(self) -> AsyncAnthropicClient:
+    def get_async_client(self):
         """
         Returns an instance of the async Anthropic client.
         """
-        if self.async_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 = AsyncAnthropicClient(**_client_params)
+        self.async_client = AsyncAnthropicVertex(**_client_params)
         return self.async_client

agno/os/routers/evals/evals.py

@@ -356,10 +356,10 @@ def attach_routes(
             ):
                 default_model = deepcopy(agent.model)
                 if eval_run_input.model_id != agent.model.id or eval_run_input.model_provider != agent.model.provider:
-                    model = get_model(
-                        model_id=eval_run_input.model_id.lower(),
-                        model_provider=eval_run_input.model_provider.lower(),
-                    )
+                    model_provider = eval_run_input.model_provider.lower()
+                    model_id = eval_run_input.model_id.lower()
+                    model_string = f"{model_provider}:{model_id}"
+                    model = get_model(model_string)
                     agent.model = model
 
             team = None
@@ -378,10 +378,10 @@ def attach_routes(
             ):
                 default_model = deepcopy(team.model)
                 if eval_run_input.model_id != team.model.id or eval_run_input.model_provider != team.model.provider:
-                    model = get_model(
-                        model_id=eval_run_input.model_id.lower(),
-                        model_provider=eval_run_input.model_provider.lower(),
-                    )
+                    model_provider = eval_run_input.model_provider.lower()
+                    model_id = eval_run_input.model_id.lower()
+                    model_string = f"{model_provider}:{model_id}"
+                    model = get_model(model_string)
                     team.model = model
 
             agent = None

agno/os/routers/evals/utils.py

@@ -33,6 +33,7 @@ async def run_accuracy_eval(
         additional_context=eval_run_input.additional_context,
         num_iterations=eval_run_input.num_iterations or 1,
         name=eval_run_input.name,
+        model=default_model,
     )
 
     result = accuracy_eval.run(print_results=False, print_summary=False)