agno 2.2.13__py3-none-any.whl → 2.3.1__py3-none-any.whl

agno/models/cerebras/cerebras.py

@@ -12,6 +12,7 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
@@ -107,11 +108,11 @@ class Cerebras(Model):
             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_debug("http_client is not an instance of httpx.Client.")
+        if self.http_client is not None:
+            client_params["http_client"] = self.http_client
+        else:
+            # Use global sync client when no custom http_client is provided
+            client_params["http_client"] = get_default_sync_client()
         self.client = CerebrasClient(**client_params)
         return self.client
 
@@ -129,12 +130,8 @@ class Cerebras(Model):
         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)
-            )
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
         self.async_client = AsyncCerebrasClient(**client_params)
         return self.async_client
 

agno/models/cohere/chat.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Type, Union
 
+import httpx
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError
@@ -10,7 +11,8 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
-from agno.utils.log import log_debug, log_error
+from agno.utils.http import get_default_async_client, get_default_sync_client
+from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.cohere import format_messages
 
 try:
@@ -50,6 +52,7 @@ class Cohere(Model):
     # -*- Client parameters
     api_key: Optional[str] = None
     client_params: Optional[Dict[str, Any]] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     # -*- Provide the Cohere client manually
     client: Optional[CohereClient] = None
     async_client: Optional[CohereAsyncClient] = None
@@ -66,6 +69,17 @@ class Cohere(Model):
 
         _client_params["api_key"] = self.api_key
 
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                _client_params["httpx_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["httpx_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            _client_params["httpx_client"] = get_default_sync_client()
+
         self.client = CohereClient(**_client_params)
         return self.client  # type: ignore
 
@@ -82,6 +96,18 @@ class Cohere(Model):
 
         _client_params["api_key"] = self.api_key
 
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                _client_params["httpx_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["httpx_client"] = get_default_async_client()
+        else:
+            # Use global async client when no custom http_client is provided
+            _client_params["httpx_client"] = get_default_async_client()
         self.async_client = CohereAsyncClient(**_client_params)
         return self.async_client  # type: ignore
 

agno/models/google/gemini.py

@@ -1,3 +1,4 @@
+import base64
 import json
 import time
 from collections.abc import AsyncIterator
@@ -480,14 +481,18 @@ class Gemini(Model):
             if role == "model" and message.tool_calls is not None and len(message.tool_calls) > 0:
                 if content is not None:
                     content_str = content if isinstance(content, str) else str(content)
-                    message_parts.append(Part.from_text(text=content_str))
+                    part = Part.from_text(text=content_str)
+                    if message.provider_data and "thought_signature" in message.provider_data:
+                        part.thought_signature = base64.b64decode(message.provider_data["thought_signature"])
+                    message_parts.append(part)
                 for tool_call in message.tool_calls:
-                    message_parts.append(
-                        Part.from_function_call(
-                            name=tool_call["function"]["name"],
-                            args=json.loads(tool_call["function"]["arguments"]),
-                        )
+                    part = Part.from_function_call(
+                        name=tool_call["function"]["name"],
+                        args=json.loads(tool_call["function"]["arguments"]),
                     )
+                    if "thought_signature" in tool_call:
+                        part.thought_signature = base64.b64decode(tool_call["thought_signature"])
+                    message_parts.append(part)
             # Function call results
             elif message.tool_calls is not None and len(message.tool_calls) > 0:
                 for tool_call in message.tool_calls:
@@ -499,7 +504,10 @@ class Gemini(Model):
             # Regular text content
             else:
                 if isinstance(content, str):
-                    message_parts = [Part.from_text(text=content)]
+                    part = Part.from_text(text=content)
+                    if message.provider_data and "thought_signature" in message.provider_data:
+                        part.thought_signature = base64.b64decode(message.provider_data["thought_signature"])
+                    message_parts = [part]
 
             if role == "user" and message.tool_calls is None:
                 # Add images to the message for the model
@@ -834,6 +842,14 @@ class Gemini(Model):
                             else:
                                 model_response.content += content_str
 
+                    # Capture thought signature for text parts
+                    if hasattr(part, "thought_signature") and part.thought_signature:
+                        if model_response.provider_data is None:
+                            model_response.provider_data = {}
+                        model_response.provider_data["thought_signature"] = base64.b64encode(
+                            part.thought_signature
+                        ).decode("ascii")
+
                 if hasattr(part, "inline_data") and part.inline_data is not None:
                     # Handle audio responses (for TTS models)
                     if part.inline_data.mime_type and part.inline_data.mime_type.startswith("audio/"):
@@ -865,6 +881,10 @@ class Gemini(Model):
                         },
                     }
 
+                    # Capture thought signature for function calls
+                    if hasattr(part, "thought_signature") and part.thought_signature:
+                        tool_call["thought_signature"] = base64.b64encode(part.thought_signature).decode("ascii")
+
                     model_response.tool_calls.append(tool_call)
 
             citations = Citations()
@@ -956,6 +976,14 @@ class Gemini(Model):
                             else:
                                 model_response.content += text_content
 
+                        # Capture thought signature for text parts
+                        if hasattr(part, "thought_signature") and part.thought_signature:
+                            if model_response.provider_data is None:
+                                model_response.provider_data = {}
+                            model_response.provider_data["thought_signature"] = base64.b64encode(
+                                part.thought_signature
+                            ).decode("ascii")
+
                     if hasattr(part, "inline_data") and part.inline_data is not None:
                         # Audio responses
                         if part.inline_data.mime_type and part.inline_data.mime_type.startswith("audio/"):
@@ -989,6 +1017,10 @@ class Gemini(Model):
                             },
                         }
 
