agno 2.2.13__py3-none-any.whl

agno/models/cohere/chat.py

@@ -0,0 +1,389 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Type, Union
+
+from pydantic import BaseModel
+
+from agno.exceptions import ModelProviderError
+from agno.models.base import Model
+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.models.cohere import format_messages
+
+try:
+    from cohere import AsyncClientV2 as CohereAsyncClient
+    from cohere import ClientV2 as CohereClient
+    from cohere.v2.types.v2chat_response import V2ChatResponse
+    from cohere.v2.types.v2chat_stream_response import V2ChatStreamResponse
+except ImportError:
+    raise ImportError("`cohere` not installed. Please install using `pip install cohere`")
+
+
+@dataclass
+class Cohere(Model):
+    """
+    A class representing the Cohere model.
+
+    For more information, see: https://docs.cohere.com/docs/chat-api
+    """
+
+    id: str = "command-r-plus"
+    name: str = "cohere"
+    provider: str = "Cohere"
+
+    # -*- Request parameters
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_k: Optional[int] = None
+    top_p: Optional[float] = None
+    seed: Optional[int] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None
+    logprobs: Optional[bool] = None
+    request_params: Optional[Dict[str, Any]] = None
+    strict_tools: bool = False
+    # Add chat history to the cohere messages instead of using the conversation_id
+    add_chat_history: bool = False
+    # -*- Client parameters
+    api_key: Optional[str] = None
+    client_params: Optional[Dict[str, Any]] = None
+    # -*- Provide the Cohere client manually
+    client: Optional[CohereClient] = None
+    async_client: Optional[CohereAsyncClient] = None
+
+    def get_client(self) -> CohereClient:
+        if self.client:
+            return self.client
+
+        _client_params: Dict[str, Any] = {}
+
+        self.api_key = self.api_key or getenv("CO_API_KEY")
+        if not self.api_key:
+            log_error("CO_API_KEY not set. Please set the CO_API_KEY environment variable.")
+
+        _client_params["api_key"] = self.api_key
+
+        self.client = CohereClient(**_client_params)
+        return self.client  # type: ignore
+
+    def get_async_client(self) -> CohereAsyncClient:
+        if self.async_client:
+            return self.async_client
+
+        _client_params: Dict[str, Any] = {}
+
+        self.api_key = self.api_key or getenv("CO_API_KEY")
+
+        if not self.api_key:
+            log_error("CO_API_KEY not set. Please set the CO_API_KEY environment variable.")
+
+        _client_params["api_key"] = self.api_key
+
+        self.async_client = CohereAsyncClient(**_client_params)
+        return self.async_client  # type: ignore
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        _request_params: Dict[str, Any] = {}
+        if self.temperature:
+            _request_params["temperature"] = self.temperature
+        if self.max_tokens:
+            _request_params["max_tokens"] = self.max_tokens
+        if self.top_k:
+            _request_params["k"] = self.top_k
+        if self.top_p:
+            _request_params["p"] = self.top_p
+        if self.seed:
+            _request_params["seed"] = self.seed
+        if self.logprobs:
+            _request_params["logprobs"] = self.logprobs
+        if self.frequency_penalty:
+            _request_params["frequency_penalty"] = self.frequency_penalty
+        if self.presence_penalty:
+            _request_params["presence_penalty"] = self.presence_penalty
+
+        if response_format:
+            _request_params["response_format"] = response_format
+
+        # Format tools
+        if tools is not None and len(tools) > 0:
+            formatted_tools = []
+            for tool in tools:
+                if tool.get("type") == "function" and "function" in tool:
+                    # Extract only the fields that Cohere supports
+                    filtered_tool = {
+                        "type": "function",
+                        "function": {
+                            "name": tool["function"]["name"],
+                            "description": tool["function"]["description"],
+                            "parameters": tool["function"]["parameters"],
+                        },
+                    }
+                    formatted_tools.append(filtered_tool)
+                else:
+                    # For non-function tools, pass them through as-is
+                    formatted_tools.append(tool)
+
+            _request_params["tools"] = formatted_tools
+            # Fix optional parameters where the "type" is [type, null]
+            for tool in _request_params["tools"]:  # type: ignore
+                if "parameters" in tool["function"] and "properties" in tool["function"]["parameters"]:  # type: ignore
+                    params = tool["function"]["parameters"]
+                    # Cohere requires at least one required parameter, so if unset, set it to all parameters
+                    if len(params.get("required", [])) == 0:
+                        params["required"] = list(params["properties"].keys())
+            _request_params["strict_tools"] = self.strict_tools
+
+        if self.request_params:
+            _request_params.update(self.request_params)
+
+        if _request_params:
+            log_debug(f"Calling {self.provider} with request parameters: {_request_params}", log_level=2)
+        return _request_params
+
+    def invoke(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> ModelResponse:
+        """
+        Invoke a non-streamed chat response from the Cohere API.
+        """
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools)
+
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            assistant_message.metrics.start_timer()
+            provider_response = self.get_client().chat(
+                model=self.id,
+                messages=format_messages(messages),  # type: ignore
+                **request_kwargs,
+            )  # type: ignore
+            assistant_message.metrics.stop_timer()
+
+            model_response = self._parse_provider_response(provider_response, response_format=response_format)
+
+            return model_response
+
+        except Exception as e:
+            log_error(f"Unexpected error calling Cohere API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    def invoke_stream(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> Iterator[ModelResponse]:
+        """
+        Invoke a streamed chat response from the Cohere API.
+        """
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools)
+
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            tool_use: Dict[str, Any] = {}
+
+            assistant_message.metrics.start_timer()
+
+            for response in self.get_client().chat_stream(
+                model=self.id,
+                messages=format_messages(messages),  # type: ignore
+                **request_kwargs,
+            ):
+                model_response, tool_use = self._parse_provider_response_delta(response, tool_use=tool_use)
+                yield model_response
+
+            assistant_message.metrics.stop_timer()
+
+        except Exception as e:
+            log_error(f"Unexpected error calling Cohere API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    async def ainvoke(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> ModelResponse:
+        """
+        Asynchronously invoke a non-streamed chat response from the Cohere API.
+        """
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools)
+
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            assistant_message.metrics.start_timer()
+            provider_response = await self.get_async_client().chat(
+                model=self.id,
+                messages=format_messages(messages),  # type: ignore
+                **request_kwargs,
+            )
+            assistant_message.metrics.stop_timer()
+
+            model_response = self._parse_provider_response(provider_response, response_format=response_format)
+
+            return model_response
+
+        except Exception as e:
+            log_error(f"Unexpected error calling Cohere API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    async def ainvoke_stream(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> AsyncIterator[ModelResponse]:
+        """
+        Asynchronously invoke a streamed chat response from the Cohere API.
+        """
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools)
+
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            tool_use: Dict[str, Any] = {}
+
+            assistant_message.metrics.start_timer()
+
+            async for response in self.get_async_client().chat_stream(
+                model=self.id,
+                messages=format_messages(messages),  # type: ignore
+                **request_kwargs,
+            ):
+                model_response, tool_use = self._parse_provider_response_delta(response, tool_use=tool_use)
+                yield model_response
+
+            assistant_message.metrics.stop_timer()
+
+        except Exception as e:
+            log_error(f"Unexpected error calling Cohere API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    def _parse_provider_response(self, response: V2ChatResponse, **kwargs) -> ModelResponse:
+        """
+        Parse the model provider response.
+
+        Args:
+            response (V2ChatResponse): The response from the Cohere API.
+        """
+        model_response = ModelResponse()
+
+        model_response.role = response.message.role
+
+        response_message = response.message
+        if response_message.content is not None:
+            full_content = ""
+            for item in response_message.content:
+                if hasattr(item, "text") and item.text is not None:  # type: ignore
+                    full_content += item.text  # type: ignore
+            model_response.content = full_content
+
+        if response_message.tool_calls is not None:
+            model_response.tool_calls = [t.model_dump() for t in response_message.tool_calls]
+
+        if response.usage is not None:
+            model_response.response_usage = self._get_metrics(response.usage)
+
+        return model_response
+
+    def _parse_provider_response_delta(
+        self, response: V2ChatStreamResponse, tool_use: Dict[str, Any]
+    ) -> Tuple[ModelResponse, Dict[str, Any]]:  # type: ignore
+        """
+        Parse the streaming response from the model provider into ModelResponse objects.
+
+        Args:
+            response: Raw response chunk from the model provider
+
+        Returns:
+            ModelResponse: Parsed response delta
+        """
+        model_response = ModelResponse()
+
+        # 1. Add content
+        if (
+            response.type == "content-delta"
+            and response.delta is not None
+            and response.delta.message is not None
+            and response.delta.message.content is not None
+            and response.delta.message.content.text is not None
+        ):
+            model_response.content = response.delta.message.content.text
+
+        # 2. Add tool calls information
+
+        # 2.1 Add starting tool call
+        elif response.type == "tool-call-start" and response.delta is not None:
+            if response.delta.message is not None and response.delta.message.tool_calls is not None:
+                tool_use = response.delta.message.tool_calls.model_dump()
+
+        # 2.2 Add tool call delta
+        elif response.type == "tool-call-delta" and response.delta is not None:
+            if (
+                response.delta.message is not None
+                and response.delta.message.tool_calls is not None
+                and response.delta.message.tool_calls.function is not None
+                and response.delta.message.tool_calls.function.arguments is not None
+            ):
+                tool_use["function"]["arguments"] += response.delta.message.tool_calls.function.arguments
+
+        # 2.3 Add ending tool call
+        elif response.type == "tool-call-end":
+            model_response.tool_calls = [tool_use]
+
+        # 3. Add metrics
+        elif (
+            response.type == "message-end"
+            and response.delta is not None
+            and response.delta.usage is not None
+            and response.delta.usage.tokens is not None
+        ):
+            model_response.response_usage = self._get_metrics(response.delta.usage)  # type: ignore
+
+        return model_response, tool_use
+
+    def _get_metrics(self, response_usage) -> Metrics:
+        """
+        Parse the given Cohere usage into an Agno Metrics object.
+
+        Args:
+            response_usage: Usage data from Cohere
+
+        Returns:
+            Metrics: Parsed metrics data
+        """
+        metrics = Metrics()
+
+        metrics.input_tokens = response_usage.tokens.input_tokens or 0
+        metrics.output_tokens = response_usage.tokens.output_tokens or 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
+
+        return metrics

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,57 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import List, Optional
+
+import httpx
+
+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_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,91 @@
+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 ModelProviderError
+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 ModelProviderError(
+                    message="DASHSCOPE_API_KEY not set. Please set the DASHSCOPE_API_KEY environment variable.",
+                    model_name=self.name,
+                    model_id=self.id,
+                )
+
+        # 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,28 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Optional
+
+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

agno/models/deepseek/__init__.py

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

agno/models/deepseek/deepseek.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelProviderError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class DeepSeek(OpenAILike):
+    """
+    A class for interacting with DeepSeek models.
+
+    Attributes:
+        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] = 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 ModelProviderError(
+                    message="DEEPSEEK_API_KEY not set. Please set the DEEPSEEK_API_KEY environment variable.",
+                    model_name=self.name,
+                    model_id=self.id,
+                )
+
+        # 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

agno/models/defaults.py

@@ -0,0 +1 @@
+DEFAULT_OPENAI_MODEL_ID: str = "gpt-4o"

agno/models/fireworks/__init__.py

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