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

agno/models/cometapi/__init__.py

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

agno/models/cometapi/cometapi.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+from agno.utils.log import log_debug
+
+
+@dataclass
+class CometAPI(OpenAILike):
+    """
+    The CometAPI class provides access to multiple AI model providers
+    (GPT, Claude, Gemini, DeepSeek, etc.) through OpenAI-compatible endpoints.
+
+    Args:
+        id (str): The id of the CometAPI model to use. Default is "gpt-5-mini".
+        name (str): The name for this model. Defaults to "CometAPI".
+        api_key (str): The API key for CometAPI. Defaults to COMETAPI_KEY environment variable.
+        base_url (str): The base URL for CometAPI. Defaults to "https://api.cometapi.com/v1".
+    """
+
+    name: str = "CometAPI"
+    id: str = "gpt-5-mini"
+    api_key: Optional[str] = field(default_factory=lambda: getenv("COMETAPI_KEY"))
+    base_url: str = "https://api.cometapi.com/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for COMETAPI_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("COMETAPI_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="COMETAPI_KEY not set. Please set the COMETAPI_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()
+
+    def get_available_models(self) -> List[str]:
+        """
+        Fetch available chat models from CometAPI, filtering out non-chat models.
+
+        Returns:
+            List of available chat model IDs
+        """
+        if not self.api_key:
+            log_debug("No API key provided, returning empty model list")
+            return []
+
+        try:
+            with httpx.Client() as client:
+                response = client.get(
+                    f"{self.base_url}/models",
+                    headers={"Authorization": f"Bearer {self.api_key}", "Accept": "application/json"},
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+
+                data = response.json()
+                all_models = data.get("data", [])
+
+                log_debug(f"Found {len(all_models)} total models")
+                return sorted(all_models)
+
+        except Exception as e:
+            log_debug(f"Error fetching models from CometAPI: {e}")
+            return []

agno/models/dashscope/__init__.py

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

agno/models/dashscope/dashscope.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class DashScope(OpenAILike):
+    """
+    A class for interacting with Qwen models via DashScope API.
+
+    Attributes:
+        id (str): The model id. Defaults to "qwen-plus".
+        name (str): The model name. Defaults to "Qwen".
+        provider (str): The provider name. Defaults to "Qwen".
+        api_key (Optional[str]): The DashScope API key.
+        base_url (str): The base URL. Defaults to "https://dashscope-intl.aliyuncs.com/compatible-mode/v1".
+        enable_thinking (bool): Enable thinking process (DashScope native parameter). Defaults to False.
+        include_thoughts (Optional[bool]): Include thinking process in response (alternative parameter). Defaults to None.
+    """
+
+    id: str = "qwen-plus"
+    name: str = "Qwen"
+    provider: str = "Dashscope"
+
+    api_key: Optional[str] = getenv("DASHSCOPE_API_KEY") or getenv("QWEN_API_KEY")
+    base_url: str = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+
+    # Thinking parameters
+    enable_thinking: bool = False
+    include_thoughts: Optional[bool] = None
+    thinking_budget: Optional[int] = None
+
+    # DashScope supports structured outputs
+    supports_native_structured_outputs: bool = True
+    supports_json_schema_outputs: bool = True
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        if not self.api_key:
+            self.api_key = getenv("DASHSCOPE_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="DASHSCOPE_API_KEY not set. Please set the DASHSCOPE_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+        return client_params
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
+
+        if self.include_thoughts is not None:
+            self.enable_thinking = self.include_thoughts
+
+        if self.enable_thinking is not None:
+            params["extra_body"] = {
+                "enable_thinking": self.enable_thinking,
+            }
+
+            if self.thinking_budget is not None:
+                params["extra_body"]["thinking_budget"] = self.thinking_budget
+
+        return params

agno/models/deepinfra/__init__.py

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

agno/models/deepinfra/deepinfra.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class DeepInfra(OpenAILike):
+    """
+    A class for interacting with DeepInfra models.
+
+    Attributes:
+        id (str): The model id. Defaults to "meta-llama/Llama-2-70b-chat-hf".
+        name (str): The model name. Defaults to "DeepInfra".
+        provider (str): The provider name. Defaults to "DeepInfra".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://api.deepinfra.com/v1/openai".
+    """
+
+    id: str = "meta-llama/Llama-2-70b-chat-hf"
+    name: str = "DeepInfra"
+    provider: str = "DeepInfra"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("DEEPINFRA_API_KEY"))
+    base_url: str = "https://api.deepinfra.com/v1/openai"
+
+    supports_native_structured_outputs: bool = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for DEEPINFRA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("DEEPINFRA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="DEEPINFRA_API_KEY not set. Please set the DEEPINFRA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/deepseek/__init__.py

@@ -1 +1,5 @@
 from agno.models.deepseek.deepseek import DeepSeek
+
+__all__ = [
+    "DeepSeek",
+]

agno/models/deepseek/deepseek.py

@@ -1,26 +1,127 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
+from agno.models.message import Message
 from agno.models.openai.like import OpenAILike
+from agno.utils.log import log_warning
+from agno.utils.openai import _format_file_for_message, audio_to_message, images_to_message
 
 
 @dataclass
 class DeepSeek(OpenAILike):
     """
-    A model class for DeepSeek Chat API.
+    A class for interacting with DeepSeek models.
 
     Attributes:
-    - id: str: The unique identifier of the model. Default: "deepseek-chat".
-    - name: str: The name of the model. Default: "DeepSeek".
-    - provider: str: The provider of the model. Default: "DeepSeek".
-    - api_key: Optional[str]: The API key for the model.
-    - base_url: str: The base URL for the model. Default: "https://api.deepseek.com".
+        id (str): The model id. Defaults to "deepseek-chat".
+        name (str): The model name. Defaults to "DeepSeek".
+        provider (str): The provider name. Defaults to "DeepSeek".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://api.deepseek.com".
     """
 
     id: str = "deepseek-chat"
     name: str = "DeepSeek"
     provider: str = "DeepSeek"
 
-    api_key: Optional[str] = getenv("DEEPSEEK_API_KEY", None)
+    api_key: Optional[str] = field(default_factory=lambda: getenv("DEEPSEEK_API_KEY"))
     base_url: str = "https://api.deepseek.com"
+
+    # Their support for structured outputs is currently broken
+    supports_native_structured_outputs: bool = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        # Fetch API key from env if not already set
+        if not self.api_key:
+            self.api_key = getenv("DEEPSEEK_API_KEY")
+            if not self.api_key:
+                # Raise error immediately if key is missing
+                raise ModelAuthenticationError(
+                    message="DEEPSEEK_API_KEY not set. Please set the DEEPSEEK_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+        return client_params
+
+    def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
+        """
+        Format a message into the format expected by OpenAI.
+
+        Args:
+            message (Message): The message to format.
+            compress_tool_results: Whether to compress tool results.
+
+        Returns:
+            Dict[str, Any]: The formatted message.
+        """
+        tool_result = message.get_content(use_compressed_content=compress_tool_results)
+
+        message_dict: Dict[str, Any] = {
+            "role": self.role_map[message.role] if self.role_map else self.default_role_map[message.role],
+            "content": tool_result,
+            "name": message.name,
+            "tool_call_id": message.tool_call_id,
+            "tool_calls": message.tool_calls,
+            "reasoning_content": message.reasoning_content,
+        }
+        message_dict = {k: v for k, v in message_dict.items() if v is not None}
+
+        # Ignore non-string message content
+        # because we assume that the images/audio are already added to the message
+        if (message.images is not None and len(message.images) > 0) or (
+            message.audio is not None and len(message.audio) > 0
+        ):
+            # Ignore non-string message content
+            # because we assume that the images/audio are already added to the message
+            if isinstance(message.content, str):
+                message_dict["content"] = [{"type": "text", "text": message.content}]
+                if message.images is not None:
+                    message_dict["content"].extend(images_to_message(images=message.images))
+
+                if message.audio is not None:
+                    message_dict["content"].extend(audio_to_message(audio=message.audio))
+
+        if message.audio_output is not None:
+            message_dict["content"] = ""
+            message_dict["audio"] = {"id": message.audio_output.id}
+
+        if message.videos is not None and len(message.videos) > 0:
+            log_warning("Video input is currently unsupported.")
+
+        if message.files is not None:
+            # Ensure content is a list of parts
+            content = message_dict.get("content")
+            if isinstance(content, str):  # wrap existing text
+                text = content
+                message_dict["content"] = [{"type": "text", "text": text}]
+            elif content is None:
+                message_dict["content"] = []
+            # Insert each file part before text parts
+            for file in message.files:
+                file_part = _format_file_for_message(file)
+                if file_part:
+                    message_dict["content"].insert(0, file_part)
+
+        # Manually add the content field even if it is None
+        if message.content is None:
+            message_dict["content"] = ""
+        return message_dict

agno/models/fireworks/__init__.py

@@ -1 +1,5 @@
 from agno.models.fireworks.fireworks import Fireworks
+
+__all__ = [
+    "Fireworks",
+]

agno/models/fireworks/fireworks.py

@@ -1,46 +1,43 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
-from typing import Iterator, List, Optional
+from typing import Any, Dict, Optional
 
-from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
-
-from agno.models.message import Message
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai import OpenAILike
 
 
 @dataclass
 class Fireworks(OpenAILike):
     """
-    Fireworks model
+    A class for interacting with models hosted on Fireworks.
 
     Attributes:
         id (str): The model name to use. Defaults to "accounts/fireworks/models/llama-v3p1-405b-instruct".
-        name (str): The model name to use. Defaults to "Fireworks: " + id.
+        name (str): The model name to use. Defaults to "Fireworks".
         provider (str): The provider to use. Defaults to "Fireworks".
-        api_key (Optional[str]): The API key to use. Defaults to getenv("FIREWORKS_API_KEY").
+        api_key (Optional[str]): The API key to use.
         base_url (str): The base URL to use. Defaults to "https://api.fireworks.ai/inference/v1".
     """
 
     id: str = "accounts/fireworks/models/llama-v3p1-405b-instruct"
-    name: str = "Fireworks: " + id
+    name: str = "Fireworks"
     provider: str = "Fireworks"
 
-    api_key: Optional[str] = getenv("FIREWORKS_API_KEY", None)
+    api_key: Optional[str] = field(default_factory=lambda: getenv("FIREWORKS_API_KEY"))
     base_url: str = "https://api.fireworks.ai/inference/v1"
 
-    def invoke_stream(self, messages: List[Message]) -> Iterator[ChatCompletionChunk]:
+    def _get_client_params(self) -> Dict[str, Any]:
         """
-        Send a streaming chat completion request to the Fireworks API.
-
-        Args:
-            messages (List[Message]): A list of message objects representing the conversation.
+        Returns client parameters for API requests, checking for FIREWORKS_API_KEY.
 
         Returns:
-            Iterator[ChatCompletionChunk]: An iterator of chat completion chunks.
+            Dict[str, Any]: A dictionary of client parameters for API requests.
         """
-        yield from self.get_client().chat.completions.create(
-            model=self.id,
-            messages=[m.to_dict() for m in messages],  # type: ignore
-            stream=True,
-            **self.request_kwargs,
-        )  # type: ignore
+        if not self.api_key:
+            self.api_key = getenv("FIREWORKS_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="FIREWORKS_API_KEY not set. Please set the FIREWORKS_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/google/__init__.py

@@ -1,9 +1,5 @@
 from agno.models.google.gemini import Gemini
 
-try:
-    from agno.models.google.gemini_openai import GeminiOpenAI
-except ImportError:
-
-    class GeminiOpenAIChat:  # type: ignore
-        def __init__(self, *args, **kwargs):
-            raise ImportError("GeminiOpenAI requires the 'openai' library. Please install it via `pip install openai`")
+__all__ = [
+    "Gemini",
+]