agno 2.0.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

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
 
@@ -61,7 +62,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
@@ -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,30 +104,46 @@ 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.
         """
-        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:
-            client_params["http_client"] = 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:
-            # 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)
+            # 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
 
     def get_request_params(
         self,

agno/models/huggingface/huggingface.py

@@ -382,7 +382,8 @@ class HuggingFace(Model):
             List[Dict[str, Any]]: The built tool calls.
         """
         tool_calls: List[Dict[str, Any]] = []
-        for _tool_call in tool_calls_data:
+        for tool_call in tool_calls_data:
+            _tool_call = tool_call[0]
             _index = _tool_call.index
             _tool_call_id = _tool_call.id
             _tool_call_type = _tool_call.type

agno/models/internlm/internlm.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -22,5 +22,5 @@ class InternLM(OpenAILike):
     name: str = "InternLM"
     provider: str = "InternLM"
 
-    api_key: Optional[str] = getenv("INTERNLM_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("INTERNLM_API_KEY"))
     base_url: Optional[str] = "https://internlm-chat.intern-ai.org.cn/puyu/api/v1/chat/completions"

agno/models/langdb/langdb.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
@@ -22,10 +22,10 @@ class LangDB(OpenAILike):
     name: str = "LangDB"
     provider: str = "LangDB"
 
-    api_key: Optional[str] = getenv("LANGDB_API_KEY")
-    project_id: Optional[str] = getenv("LANGDB_PROJECT_ID")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("LANGDB_API_KEY"))
+    project_id: Optional[str] = field(default_factory=lambda: getenv("LANGDB_PROJECT_ID"))
 
-    base_host_url: str = getenv("LANGDB_API_BASE_URL", "https://api.us-east-1.langdb.ai")
+    base_host_url: str = field(default_factory=lambda: getenv("LANGDB_API_BASE_URL", "https://api.us-east-1.langdb.ai"))
 
     base_url: Optional[str] = None
     label: Optional[str] = None

agno/models/litellm/chat.py

@@ -38,6 +38,10 @@ class LiteLLM(Model):
     max_tokens: Optional[int] = None
     temperature: float = 0.7
     top_p: float = 1.0
+    metadata: Optional[Dict[str, Any]] = None
+    extra_headers: Optional[Dict[str, Any]] = None
+    extra_query: Optional[Dict[str, Any]] = None
+    extra_body: Optional[Dict[str, Any]] = None
     request_params: Optional[Dict[str, Any]] = None
 
     client: Optional[Any] = None
@@ -47,7 +51,7 @@ class LiteLLM(Model):
         super().__post_init__()
 
         # Set up API key from environment variable if not already set
-        if not self.api_key:
+        if not self.client and not self.api_key:
             self.api_key = getenv("LITELLM_API_KEY")
             if not self.api_key:
                 # Check for other present valid keys, e.g. OPENAI_API_KEY if self.id is an OpenAI model
@@ -148,10 +152,23 @@ class LiteLLM(Model):
             base_params["api_key"] = self.api_key
         if self.api_base:
             base_params["api_base"] = self.api_base
+        if self.extra_headers:
+            base_params["extra_headers"] = self.extra_headers
+        if self.extra_query:
+            base_params["extra_query"] = self.extra_query
         if tools:
             base_params["tools"] = tools
             base_params["tool_choice"] = "auto"
 
+        # Handle metadata via extra_body as per LiteLLM docs
+        if self.metadata:
+            if self.extra_body:
+                base_params["extra_body"] = {**self.extra_body, "metadata": self.metadata}
+            else:
+                base_params["extra_body"] = {"metadata": self.metadata}
+        elif self.extra_body:
+            base_params["extra_body"] = self.extra_body
+
         # Add additional request params if provided
         request_params: Dict[str, Any] = {k: v for k, v in base_params.items() if v is not None}
         if self.request_params:

agno/models/litellm/litellm_openai.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -21,5 +21,5 @@ class LiteLLMOpenAI(OpenAILike):
     name: str = "LiteLLM"
     provider: str = "LiteLLM"
 
