ag2 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

autogen/oai/groq.py

@@ -1,281 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-"""Create an OpenAI-compatible client using Groq's API.
-
-Example:
-    llm_config={
-        "config_list": [{
-            "api_type": "groq",
-            "model": "mixtral-8x7b-32768",
-            "api_key": os.environ.get("GROQ_API_KEY")
-            }
-    ]}
-
-    agent = autogen.AssistantAgent("my_agent", llm_config=llm_config)
-
-Install Groq's python library using: pip install --upgrade groq
-
-Resources:
-- https://console.groq.com/docs/quickstart
-"""
-
-from __future__ import annotations
-
-import copy
-import os
-import time
-import warnings
-from typing import Any, Dict, List
-
-from groq import Groq, Stream
-from openai.types.chat import ChatCompletion, ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion import ChatCompletionMessage, Choice
-from openai.types.completion_usage import CompletionUsage
-
-from autogen.oai.client_utils import should_hide_tools, validate_parameter
-
-# Cost per thousand tokens - Input / Output (NOTE: Convert $/Million to $/K)
-GROQ_PRICING_1K = {
-    "llama3-70b-8192": (0.00059, 0.00079),
-    "mixtral-8x7b-32768": (0.00024, 0.00024),
-    "llama3-8b-8192": (0.00005, 0.00008),
-    "gemma-7b-it": (0.00007, 0.00007),
-}
-
-
-class GroqClient:
-    """Client for Groq's API."""
-
-    def __init__(self, **kwargs):
-        """Requires api_key or environment variable to be set
-
-        Args:
-            api_key (str): The API key for using Groq (or environment variable GROQ_API_KEY needs to be set)
-        """
-        # Ensure we have the api_key upon instantiation
-        self.api_key = kwargs.get("api_key", None)
-        if not self.api_key:
-            self.api_key = os.getenv("GROQ_API_KEY")
-
-        assert (
-            self.api_key
-        ), "Please include the api_key in your config list entry for Groq or set the GROQ_API_KEY env variable."
-
-    def message_retrieval(self, response) -> List:
-        """
-        Retrieve and return a list of strings or a list of Choice.Message from the response.
-
-        NOTE: if a list of Choice.Message is returned, it currently needs to contain the fields of OpenAI's ChatCompletion Message object,
-        since that is expected for function or tool calling in the rest of the codebase at the moment, unless a custom agent is being used.
-        """
-        return [choice.message for choice in response.choices]
-
-    def cost(self, response) -> float:
-        return response.cost
-
-    @staticmethod
-    def get_usage(response) -> Dict:
-        """Return usage summary of the response using RESPONSE_USAGE_KEYS."""
-        # ...  # pragma: no cover
-        return {
-            "prompt_tokens": response.usage.prompt_tokens,
-            "completion_tokens": response.usage.completion_tokens,
-            "total_tokens": response.usage.total_tokens,
-            "cost": response.cost,
-            "model": response.model,
-        }
-
-    def parse_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Loads the parameters for Groq API from the passed in parameters and returns a validated set. Checks types, ranges, and sets defaults"""
-        groq_params = {}
-
-        # Check that we have what we need to use Groq's API
-        # We won't enforce the available models as they are likely to change
-        groq_params["model"] = params.get("model", None)
-        assert groq_params[
-            "model"
-        ], "Please specify the 'model' in your config list entry to nominate the Groq model to use."
-
-        # Validate allowed Groq parameters
-        # https://console.groq.com/docs/api-reference#chat
-        groq_params["frequency_penalty"] = validate_parameter(
-            params, "frequency_penalty", (int, float), True, None, (-2, 2), None
-        )
-        groq_params["max_tokens"] = validate_parameter(params, "max_tokens", int, True, None, (0, None), None)
-        groq_params["presence_penalty"] = validate_parameter(
-            params, "presence_penalty", (int, float), True, None, (-2, 2), None
-        )
-        groq_params["seed"] = validate_parameter(params, "seed", int, True, None, None, None)
-        groq_params["stream"] = validate_parameter(params, "stream", bool, True, False, None, None)
-        groq_params["temperature"] = validate_parameter(params, "temperature", (int, float), True, 1, (0, 2), None)
-        groq_params["top_p"] = validate_parameter(params, "top_p", (int, float), True, None, None, None)
-
-        # Groq parameters not supported by their models yet, ignoring
-        # logit_bias, logprobs, top_logprobs
-
-        # Groq parameters we are ignoring:
-        # n (must be 1), response_format (to enforce JSON but needs prompting as well), user,
-        # parallel_tool_calls (defaults to True), stop
-        # function_call (deprecated), functions (deprecated)
-        # tool_choice (none if no tools, auto if there are tools)
-
-        return groq_params
-
-    def create(self, params: Dict) -> ChatCompletion:
-
-        messages = params.get("messages", [])
-
-        # Convert AutoGen messages to Groq messages
-        groq_messages = oai_messages_to_groq_messages(messages)
-
-        # Parse parameters to the Groq API's parameters
-        groq_params = self.parse_params(params)
-
-        # Add tools to the call if we have them and aren't hiding them
-        if "tools" in params:
-            hide_tools = validate_parameter(
-                params, "hide_tools", str, False, "never", None, ["if_all_run", "if_any_run", "never"]
-            )
-            if not should_hide_tools(groq_messages, params["tools"], hide_tools):
-                groq_params["tools"] = params["tools"]
-
-        groq_params["messages"] = groq_messages
-
-        # We use chat model by default, and set max_retries to 5 (in line with typical retries loop)
-        client = Groq(api_key=self.api_key, max_retries=5)
-
-        # Token counts will be returned
-        prompt_tokens = 0
-        completion_tokens = 0
-        total_tokens = 0
-
-        # Streaming tool call recommendations
-        streaming_tool_calls = []
-
-        ans = None
-        response = client.chat.completions.create(**groq_params)
-        if groq_params["stream"]:
-            # Read in the chunks as they stream, taking in tool_calls which may be across
-            # multiple chunks if more than one suggested
-            ans = ""
-            for chunk in response:
-                ans = ans + (chunk.choices[0].delta.content or "")
-
-                if chunk.choices[0].delta.tool_calls:
-                    # We have a tool call recommendation
-                    for tool_call in chunk.choices[0].delta.tool_calls:
-                        streaming_tool_calls.append(
-                            ChatCompletionMessageToolCall(
-                                id=tool_call.id,
-                                function={
-                                    "name": tool_call.function.name,
-                                    "arguments": tool_call.function.arguments,
-                                },
-                                type="function",
-                            )
-                        )
-
-                if chunk.choices[0].finish_reason:
-                    prompt_tokens = chunk.x_groq.usage.prompt_tokens
-                    completion_tokens = chunk.x_groq.usage.completion_tokens
-                    total_tokens = chunk.x_groq.usage.total_tokens
-        else:
-            # Non-streaming finished
-            ans: str = response.choices[0].message.content
-            prompt_tokens = response.usage.prompt_tokens
-            completion_tokens = response.usage.completion_tokens
-            total_tokens = response.usage.total_tokens
-
-        if response is not None:
-            if isinstance(response, Stream):
-                # Streaming response
-                if chunk.choices[0].finish_reason == "tool_calls":
-                    groq_finish = "tool_calls"
-                    tool_calls = streaming_tool_calls
-                else:
-                    groq_finish = "stop"
-                    tool_calls = None
-
-                response_content = ans
-                response_id = chunk.id
-            else:
-                # Non-streaming response
-                # If we have tool calls as the response, populate completed tool calls for our return OAI response
-                if response.choices[0].finish_reason == "tool_calls":
-                    groq_finish = "tool_calls"
-                    tool_calls = []
-                    for tool_call in response.choices[0].message.tool_calls:
-                        tool_calls.append(
-                            ChatCompletionMessageToolCall(
-                                id=tool_call.id,
-                                function={"name": tool_call.function.name, "arguments": tool_call.function.arguments},
-                                type="function",
-                            )
-                        )
-                else:
-                    groq_finish = "stop"
-                    tool_calls = None
-
-                response_content = response.choices[0].message.content
-                response_id = response.id
-        else:
-            raise RuntimeError("Failed to get response from Groq after retrying 5 times.")
-
-        # 3. convert output
-        message = ChatCompletionMessage(
-            role="assistant",
-            content=response_content,
-            function_call=None,
-            tool_calls=tool_calls,
-        )
-        choices = [Choice(finish_reason=groq_finish, index=0, message=message)]
-
-        response_oai = ChatCompletion(
-            id=response_id,
-            model=groq_params["model"],
-            created=int(time.time()),
-            object="chat.completion",
-            choices=choices,
-            usage=CompletionUsage(
-                prompt_tokens=prompt_tokens,
-                completion_tokens=completion_tokens,
-                total_tokens=total_tokens,
-            ),
-            cost=calculate_groq_cost(prompt_tokens, completion_tokens, groq_params["model"]),
-        )
-
-        return response_oai
-
-
-def oai_messages_to_groq_messages(messages: list[Dict[str, Any]]) -> list[dict[str, Any]]:
-    """Convert messages from OAI format to Groq's format.
-    We correct for any specific role orders and types.
-    """
-
-    groq_messages = copy.deepcopy(messages)
-
-    # Remove the name field
-    for message in groq_messages:
-        if "name" in message:
-            message.pop("name", None)
-
-    return groq_messages
-
-
-def calculate_groq_cost(input_tokens: int, output_tokens: int, model: str) -> float:
-    """Calculate the cost of the completion using the Groq pricing."""
-    total = 0.0
-
-    if model in GROQ_PRICING_1K:
-        input_cost_per_k, output_cost_per_k = GROQ_PRICING_1K[model]
-        input_cost = (input_tokens / 1000) * input_cost_per_k
-        output_cost = (output_tokens / 1000) * output_cost_per_k
-        total = input_cost + output_cost
-    else:
-        warnings.warn(f"Cost calculation not available for model {model}", UserWarning)
-
-    return total

autogen/oai/mistral.py

@@ -1,279 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-"""Create an OpenAI-compatible client using Mistral.AI's API.
-
-Example:
-    llm_config={
-        "config_list": [{
-            "api_type": "mistral",
-            "model": "open-mixtral-8x22b",
-            "api_key": os.environ.get("MISTRAL_API_KEY")
-            }
-    ]}
-
-    agent = autogen.AssistantAgent("my_agent", llm_config=llm_config)
-
-Install Mistral.AI python library using: pip install --upgrade mistralai
-
-Resources:
-- https://docs.mistral.ai/getting-started/quickstart/
-
-NOTE: Requires mistralai package version >= 1.0.1
-"""
-
-import inspect
-import json
-import os
-import time
-import warnings
-from typing import Any, Dict, List, Union
-
-# Mistral libraries
-# pip install mistralai
-from mistralai import (
-    AssistantMessage,
-    Function,
-    FunctionCall,
-    Mistral,
-    SystemMessage,
-    ToolCall,
-    ToolMessage,
-    UserMessage,
-)
-from openai.types.chat import ChatCompletion, ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion import ChatCompletionMessage, Choice
-from openai.types.completion_usage import CompletionUsage
-
-from autogen.oai.client_utils import should_hide_tools, validate_parameter
-
-
-class MistralAIClient:
-    """Client for Mistral.AI's API."""
-
-    def __init__(self, **kwargs):
-        """Requires api_key or environment variable to be set
-
-        Args:
-            api_key (str): The API key for using Mistral.AI (or environment variable MISTRAL_API_KEY needs to be set)
-        """
-
-        # Ensure we have the api_key upon instantiation
-        self.api_key = kwargs.get("api_key", None)
-        if not self.api_key:
-            self.api_key = os.getenv("MISTRAL_API_KEY", None)
-
-        assert (
-            self.api_key
-        ), "Please specify the 'api_key' in your config list entry for Mistral or set the MISTRAL_API_KEY env variable."
-
-        self._client = Mistral(api_key=self.api_key)
-
-    def message_retrieval(self, response: ChatCompletion) -> Union[List[str], List[ChatCompletionMessage]]:
-        """Retrieve the messages from the response."""
-
-        return [choice.message for choice in response.choices]
-
-    def cost(self, response) -> float:
-        return response.cost
-
-    def parse_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Loads the parameters for Mistral.AI API from the passed in parameters and returns a validated set. Checks types, ranges, and sets defaults"""
-        mistral_params = {}
-
-        # 1. Validate models
-        mistral_params["model"] = params.get("model", None)
-        assert mistral_params[
-            "model"
-        ], "Please specify the 'model' in your config list entry to nominate the Mistral.ai model to use."
-
-        # 2. Validate allowed Mistral.AI parameters
-        mistral_params["temperature"] = validate_parameter(params, "temperature", (int, float), True, 0.7, None, None)
-        mistral_params["top_p"] = validate_parameter(params, "top_p", (int, float), True, None, None, None)
-        mistral_params["max_tokens"] = validate_parameter(params, "max_tokens", int, True, None, (0, None), None)
-        mistral_params["safe_prompt"] = validate_parameter(
-            params, "safe_prompt", bool, False, False, None, [True, False]
-        )
-        mistral_params["random_seed"] = validate_parameter(params, "random_seed", int, True, None, False, None)
-
-        # TODO
-        if params.get("stream", False):
-            warnings.warn(
-                "Streaming is not currently supported, streaming will be disabled.",
-                UserWarning,
-            )
-
-        # 3. Convert messages to Mistral format
-        mistral_messages = []
-        tool_call_ids = {}  # tool call ids to function name mapping
-        for message in params["messages"]:
-            if message["role"] == "assistant" and "tool_calls" in message and message["tool_calls"] is not None:
-                # Convert OAI ToolCall to Mistral ToolCall
-                mistral_messages_tools = []
-                for toolcall in message["tool_calls"]:
-                    mistral_messages_tools.append(
-                        ToolCall(
-                            id=toolcall["id"],
-                            function=FunctionCall(
-                                name=toolcall["function"]["name"],
-                                arguments=json.loads(toolcall["function"]["arguments"]),
-                            ),
-                        )
-                    )
-
-                mistral_messages.append(AssistantMessage(content="", tool_calls=mistral_messages_tools))
-
-                # Map tool call id to the function name
-                for tool_call in message["tool_calls"]:
-                    tool_call_ids[tool_call["id"]] = tool_call["function"]["name"]
-
-            elif message["role"] == "system":
-                if len(mistral_messages) > 0 and mistral_messages[-1].role == "assistant":
-                    # System messages can't appear after an Assistant message, so use a UserMessage
-                    mistral_messages.append(UserMessage(content=message["content"]))
-                else:
-                    mistral_messages.append(SystemMessage(content=message["content"]))
-            elif message["role"] == "assistant":
-                mistral_messages.append(AssistantMessage(content=message["content"]))
-            elif message["role"] == "user":
-                mistral_messages.append(UserMessage(content=message["content"]))
-
-            elif message["role"] == "tool":
-                # Indicates the result of a tool call, the name is the function name called
-                mistral_messages.append(
-                    ToolMessage(
-                        name=tool_call_ids[message["tool_call_id"]],
-                        content=message["content"],
-                        tool_call_id=message["tool_call_id"],
-                    )
-                )
-            else:
-                warnings.warn(f"Unknown message role {message['role']}", UserWarning)
-
-        # 4. Last message needs to be user or tool, if not, add a "please continue" message
-        if not isinstance(mistral_messages[-1], UserMessage) and not isinstance(mistral_messages[-1], ToolMessage):
-            mistral_messages.append(UserMessage(content="Please continue."))
-
-        mistral_params["messages"] = mistral_messages
-
-        # 5. Add tools to the call if we have them and aren't hiding them
-        if "tools" in params:
-            hide_tools = validate_parameter(
-                params, "hide_tools", str, False, "never", None, ["if_all_run", "if_any_run", "never"]
-            )
-            if not should_hide_tools(params["messages"], params["tools"], hide_tools):
-                mistral_params["tools"] = tool_def_to_mistral(params["tools"])
-
-        return mistral_params
-
-    def create(self, params: Dict[str, Any]) -> ChatCompletion:
-        # 1. Parse parameters to Mistral.AI API's parameters
-        mistral_params = self.parse_params(params)
-
-        # 2. Call Mistral.AI API
-        mistral_response = self._client.chat.complete(**mistral_params)
-        # TODO: Handle streaming
-
-        # 3. Convert Mistral response to OAI compatible format
-        if mistral_response.choices[0].finish_reason == "tool_calls":
-            mistral_finish = "tool_calls"
-            tool_calls = []
-            for tool_call in mistral_response.choices[0].message.tool_calls:
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=tool_call.id,
-                        function={"name": tool_call.function.name, "arguments": tool_call.function.arguments},
-                        type="function",
-                    )
-                )
-        else:
-            mistral_finish = "stop"
-            tool_calls = None
-
-        message = ChatCompletionMessage(
-            role="assistant",
-            content=mistral_response.choices[0].message.content,
-            function_call=None,
-            tool_calls=tool_calls,
-        )
-        choices = [Choice(finish_reason=mistral_finish, index=0, message=message)]
-
-        response_oai = ChatCompletion(
-            id=mistral_response.id,
-            model=mistral_response.model,
-            created=int(time.time()),
-            object="chat.completion",
-            choices=choices,
-            usage=CompletionUsage(
-                prompt_tokens=mistral_response.usage.prompt_tokens,
-                completion_tokens=mistral_response.usage.completion_tokens,
-                total_tokens=mistral_response.usage.prompt_tokens + mistral_response.usage.completion_tokens,
-            ),
-            cost=calculate_mistral_cost(
-                mistral_response.usage.prompt_tokens, mistral_response.usage.completion_tokens, mistral_response.model
-            ),
-        )
-
-        return response_oai
-
-    @staticmethod
-    def get_usage(response: ChatCompletion) -> Dict:
-        return {
-            "prompt_tokens": response.usage.prompt_tokens if response.usage is not None else 0,
-            "completion_tokens": response.usage.completion_tokens if response.usage is not None else 0,
-            "total_tokens": (
-                response.usage.prompt_tokens + response.usage.completion_tokens if response.usage is not None else 0
-            ),
-            "cost": response.cost if hasattr(response, "cost") else 0,
-            "model": response.model,
-        }
-
-
-def tool_def_to_mistral(tool_definitions: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Converts AutoGen tool definition to a mistral tool format"""
-
-    mistral_tools = []
-
-    for autogen_tool in tool_definitions:
-        mistral_tool = {
-            "type": "function",
-            "function": Function(
-                name=autogen_tool["function"]["name"],
-                description=autogen_tool["function"]["description"],
-                parameters=autogen_tool["function"]["parameters"],
-            ),
-        }
-
-        mistral_tools.append(mistral_tool)
-
-    return mistral_tools
-
-
-def calculate_mistral_cost(input_tokens: int, output_tokens: int, model_name: str) -> float:
-    """Calculate the cost of the mistral response."""
-
-    # Prices per 1 thousand tokens
-    # https://mistral.ai/technology/
-    model_cost_map = {
-        "open-mistral-7b": {"input": 0.00025, "output": 0.00025},
-        "open-mixtral-8x7b": {"input": 0.0007, "output": 0.0007},
-        "open-mixtral-8x22b": {"input": 0.002, "output": 0.006},
-        "mistral-small-latest": {"input": 0.001, "output": 0.003},
-        "mistral-medium-latest": {"input": 0.00275, "output": 0.0081},
-        "mistral-large-latest": {"input": 0.0003, "output": 0.0003},
-        "mistral-large-2407": {"input": 0.0003, "output": 0.0003},
-        "open-mistral-nemo-2407": {"input": 0.0003, "output": 0.0003},
-        "codestral-2405": {"input": 0.001, "output": 0.003},
-    }
-
-    # Ensure we have the model they are using and return the total cost
-    if model_name in model_cost_map:
-        costs = model_cost_map[model_name]
-
-        return (input_tokens * costs["input"] / 1000) + (output_tokens * costs["output"] / 1000)
-    else:
-        warnings.warn(f"Cost calculation is not implemented for model {model_name}, will return $0.", UserWarning)
-        return 0