+                        # Capture thought signature for function calls
+                        if hasattr(part, "thought_signature") and part.thought_signature:
+                            tool_call["thought_signature"] = base64.b64encode(part.thought_signature).decode("ascii")
+
                         model_response.tool_calls.append(tool_call)
 
             if response_delta.candidates[0].grounding_metadata is not None:

agno/models/groq/groq.py

@@ -12,6 +12,7 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.openai import images_to_message
 
@@ -93,7 +94,7 @@ class Groq(Model):
 
     def get_client(self) -> GroqClient:
         """
-        Returns a Groq client.
+        Returns a Groq client. Caches the client to avoid recreating it on every request.
 
         Returns:
             GroqClient: An instance of the Groq client.
@@ -103,14 +104,22 @@ class Groq(Model):
 
         client_params: Dict[str, Any] = self._get_client_params()
         if self.http_client is not None:
-            client_params["http_client"] = 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 = GroqClient(**client_params)
         return self.client
 
     def get_async_client(self) -> AsyncGroqClient:
         """
-        Returns an asynchronous Groq client.
+        Returns an asynchronous Groq client. Caches the client to avoid recreating it on every request.
 
         Returns:
             AsyncGroqClient: An instance of the asynchronous Groq client.
@@ -119,15 +128,20 @@ class Groq(Model):
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
-            client_params["http_client"] = self.http_client
+        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:
-            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)
-            )
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
+
+        # Create and cache the client
         self.async_client = AsyncGroqClient(**client_params)
         return self.async_client
 

agno/models/meta/llama.py

@@ -12,6 +12,7 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.llama import format_message
 
@@ -108,7 +109,12 @@ class Llama(Model):
             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.")
+                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 = LlamaAPIClient(**client_params)
         return self.client
 
@@ -123,15 +129,20 @@ class Llama(Model):
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
-            client_params["http_client"] = self.http_client
+        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:
-            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)
-            )
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
+
+        # Create and cache the client
         self.async_client = AsyncLlamaAPIClient(**client_params)
         return self.async_client
 

agno/models/meta/llama_openai.py

@@ -2,8 +2,6 @@ from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
-import httpx
-
 try:
     from openai import AsyncOpenAI as AsyncOpenAIClient
 except ImportError:
@@ -48,6 +46,9 @@ class LlamaOpenAI(OpenAILike):
     supports_native_structured_outputs: bool = False
     supports_json_schema_outputs: bool = True
 
+    # Cached async client
+    openai_async_client: Optional[AsyncOpenAIClient] = None
+
     def _format_message(self, message: Message) -> Dict[str, Any]:
         """
         Format a message into the format expected by Llama API.
@@ -59,20 +60,3 @@ class LlamaOpenAI(OpenAILike):
             Dict[str, Any]: The formatted message.
         """
         return format_message(message, openai_like=True)