-    api_key: Optional[str] = getenv("LITELLM_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("LITELLM_API_KEY"))
     base_url: str = "http://0.0.0.0:4000"

agno/models/llama_cpp/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.llama_cpp.llama_cpp import LlamaCpp
+
+__all__ = [
+    "LlamaCpp",
+]

agno/models/llama_cpp/llama_cpp.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class LlamaCpp(OpenAILike):
+    """
+    A class for interacting with LLMs using Llama CPP.
+
+    Attributes:
+        id (str): The id of the Llama CPP model. Default is "ggml-org/gpt-oss-20b-GGUF".
+        name (str): The name of this chat model instance. Default is "LlamaCpp".
+        provider (str): The provider of the model. Default is "LlamaCpp".
+        base_url (str): The base url to which the requests are sent.
+    """
+
+    id: str = "ggml-org/gpt-oss-20b-GGUF"
+    name: str = "LlamaCpp"
+    provider: str = "LlamaCpp"
+
+    base_url: str = "http://127.0.0.1:8080/v1"

agno/models/message.py

@@ -1,6 +1,7 @@
 import json
 from time import time
 from typing import Any, Dict, List, Optional, Sequence, Union
+from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -51,6 +52,8 @@ class Citations(BaseModel):
 class Message(BaseModel):
     """Message sent to the Model"""
 
+    id: str = Field(default_factory=lambda: str(uuid4()))
+
     # The role of the message author.
     # One of system, user, assistant, or tool.
     role: str
@@ -74,6 +77,7 @@ class Message(BaseModel):
     audio_output: Optional[Audio] = None
     image_output: Optional[Image] = None
     video_output: Optional[Video] = None
+    file_output: Optional[File] = None
 
     # The thinking content from the model
     redacted_reasoning_content: Optional[str] = None
@@ -121,11 +125,144 @@ class Message(BaseModel):
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        # Handle image reconstruction properly
+        if "images" in data and data["images"]:
+            reconstructed_images = []
+            for i, img_data in enumerate(data["images"]):
+                if isinstance(img_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in img_data and isinstance(img_data["content"], str):
+                        reconstructed_images.append(
+                            Image.from_base64(
+                                img_data["content"],
+                                id=img_data.get("id"),
+                                mime_type=img_data.get("mime_type"),
+                                format=img_data.get("format"),
+                            )
+                        )
+                    else:
+                        # Regular image (filepath/url)
+                        reconstructed_images.append(Image(**img_data))
+                else:
+                    reconstructed_images.append(img_data)
+            data["images"] = reconstructed_images
+
+        # Handle audio reconstruction properly
+        if "audio" in data and data["audio"]:
+            reconstructed_audio = []
+            for i, aud_data in enumerate(data["audio"]):
+                if isinstance(aud_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in aud_data and isinstance(aud_data["content"], str):
+                        reconstructed_audio.append(
+                            Audio.from_base64(
+                                aud_data["content"],
+                                id=aud_data.get("id"),
+                                mime_type=aud_data.get("mime_type"),
+                                transcript=aud_data.get("transcript"),
+                                expires_at=aud_data.get("expires_at"),
+                                sample_rate=aud_data.get("sample_rate", 24000),
+                                channels=aud_data.get("channels", 1),
+                            )
+                        )
+                    else:
+                        reconstructed_audio.append(Audio(**aud_data))
+                else:
+                    reconstructed_audio.append(aud_data)
+            data["audio"] = reconstructed_audio
+
+        # Handle video reconstruction properly
+        if "videos" in data and data["videos"]:
+            reconstructed_videos = []
+            for i, vid_data in enumerate(data["videos"]):
+                if isinstance(vid_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in vid_data and isinstance(vid_data["content"], str):
+                        reconstructed_videos.append(
+                            Video.from_base64(
+                                vid_data["content"],
+                                id=vid_data.get("id"),
+                                mime_type=vid_data.get("mime_type"),
+                                format=vid_data.get("format"),
+                            )
+                        )
+                    else:
+                        reconstructed_videos.append(Video(**vid_data))
+                else:
+                    reconstructed_videos.append(vid_data)
+            data["videos"] = reconstructed_videos
+
+        # Handle file reconstruction properly
+        if "files" in data and data["files"]:
+            reconstructed_files = []
+            for i, file_data in enumerate(data["files"]):
+                if isinstance(file_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in file_data and isinstance(file_data["content"], str):
+                        reconstructed_files.append(
+                            File.from_base64(
+                                file_data["content"],
+                                id=file_data.get("id"),
+                                mime_type=file_data.get("mime_type"),
+                                filename=file_data.get("filename"),
+                                name=file_data.get("name"),
+                                format=file_data.get("format"),
+                            )
+                        )
+                    else:
+                        reconstructed_files.append(File(**file_data))
+                else:
+                    reconstructed_files.append(file_data)
+            data["files"] = reconstructed_files
+
+        if "audio_output" in data and data["audio_output"]:
+            aud_data = data["audio_output"]
+            if isinstance(aud_data, dict):
+                if "content" in aud_data and isinstance(aud_data["content"], str):
+                    data["audio_output"] = Audio.from_base64(
+                        aud_data["content"],
+                        id=aud_data.get("id"),
+                        mime_type=aud_data.get("mime_type"),
+                        transcript=aud_data.get("transcript"),
+                        expires_at=aud_data.get("expires_at"),
+                        sample_rate=aud_data.get("sample_rate", 24000),
+                        channels=aud_data.get("channels", 1),
+                    )
+                else:
+                    data["audio_output"] = Audio(**aud_data)
+
+        if "image_output" in data and data["image_output"]:
+            img_data = data["image_output"]
+            if isinstance(img_data, dict):
+                if "content" in img_data and isinstance(img_data["content"], str):
+                    data["image_output"] = Image.from_base64(
+                        img_data["content"],
+                        id=img_data.get("id"),
+                        mime_type=img_data.get("mime_type"),
+                        format=img_data.get("format"),
+                    )
+                else:
+                    data["image_output"] = Image(**img_data)
+
+        if "video_output" in data and data["video_output"]:
+            vid_data = data["video_output"]
+            if isinstance(vid_data, dict):
+                if "content" in vid_data and isinstance(vid_data["content"], str):
+                    data["video_output"] = Video.from_base64(
+                        vid_data["content"],
+                        id=vid_data.get("id"),
+                        mime_type=vid_data.get("mime_type"),
+                        format=vid_data.get("format"),
+                    )
+                else:
+                    data["video_output"] = Video(**vid_data)
+
         return cls(**data)
 
     def to_dict(self) -> Dict[str, Any]:
         """Returns the message as a dictionary."""
         message_dict = {
+            "id": self.id,
             "content": self.content,
             "reasoning_content": self.reasoning_content,
             "from_history": self.from_history,
@@ -152,6 +289,8 @@ class Message(BaseModel):
             message_dict["audio"] = [aud.to_dict() for aud in self.audio]
         if self.videos:
             message_dict["videos"] = [vid.to_dict() for vid in self.videos]
+        if self.files:
+            message_dict["files"] = [file.to_dict() for file in self.files]
         if self.audio_output:
             message_dict["audio_output"] = self.audio_output.to_dict()
 

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
 
@@ -61,7 +62,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 +105,16 @@ 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_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
 
@@ -116,18 +125,26 @@ 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:
-            client_params["http_client"] = 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:
-            # 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)
+            # 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
 
     def get_request_params(
         self,

agno/models/meta/llama_openai.py

@@ -1,9 +1,7 @@
-from dataclasses import dataclass
+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:
@@ -31,7 +29,7 @@ class LlamaOpenAI(OpenAILike):
     name: str = "LlamaOpenAI"
     provider: str = "LlamaOpenAI"
 
-    api_key: Optional[str] = getenv("LLAMA_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("LLAMA_API_KEY"))
     base_url: Optional[str] = "https://api.llama.com/compat/v1/"
 
     # Request parameters
@@ -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,16 +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"""
-        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),
-        )
-
-        return AsyncOpenAIClient(**client_params)

agno/models/nebius/nebius.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
@@ -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] = getenv("NEBIUS_API_KEY")
-    base_url: str = "https://api.studio.nebius.com/v1/"
+    api_key: Optional[str] = field(default_factory=lambda: getenv("NEBIUS_API_KEY"))
+    base_url: str = "https://api.tokenfactory.nebius.com/v1/"
 
     def _get_client_params(self) -> Dict[str, Any]:
         if not self.api_key:

agno/models/nexus/__init__.py

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

agno/models/nexus/nexus.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Nexus(OpenAILike):
+    """
+    A class for interacting with LLMs using Nexus.
+
+    Attributes:
+        id (str): The id of the Nexus model to use. Default is "openai/gpt-4".
+        name (str): The name of this chat model instance. Default is "Nexus"
+        provider (str): The provider of the model. Default is "Nexus".
+        base_url (str): The base url to which the requests are sent.
+    """
+
+    id: str = "openai/gpt-4"
+    name: str = "Nexus"
+    provider: str = "Nexus"
+
+    base_url: str = "http://localhost:8000/llm/v1/"

agno/models/nvidia/nvidia.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -22,7 +22,7 @@ class Nvidia(OpenAILike):
     name: str = "Nvidia"
     provider: str = "Nvidia"
 
-    api_key: Optional[str] = getenv("NVIDIA_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("NVIDIA_API_KEY"))
     base_url: str = "https://integrate.api.nvidia.com/v1"
 
     supports_native_structured_outputs: bool = False