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

agno/models/sambanova/sambanova.py

@@ -1,26 +1,45 @@
 from dataclasses import dataclass
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
 @dataclass
 class Sambanova(OpenAILike):
     """
-    A class for interacting with Sambanova models.
+    A class for interacting with Sambanova API.
 
     Attributes:
         id (str): The id of the Sambanova model to use. Default is "Meta-Llama-3.1-8B-Instruct".
         name (str): The name of this chat model instance. Default is "Sambanova"
         provider (str): The provider of the model. Default is "Sambanova".
         api_key (str): The api key to authorize request to Sambanova.
-        base_url (str): The base url to which the requests are sent.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.sambanova.ai/v1".
     """
 
     id: str = "Meta-Llama-3.1-8B-Instruct"
     name: str = "Sambanova"
     provider: str = "Sambanova"
 
-    api_key: Optional[str] = getenv("SAMBANOVA_API_KEY")
+    api_key: Optional[str] = None
     base_url: str = "https://api.sambanova.ai/v1"
+
+    supports_native_structured_outputs: bool = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for SAMBANOVA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("SAMBANOVA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="SAMBANOVA_API_KEY not set. Please set the SAMBANOVA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/siliconflow/__init__.py

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

agno/models/siliconflow/siliconflow.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Siliconflow(OpenAILike):
+    """
+    A class for interacting with Siliconflow API.
+
+    Attributes:
+        id (str): The id of the Siliconflow model to use. Default is "Qwen/QwQ-32B".
+        name (str): The name of this chat model instance. Default is "Siliconflow".
+        provider (str): The provider of the model. Default is "Siliconflow".
+        api_key (str): The api key to authorize request to Siliconflow.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.siliconflow.cn/v1".
+    """
+
+    id: str = "Qwen/QwQ-32B"
+    name: str = "Siliconflow"
+    provider: str = "Siliconflow"
+    api_key: Optional[str] = None
+    base_url: str = "https://api.siliconflow.com/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for SILICONFLOW_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("SILICONFLOW_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="SILICONFLOW_API_KEY not set. Please set the SILICONFLOW_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/together/__init__.py

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

agno/models/together/together.py

@@ -1,185 +1,42 @@
-import json
 from dataclasses import dataclass
 from os import getenv
-from typing import Any, Dict, Iterator, List, Optional
+from typing import Any, Dict, Optional
 
-from agno.models.message import Message
-from agno.models.openai.chat import Metrics, StreamData
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
-from agno.models.response import ModelResponse
-from agno.tools.function import FunctionCall
-from agno.utils.log import logger
-from agno.utils.tools import get_function_call_for_tool_call
-
-try:
-    from openai.types.chat.chat_completion_chunk import (
-        ChoiceDelta,
-        ChoiceDeltaToolCall,
-    )
-    from openai.types.completion_usage import CompletionUsage
-except ImportError:
-    logger.error("`openai` not installed")
-    raise
 
 
 @dataclass
 class Together(OpenAILike):
     """
-    A class for interacting with Together models.
+    A class for interacting with Together API.
 
     Attributes:
         id (str): The id of the Together model to use. Default is "mistralai/Mixtral-8x7B-Instruct-v0.1".
         name (str): The name of this chat model instance. Default is "Together"
         provider (str): The provider of the model. Default is "Together".
         api_key (str): The api key to authorize request to Together.
-        base_url (str): The base url to which the requests are sent.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.together.xyz/v1".
     """
 
     id: str = "mistralai/Mixtral-8x7B-Instruct-v0.1"
     name: str = "Together"
-    provider: str = "Together " + id
-    api_key: Optional[str] = getenv("TOGETHER_API_KEY")
+    provider: str = "Together"
+    api_key: Optional[str] = None
     base_url: str = "https://api.together.xyz/v1"
-    monkey_patch: bool = False
-
-    def response_stream(self, messages: List[Message]) -> Iterator[ModelResponse]:
-        if not self.monkey_patch:
-            yield from super().response_stream(messages)
-            return
-
-        logger.debug("---------- Together Response Start ----------")
-        # -*- Log messages for debugging
-        self._log_messages(messages)
-
-        stream_data: StreamData = StreamData()
-        metrics: Metrics = Metrics()
-        assistant_message_content = ""
-        response_is_tool_call = False
-
-        # -*- Generate response
-        metrics.start_response_timer()
-        for response in self.invoke_stream(messages=messages):
-            if len(response.choices) > 0:
-                metrics.completion_tokens += 1
-                if metrics.completion_tokens == 1:
-                    metrics.time_to_first_token = metrics.response_timer.elapsed
-
-                response_delta: ChoiceDelta = response.choices[0].delta
-                response_content: Optional[str] = response_delta.content
-                response_tool_calls: Optional[List[ChoiceDeltaToolCall]] = response_delta.tool_calls
-
-                if response_content is not None:
-                    stream_data.response_content += response_content
-                    yield ModelResponse(content=response_content)
-
-                if response_tool_calls is not None:
-                    if stream_data.response_tool_calls is None:
-                        stream_data.response_tool_calls = []
-                    stream_data.response_tool_calls.extend(response_tool_calls)
-
-            if response.usage:
-                response_usage: Optional[CompletionUsage] = response.usage
-                if response_usage:
-                    metrics.input_tokens = response_usage.prompt_tokens
-                    metrics.prompt_tokens = response_usage.prompt_tokens
-                    metrics.output_tokens = response_usage.completion_tokens
-                    metrics.completion_tokens = response_usage.completion_tokens
-                    metrics.total_tokens = response_usage.total_tokens
-        metrics.stop_response_timer()
-        logger.debug(f"Time to generate response: {metrics.response_timer.elapsed:.4f}s")
-
-        # -*- Create assistant message
-        assistant_message = Message(
-            role="assistant",
-            content=assistant_message_content,
-        )
-        # -*- Check if the response is a tool call
-        try:
-            if response_is_tool_call and assistant_message_content != "":
-                _tool_call_content = assistant_message_content.strip()
-                _tool_call_list = json.loads(_tool_call_content)
-                if isinstance(_tool_call_list, list):
-                    # Build tool calls
-                    _tool_calls: List[Dict[str, Any]] = []
-                    logger.debug(f"Building tool calls from {_tool_call_list}")
-                    for _tool_call in _tool_call_list:
-                        tool_call_name = _tool_call.get("name")
-                        tool_call_args = _tool_call.get("arguments")
-                        _function_def = {"name": tool_call_name}
-                        if tool_call_args is not None:
-                            _function_def["arguments"] = json.dumps(tool_call_args)
-                        _tool_calls.append(
-                            {
-                                "type": "function",
-                                "function": _function_def,
-                            }
-                        )
-                    assistant_message.tool_calls = _tool_calls
-        except Exception:
-            logger.warning(f"Could not parse tool calls from response: {assistant_message_content}")
-            pass
-
-        # -*- Update usage metrics
-        # Add response time to metrics
-        assistant_message.metrics["time"] = metrics.response_timer.elapsed
-        if "response_times" not in self.metrics:
-            self.metrics["response_times"] = []
-        self.metrics["response_times"].append(metrics.response_timer.elapsed)
-
-        # Add token usage to metrics
-        logger.debug(f"Estimated completion tokens: {metrics.completion_tokens}")
-        assistant_message.metrics["completion_tokens"] = metrics.completion_tokens
-        if "completion_tokens" not in self.metrics:
-            self.metrics["completion_tokens"] = metrics.completion_tokens
-        else:
-            self.metrics["completion_tokens"] += metrics.completion_tokens
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-        assistant_message.log()
-        metrics.log()
-
-        # -*- Parse and run tool calls
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            tool_role: str = "tool"
-            function_calls_to_run: List[FunctionCall] = []
-            function_call_results: List[Message] = []
-            for tool_call in assistant_message.tool_calls:
-                _tool_call_id = tool_call.get("id")
-                _function_call = get_function_call_for_tool_call(tool_call, self._functions)
-                if _function_call is None:
-                    messages.append(
-                        Message(
-                            role=tool_role,
-                            tool_call_id=_tool_call_id,
-                            content="Could not find function to call.",
-                        )
-                    )
-                    continue
-                if _function_call.error is not None:
-                    messages.append(
-                        Message(
-                            role=tool_role,
-                            tool_call_id=_tool_call_id,
-                            content=_function_call.error,
-                        )
-                    )
-                    continue
-                function_calls_to_run.append(_function_call)
-
-            if self.show_tool_calls:
-                yield ModelResponse(content="\nRunning:")
-                for _f in function_calls_to_run:
-                    yield ModelResponse(content=f"\n - {_f.get_call_str()}")
-                yield ModelResponse(content="\n\n")
-
-            for intermediate_model_response in self.run_function_calls(
-                function_calls=function_calls_to_run, function_call_results=function_call_results, tool_role=tool_role
-            ):
-                yield intermediate_model_response
 
-            if len(function_call_results) > 0:
-                messages.extend(function_call_results)
-            # -*- Yield new response using results of tool calls
-            yield from self.response_stream(messages=messages)
-        logger.debug("---------- Together Response End ----------")
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for TOGETHER_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("TOGETHER_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="TOGETHER_API_KEY not set. Please set the TOGETHER_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/utils.py

@@ -0,0 +1,266 @@
+from typing import Optional, Union
+
+from agno.models.base import Model
+
+
+def _get_model_class(model_id: str, model_provider: str) -> Model:
+    if model_provider == "aimlapi":
+        from agno.models.aimlapi import AIMLAPI
+
+        return AIMLAPI(id=model_id)
+
+    elif model_provider == "anthropic":
+        from agno.models.anthropic import Claude
+
+        return Claude(id=model_id)
+
+    elif model_provider == "aws-bedrock":
+        from agno.models.aws import AwsBedrock
+
+        return AwsBedrock(id=model_id)
+
+    elif model_provider == "aws-claude":
+        from agno.models.aws import Claude as AWSClaude
+
+        return AWSClaude(id=model_id)
+
+    elif model_provider == "azure-ai-foundry":
+        from agno.models.azure import AzureAIFoundry
+
+        return AzureAIFoundry(id=model_id)
+
+    elif model_provider == "azure-openai":
+        from agno.models.azure import AzureOpenAI
+
+        return AzureOpenAI(id=model_id)
+
+    elif model_provider == "cerebras":
+        from agno.models.cerebras import Cerebras
+
+        return Cerebras(id=model_id)
+
+    elif model_provider == "cerebras-openai":
+        from agno.models.cerebras import CerebrasOpenAI
+
+        return CerebrasOpenAI(id=model_id)
+
+    elif model_provider == "cohere":
+        from agno.models.cohere import Cohere
+
+        return Cohere(id=model_id)
+
+    elif model_provider == "cometapi":
+        from agno.models.cometapi import CometAPI
+
+        return CometAPI(id=model_id)
+
+    elif model_provider == "dashscope":
+        from agno.models.dashscope import DashScope
+
+        return DashScope(id=model_id)
+
+    elif model_provider == "deepinfra":
+        from agno.models.deepinfra import DeepInfra
+
+        return DeepInfra(id=model_id)
+
+    elif model_provider == "deepseek":
+        from agno.models.deepseek import DeepSeek
+
+        return DeepSeek(id=model_id)
+
+    elif model_provider == "fireworks":
+        from agno.models.fireworks import Fireworks
+
+        return Fireworks(id=model_id)
+
+    elif model_provider == "google":
+        from agno.models.google import Gemini
+
+        return Gemini(id=model_id)
+
+    elif model_provider == "groq":
+        from agno.models.groq import Groq
+
+        return Groq(id=model_id)
+
+    elif model_provider == "huggingface":
+        from agno.models.huggingface import HuggingFace
+
+        return HuggingFace(id=model_id)
+
+    elif model_provider == "ibm":
+        from agno.models.ibm import WatsonX
+
+        return WatsonX(id=model_id)
+
+    elif model_provider == "internlm":
+        from agno.models.internlm import InternLM
+
+        return InternLM(id=model_id)
+
+    elif model_provider == "langdb":
+        from agno.models.langdb import LangDB
+
+        return LangDB(id=model_id)
+
+    elif model_provider == "litellm":
+        from agno.models.litellm import LiteLLM
+
+        return LiteLLM(id=model_id)
+
+    elif model_provider == "litellm-openai":
+        from agno.models.litellm import LiteLLMOpenAI
+
+        return LiteLLMOpenAI(id=model_id)
+
+    elif model_provider == "llama-cpp":
+        from agno.models.llama_cpp import LlamaCpp
+
+        return LlamaCpp(id=model_id)
+
+    elif model_provider == "llama-openai":
+        from agno.models.meta import LlamaOpenAI
+
+        return LlamaOpenAI(id=model_id)
+
+    elif model_provider == "lmstudio":
+        from agno.models.lmstudio import LMStudio
+
+        return LMStudio(id=model_id)
+
+    elif model_provider == "meta":
+        from agno.models.meta import Llama
+
+        return Llama(id=model_id)
+
+    elif model_provider == "mistral":
+        from agno.models.mistral import MistralChat
+
+        return MistralChat(id=model_id)
+
+    elif model_provider == "nebius":
+        from agno.models.nebius import Nebius
+
+        return Nebius(id=model_id)
+
+    elif model_provider == "nexus":
+        from agno.models.nexus import Nexus
+
+        return Nexus(id=model_id)
+
+    elif model_provider == "nvidia":
+        from agno.models.nvidia import Nvidia
+
+        return Nvidia(id=model_id)
+
+    elif model_provider == "ollama":
+        from agno.models.ollama import Ollama
+
+        return Ollama(id=model_id)
+
+    elif model_provider == "openai":
+        from agno.models.openai import OpenAIChat
+
+        return OpenAIChat(id=model_id)
+
+    elif model_provider == "openai-responses":
+        from agno.models.openai import OpenAIResponses
+
+        return OpenAIResponses(id=model_id)
+
+    elif model_provider == "openrouter":
+        from agno.models.openrouter import OpenRouter
+
+        return OpenRouter(id=model_id)
+
+    elif model_provider == "perplexity":
+        from agno.models.perplexity import Perplexity
+
+        return Perplexity(id=model_id)
+
+    elif model_provider == "portkey":
+        from agno.models.portkey import Portkey
+
+        return Portkey(id=model_id)
+
+    elif model_provider == "requesty":
+        from agno.models.requesty import Requesty
+
+        return Requesty(id=model_id)
+
+    elif model_provider == "sambanova":
+        from agno.models.sambanova import Sambanova
+
+        return Sambanova(id=model_id)
+
+    elif model_provider == "siliconflow":
+        from agno.models.siliconflow import Siliconflow
+
+        return Siliconflow(id=model_id)
+
+    elif model_provider == "together":
+        from agno.models.together import Together
+
+        return Together(id=model_id)
+
+    elif model_provider == "vercel":
+        from agno.models.vercel import V0
+
+        return V0(id=model_id)
+
+    elif model_provider == "vertexai-claude":
+        from agno.models.vertexai.claude import Claude as VertexAIClaude
+
+        return VertexAIClaude(id=model_id)
+
+    elif model_provider == "vllm":
+        from agno.models.vllm import VLLM
+
+        return VLLM(id=model_id)
+
+    elif model_provider == "xai":
+        from agno.models.xai import xAI
+
+        return xAI(id=model_id)
+
+    else:
+        raise ValueError(f"Model provider '{model_provider}' is not supported.")
+
+
+def _parse_model_string(model_string: str) -> Model:
+    if not model_string or not isinstance(model_string, str):
+        raise ValueError(f"Model string must be a non-empty string, got: {model_string}")
+
+    if ":" not in model_string:
+        raise ValueError(
+            f"Invalid model string format: '{model_string}'. Model strings should be in format '<provider>:<model_id>' e.g. 'openai:gpt-4o'"
+        )
+
+    parts = model_string.split(":", 1)
+    if len(parts) != 2:
+        raise ValueError(
+            f"Invalid model string format: '{model_string}'. Model strings should be in format '<provider>:<model_id>' e.g. 'openai:gpt-4o'"
+        )
+
+    model_provider, model_id = parts
+    model_provider = model_provider.strip().lower()
+    model_id = model_id.strip()
+
+    if not model_provider or not model_id:
+        raise ValueError(
+            f"Invalid model string format: '{model_string}'. Model strings should be in format '<provider>:<model_id>' e.g. 'openai:gpt-4o'"
+        )
+
+    return _get_model_class(model_id, model_provider)
+
+
+def get_model(model: Union[Model, str, None]) -> Optional[Model]:
+    if model is None:
+        return None
+    elif isinstance(model, Model):
+        return model
+    elif isinstance(model, str):
+        return _parse_model_string(model)
+    else:
+        raise ValueError("Model must be a Model instance, string, or None")

agno/models/vercel/__init__.py

@@ -0,0 +1,3 @@
+from agno.models.vercel.v0 import V0
+
+__all__ = ["V0"]

agno/models/vercel/v0.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class V0(OpenAILike):
+    """
+    Class for interacting with the v0 API.
+
+    Attributes:
+        id (str): The ID of the language model. Defaults to "v0-1.0-md".
+        name (str): The name of the API. Defaults to "v0".
+        provider (str): The provider of the API. Defaults to "v0".
+        api_key (Optional[str]): The API key for the v0 API.
+        base_url (Optional[str]): The base URL for the v0 API. Defaults to "https://v0.dev/chat/settings/keys".
+    """
+
+    id: str = "v0-1.0-md"
+    name: str = "v0"
+    provider: str = "Vercel"
+
+    api_key: Optional[str] = None
+    base_url: str = "https://api.v0.dev/v1/"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for V0_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("V0_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="V0_API_KEY not set. Please set the V0_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/vertexai/__init__.py

@@ -1 +0,0 @@
-from agno.models.vertexai.gemini import Gemini