-
-    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
-        client_params["http_client"] = httpx.AsyncClient(
-            limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100),
-            follow_redirects=True,
-            timeout=httpx.Timeout(30.0),
-        )
-
-        self.async_client = AsyncOpenAIClient(**client_params)
-        return self.async_client

agno/models/nebius/nebius.py

@@ -9,22 +9,22 @@ from agno.models.openai.like import OpenAILike
 @dataclass
 class Nebius(OpenAILike):
     """
-    A class for interacting with Nebius AI Studio models.
+    A class for interacting with Nebius Token Factory models.
 
     Attributes:
         id (str): The model id. Defaults to "Qwen/Qwen3-235B-A22B"".
         name (str): The model name. Defaults to "Nebius".
         provider (str): The provider name. Defaults to "Nebius".
         api_key (Optional[str]): The API key.
-        base_url (str): The base URL. Defaults to "https://api.studio.nebius.com/v1".
+        base_url (str): The base URL. Defaults to "https://api.tokenfactory.nebius.com/v1".
     """
 
-    id: str = "Qwen/Qwen3-4B-fast"  # Default model for chat
+    id: str = "openai/gpt-oss-20b"  # Default model for chat
     name: str = "Nebius"
     provider: str = "Nebius"
 
     api_key: Optional[str] = field(default_factory=lambda: getenv("NEBIUS_API_KEY"))
-    base_url: str = "https://api.studio.nebius.com/v1/"
+    base_url: str = "https://api.tokenfactory.nebius.com/v1/"
 
     def _get_client_params(self) -> Dict[str, Any]:
         if not self.api_key:

agno/models/openai/chat.py

@@ -15,6 +15,7 @@ from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
 from agno.run.team import TeamRunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.openai import _format_file_for_message, audio_to_message, images_to_message
 from agno.utils.reasoning import extract_thinking_content
@@ -83,7 +84,7 @@ class OpenAIChat(Model):
     http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
-    # OpenAI clients
+    # Cached clients to avoid recreating them on every request
     client: Optional[OpenAIClient] = None
     async_client: Optional[AsyncOpenAIClient] = None
 
@@ -124,44 +125,59 @@ class OpenAIChat(Model):
 
     def get_client(self) -> OpenAIClient:
         """
-        Returns an OpenAI client.
+        Returns an OpenAI client. Caches the client to avoid recreating it on every request.
 
         Returns:
             OpenAIClient: An instance of the OpenAI client.
         """
-        if self.client and not self.client.is_closed():
+        # Return cached client if it exists and is not closed
+        if self.client is not None and not self.client.is_closed():
             return self.client
 
+        log_debug(f"Creating new sync OpenAI client for model {self.id}")
         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_debug("http_client is not an instance of httpx.Client.")
+                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()
 
+        # Create and cache the client
         self.client = OpenAIClient(**client_params)
         return self.client
 
     def get_async_client(self) -> AsyncOpenAIClient:
         """
-        Returns an asynchronous OpenAI client.
+        Returns an asynchronous OpenAI client. Caches the client to avoid recreating it on every request.
 
         Returns:
             AsyncOpenAIClient: An instance of the asynchronous OpenAI client.
         """
-        if self.async_client and not self.async_client.is_closed():
+        # Return cached client if it exists and is not closed
+        if self.async_client is not None and not self.async_client.is_closed():
             return self.async_client
 
+        log_debug(f"Creating new async OpenAI client for model {self.id}")
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
-            client_params["http_client"] = self.http_client
+        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:
-            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)
-            )
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
+
+        # Create and cache the client
         self.async_client = AsyncOpenAIClient(**client_params)
         return self.async_client
 

agno/models/openai/responses.py

@@ -13,6 +13,7 @@ from agno.models.message import Citations, Message, UrlCitation
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.openai_responses import images_to_message
 from agno.utils.models.schema_utils import get_response_schema_for_provider
