agno 2.2.4__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/app.py

@@ -224,13 +224,59 @@ class AgentOS:
         except (ValueError, TypeError):
             return lifespan
 
-    def resync(self) -> None:
+    def resync(self, app: FastAPI) -> None:
         """Resync the AgentOS to discover, initialize and configure: agents, teams, workflows, databases and knowledge bases."""
         self._initialize_agents()
         self._initialize_teams()
         self._initialize_workflows()
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
+        self._reprovision_routers(app=app)
+
+    def _reprovision_routers(self, app: FastAPI) -> None:
+        """Re-provision all routes for the AgentOS."""
+        updated_routers = [
+            get_session_router(dbs=self.dbs),
+            get_memory_router(dbs=self.dbs),
+            get_eval_router(dbs=self.dbs, agents=self.agents, teams=self.teams),
+            get_metrics_router(dbs=self.dbs),
+            get_knowledge_router(knowledge_instances=self.knowledge_instances),
+        ]
+
+        # Clear all previously existing routes
+        app.router.routes = []
+
+        # Add the updated routes
+        for router in updated_routers:
+            self._add_router(app, router)
+
+        # Add the built-in routes
+        self._add_built_in_routes(app=app)
+
+    def _add_built_in_routes(self, app: FastAPI) -> None:
+        """Add all AgentOSbuilt-in routes to the given app."""
+        self._add_router(app, get_base_router(self, settings=self.settings))
+        self._add_router(app, get_websocket_router(self, settings=self.settings))
+        self._add_router(app, get_health_router())
+        self._add_router(app, get_home_router(self))
+
+        # Add A2A interface if relevant
+        has_a2a_interface = False
+        for interface in self.interfaces:
+            if not has_a2a_interface and interface.__class__.__name__ == "A2A":
+                has_a2a_interface = True
+            interface_router = interface.get_router()
+            self._add_router(app, interface_router)
+        if self.a2a_interface and not has_a2a_interface:
+            from agno.os.interfaces.a2a import A2A
+
+            a2a_interface = A2A(agents=self.agents, teams=self.teams, workflows=self.workflows)
+            self.interfaces.append(a2a_interface)
+            self._add_router(app, a2a_interface.get_router())
+
+        # Add the home router if MCP server is not enabled
+        if not self.enable_mcp_server:
+            self._add_router(app, get_home_router(self))
 
     def _make_app(self, lifespan: Optional[Any] = None) -> FastAPI:
         # Adjust the FastAPI app lifespan to handle MCP connections if relevant
@@ -381,26 +427,7 @@ class AgentOS:
 
                 fastapi_app = self._make_app(lifespan=wrapped_user_lifespan)
 
-        # Add routes
-        self._add_router(fastapi_app, get_base_router(self, settings=self.settings))
-        self._add_router(fastapi_app, get_websocket_router(self, settings=self.settings))
-        self._add_router(fastapi_app, get_health_router())
-        self._add_router(fastapi_app, get_home_router(self))
-
-        has_a2a_interface = False
-        for interface in self.interfaces:
-            if not has_a2a_interface and interface.__class__.__name__ == "A2A":
-                has_a2a_interface = True
-            interface_router = interface.get_router()
-            self._add_router(fastapi_app, interface_router)
-
-        # Add A2A interface if requested and not provided in self.interfaces
-        if self.a2a_interface and not has_a2a_interface:
-            from agno.os.interfaces.a2a import A2A
-
-            a2a_interface = A2A(agents=self.agents, teams=self.teams, workflows=self.workflows)
-            self.interfaces.append(a2a_interface)
-            self._add_router(fastapi_app, a2a_interface.get_router())
+        self._add_built_in_routes(app=fastapi_app)
 
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()