@@ -140,7 +141,7 @@ class OpenAIResponses(Model):
 
     def get_client(self) -> OpenAI:
         """
-        Returns an OpenAI client.
+        Returns an OpenAI client. Caches the client to avoid recreating it on every request.
 
         Returns:
             OpenAI: An instance of the OpenAI client.
@@ -149,18 +150,18 @@ class OpenAIResponses(Model):
             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_debug("http_client is not an instance of httpx.Client.")
+        if self.http_client is not None:
+            client_params["http_client"] = self.http_client
+        else:
+            # Use global sync client when no custom http_client is provided
+            client_params["http_client"] = get_default_sync_client()
 
         self.client = OpenAI(**client_params)
         return self.client
 
     def get_async_client(self) -> AsyncOpenAI:
         """
-        Returns an asynchronous OpenAI client.
+        Returns an asynchronous OpenAI client. Caches the client to avoid recreating it on every request.
 
         Returns:
             AsyncOpenAI: An instance of the asynchronous OpenAI client.
@@ -172,12 +173,8 @@ class OpenAIResponses(Model):
         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)
-            )
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
 
         self.async_client = AsyncOpenAI(**client_params)
         return self.async_client

agno/models/response.py

@@ -197,3 +197,4 @@ class FileType(str, Enum):
     MP4 = "mp4"
     GIF = "gif"
     MP3 = "mp3"
+    WAV = "wav"

agno/models/vertexai/claude.py

@@ -2,7 +2,11 @@ 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
@@ -55,6 +59,16 @@ class Claude(AnthropicClaude):
             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
 
@@ -66,5 +80,17 @@ class Claude(AnthropicClaude):
             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/os/app.py

@@ -110,10 +110,6 @@ class AgentOS:
         on_route_conflict: Literal["preserve_agentos", "preserve_base_app", "error"] = "preserve_agentos",
         telemetry: bool = True,
         auto_provision_dbs: bool = True,
-        os_id: Optional[str] = None,  # Deprecated
-        enable_mcp: bool = False,  # Deprecated
-        fastapi_app: Optional[FastAPI] = None,  # Deprecated
-        replace_routes: Optional[bool] = None,  # Deprecated
     ):
         """Initialize AgentOS.
 
@@ -156,13 +152,6 @@ class AgentOS:
             self.base_app: Optional[FastAPI] = base_app
             self._app_set = True
             self.on_route_conflict = on_route_conflict
-        elif fastapi_app:
-            self.base_app = fastapi_app
-            self._app_set = True
-            if replace_routes is not None:
-                self.on_route_conflict = "preserve_agentos" if replace_routes else "preserve_base_app"
-            else:
-                self.on_route_conflict = on_route_conflict
         else:
             self.base_app = None
             self._app_set = False
@@ -172,7 +161,7 @@ class AgentOS:
 
         self.name = name
 
-        self.id = id or os_id
+        self.id = id
         if not self.id:
             self.id = generate_id(self.name) if self.name else str(uuid4())
 
@@ -181,7 +170,7 @@ class AgentOS:
 
         self.telemetry = telemetry
 
-        self.enable_mcp_server = enable_mcp or enable_mcp_server
+        self.enable_mcp_server = enable_mcp_server
         self.lifespan = lifespan
 
         # List of all MCP tools used inside the AgentOS
@@ -327,16 +316,16 @@ class AgentOS:
         """Initialize and configure all agents for AgentOS usage."""
         if not self.agents:
             return
-
         for agent in self.agents:
             # Track all MCP tools to later handle their connection
             if agent.tools:
                 for tool in agent.tools:
-                    # Checking if the tool is a MCPTools or MultiMCPTools instance
-                    type_name = type(tool).__name__
-                    if type_name in ("MCPTools", "MultiMCPTools"):
-                        if tool not in self.mcp_tools:
-                            self.mcp_tools.append(tool)
+                    # Checking if the tool is an instance of MCPTools, MultiMCPTools, or a subclass of those
+                    if hasattr(type(tool), "__mro__"):
+                        mro_names = {cls.__name__ for cls in type(tool).__mro__}
+                        if mro_names & {"MCPTools", "MultiMCPTools"}:
+                            if tool not in self.mcp_tools:
+                                self.mcp_tools.append(tool)
 
             agent.initialize_agent()