camel-ai 0.2.67__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/agents/mcp_agent.py

@@ -15,16 +15,25 @@
 import asyncio
 import json
 import platform
-import re
-from typing import Any, Callable, Dict, List, Optional, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Union,
+    cast,
+)
 
-from camel.agents import ChatAgent
+from camel.agents.chat_agent import ChatAgent
 from camel.logger import get_logger
 from camel.messages import BaseMessage
-from camel.models import BaseModelBackend, ModelFactory
+from camel.models.base_model import BaseModelBackend
+from camel.models.model_factory import ModelFactory
 from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
-from camel.toolkits import FunctionTool, MCPToolkit
+from camel.toolkits.function_tool import FunctionTool
 from camel.types import (
     BaseMCPRegistryConfig,
     MCPRegistryType,
@@ -33,6 +42,9 @@ from camel.types import (
     RoleType,
 )
 
+if TYPE_CHECKING:
+    from camel.toolkits.mcp_toolkit import MCPToolkit
+
 # AgentOps decorator setting
 try:
     import os
@@ -44,6 +56,8 @@ try:
 except (ImportError, AttributeError):
     from camel.utils import track_agent
 
+from camel.parsers.mcp_tool_call_parser import extract_tool_calls_from_text
+
 logger = get_logger(__name__)
 
 
@@ -168,8 +182,10 @@ class MCPAgent(ChatAgent):
             **kwargs,
         )
 
-    def _initialize_mcp_toolkit(self) -> MCPToolkit:
+    def _initialize_mcp_toolkit(self) -> "MCPToolkit":
         r"""Initialize the MCP toolkit from the provided configuration."""
+        from camel.toolkits.mcp_toolkit import MCPToolkit
+
         config_dict = {}
         for registry_config in self.registry_configs:
             config_dict.update(registry_config.get_config())
@@ -334,27 +350,14 @@ class MCPAgent(ChatAgent):
             task = f"## Task:\n  {input_message}"
             input_message = str(self._text_tools) + task
             response = await super().astep(input_message, *args, **kwargs)
-            content = response.msgs[0].content.lower()
-
-            tool_calls = []
-            while "```json" in content:
-                json_match = re.search(r'```json', content)
-                if not json_match:
-                    break
-                json_start = json_match.span()[1]
-
-                end_match = re.search(r'```', content[json_start:])
-                if not end_match:
-                    break
-                json_end = end_match.span()[0] + json_start
-
-                tool_json = content[json_start:json_end].strip('\n')
-                try:
-                    tool_calls.append(json.loads(tool_json))
-                except json.JSONDecodeError:
-                    logger.warning(f"Failed to parse JSON: {tool_json}")
-                    continue
-                content = content[json_end:]
+            raw_content = response.msgs[0].content if response.msgs else ""
+            content = (
+                raw_content
+                if isinstance(raw_content, str)
+                else str(raw_content)
+            )
+
+            tool_calls = extract_tool_calls_from_text(content)
 
             if not tool_calls:
                 return response

camel/agents/repo_agent.py

@@ -21,6 +21,7 @@ if TYPE_CHECKING:
 from pydantic import BaseModel
 
 from camel.agents import ChatAgent
+from camel.agents.chat_agent import StreamingChatAgentResponse
 from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.models import BaseModelBackend, ModelFactory
@@ -442,7 +443,7 @@ class RepoAgent(ChatAgent):
 
     def step(
         self, input_message: Union[BaseMessage, str], *args, **kwargs
-    ) -> ChatAgentResponse:
+    ) -> Union[ChatAgentResponse, StreamingChatAgentResponse]:
         r"""Overrides `ChatAgent.step()` to first retrieve relevant context
         from the vector store before passing the input to the language model.
         """

camel/benchmarks/browsecomp.py

@@ -619,20 +619,20 @@ class BrowseCompBenchmark(BaseBenchmark):
                         assistant_response, user_response = pipeline.step(
                             input_msg
                         )
-                        if assistant_response.terminated:  # type: ignore[attr-defined]
+                        if assistant_response.terminated:  # type: ignore[union-attr]
                             break
-                        if user_response.terminated:  # type: ignore[attr-defined]
+                        if user_response.terminated:  # type: ignore[union-attr]
                             break
-                        if "CAMEL_TASK_DONE" in user_response.msg.content:  # type: ignore[attr-defined]
+                        if "CAMEL_TASK_DONE" in user_response.msg.content:  # type: ignore[union-attr]
                             break
 
                         chat_history.append(
-                            f"AI User: {user_response.msg.content}"  # type: ignore[attr-defined]
+                            f"AI User: {user_response.msg.content}"  # type: ignore[union-attr]
                         )
                         chat_history.append(
-                            f"AI Assistant: {assistant_response.msg.content}"  # type: ignore[attr-defined]
+                            f"AI Assistant: {assistant_response.msg.content}"  # type: ignore[union-attr]
                         )
-                        input_msg = assistant_response.msg  # type: ignore[attr-defined]
+                        input_msg = assistant_response.msg  # type: ignore[union-attr]
 
                     chat_history_str = "\n".join(chat_history)
                     if roleplaying_summarizer:

camel/configs/__init__.py

@@ -11,11 +11,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from .aihubmix_config import AIHUBMIX_API_PARAMS, AihubMixConfig
 from .aiml_config import AIML_API_PARAMS, AIMLConfig
+from .amd_config import AMD_API_PARAMS, AMDConfig
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
 from .bedrock_config import BEDROCK_API_PARAMS, BedrockConfig
 from .cohere_config import COHERE_API_PARAMS, CohereConfig
+from .cometapi_config import COMETAPI_API_PARAMS, CometAPIConfig
 from .crynux_config import CRYNUX_API_PARAMS, CrynuxConfig
 from .deepseek_config import DEEPSEEK_API_PARAMS, DeepSeekConfig
 from .gemini_config import Gemini_API_PARAMS, GeminiConfig
@@ -23,9 +26,11 @@ from .groq_config import GROQ_API_PARAMS, GroqConfig
 from .internlm_config import INTERNLM_API_PARAMS, InternLMConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .lmstudio_config import LMSTUDIO_API_PARAMS, LMStudioConfig
+from .minimax_config import MINIMAX_API_PARAMS, MinimaxConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .modelscope_config import MODELSCOPE_API_PARAMS, ModelScopeConfig
 from .moonshot_config import MOONSHOT_API_PARAMS, MoonshotConfig
+from .nebius_config import NEBIUS_API_PARAMS, NebiusConfig
 from .netmind_config import NETMIND_API_PARAMS, NetmindConfig
 from .novita_config import NOVITA_API_PARAMS, NovitaConfig
 from .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
@@ -54,10 +59,14 @@ __all__ = [
     'BaseConfig',
     'ChatGPTConfig',
     'OPENAI_API_PARAMS',
+    'AihubMixConfig',
+    'AIHUBMIX_API_PARAMS',
     'AnthropicConfig',
     'ANTHROPIC_API_PARAMS',
     'GROQ_API_PARAMS',
     'GroqConfig',
+    'NEBIUS_API_PARAMS',
+    'NebiusConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
     'NetmindConfig',
@@ -86,6 +95,8 @@ __all__ = [
     'TOGETHERAI_API_PARAMS',
     'CohereConfig',
     'COHERE_API_PARAMS',
+    'CometAPIConfig',
+    'COMETAPI_API_PARAMS',
     'YiConfig',
     'YI_API_PARAMS',
     'QwenConfig',
@@ -108,10 +119,14 @@ __all__ = [
     'SILICONFLOW_API_PARAMS',
     'AIMLConfig',
     'AIML_API_PARAMS',
+    'AMDConfig',
+    'AMD_API_PARAMS',
     'OpenRouterConfig',
     'OPENROUTER_API_PARAMS',
     'LMSTUDIO_API_PARAMS',
     'LMStudioConfig',
+    'MINIMAX_API_PARAMS',
+    'MinimaxConfig',
     'WatsonXConfig',
     'WATSONX_API_PARAMS',
     'QianfanConfig',

camel/configs/aihubmix_config.py

@@ -0,0 +1,88 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import Dict, Optional, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class AihubMixConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    AihubMix API.
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.8`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`1024`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim.
+            (default: :obj:`0`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics.
+            (default: :obj:`0`)
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        web_search_options (dict, optional): Search model's web search options,
+            only supported by specific search models.
+            (default: :obj:`None`)
+        tools (list[FunctionTool], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+        parallel_tool_calls (bool, optional): A parameter specifying whether
+            the model should call tools in parallel or not.
+            (default: :obj:`None`)
+        extra_headers: Optional[Dict[str, str]]: Extra headers to use for the
+            model. (default: :obj:`None`)
+    """
+
+    temperature: Optional[float] = 0.8
+    max_tokens: Optional[int] = 1024
+    top_p: Optional[float] = 1.0
+    frequency_penalty: Optional[float] = 0.0
+    presence_penalty: Optional[float] = 0.0
+    stream: Optional[bool] = False
+    web_search_options: Optional[Dict] = None
+    tool_choice: Optional[Union[Dict[str, str], str]] = None
+    parallel_tool_calls: Optional[bool] = None
+    extra_headers: Optional[Dict[str, str]] = None
+
+
+AIHUBMIX_API_PARAMS = {param for param in AihubMixConfig.model_fields.keys()}

camel/configs/amd_config.py

@@ -0,0 +1,70 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from pydantic import Field
+
+from camel.configs.base_config import BaseConfig
+from camel.types import NotGiven
+
+
+class AMDConfig(BaseConfig):
+    r"""Configuration class for AMD API models.
+
+    This class defines the configuration parameters for AMD's language
+    models, including temperature, sampling parameters, and response format
+    settings.
+
+    Args:
+        stream (bool, optional): Whether to stream the response.
+            (default: :obj:`None`)
+        temperature (float, optional): Controls randomness in the response.
+            Higher values make output more random, lower values make it more
+            deterministic. Range: [0.0, 2.0]. (default: :obj:`None`)
+        top_p (float, optional): Controls diversity via nucleus sampling.
+            Range: [0.0, 1.0]. (default: :obj:`None`)
+        presence_penalty (float, optional): Penalizes new tokens based on
+            whether they appear in the text so far. Range: [-2.0, 2.0].
+            (default: :obj:`None`)
+        frequency_penalty (float, optional): Penalizes new tokens based on
+            their frequency in the text so far. Range: [-2.0, 2.0].
+            (default: :obj:`None`)
+        max_tokens (Union[int, NotGiven], optional): Maximum number of tokens
+            to generate. If not provided, model will use its default maximum.
+            (default: :obj:`None`)
+        seed (Optional[int], optional): Random seed for deterministic sampling.
+            (default: :obj:`None`)
+        tools (Optional[List[Dict]], optional): List of tools available to the
+            model. This includes tools such as a text editor, a calculator, or
+            a search engine. (default: :obj:`None`)
+        tool_choice (Optional[str], optional): Tool choice configuration.
+            (default: :obj:`None`)
+        stop (Optional[List[str]], optional): List of stop sequences.
+            (default: :obj:`None`)
+    """
+
+    stream: Optional[bool] = Field(default=None)
+    temperature: Optional[float] = Field(default=None)
+    top_p: Optional[float] = Field(default=None)
+    presence_penalty: Optional[float] = Field(default=None)
+    frequency_penalty: Optional[float] = Field(default=None)
+    max_tokens: Optional[Union[int, NotGiven]] = Field(default=None)
+    seed: Optional[int] = Field(default=None)
+    tool_choice: Optional[str] = Field(default=None)
+    stop: Optional[List[str]] = Field(default=None)
+
+
+AMD_API_PARAMS = {param for param in AMDConfig.model_fields.keys()}

camel/configs/cometapi_config.py

@@ -0,0 +1,104 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import Optional, Sequence, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class CometAPIConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using CometAPI's
+    OpenAI-compatible interface.
+
+    Reference: https://api.cometapi.com/v1/
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`None`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`None`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`None`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`None`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`None`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`None`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help CometAPI to monitor and detect abuse.
+            (default: :obj:`None`)
+        tools (list[FunctionTool], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    response_format: Optional[dict] = None
+    frequency_penalty: Optional[float] = None
+    user: Optional[str] = None
+    tools: Optional[list] = None
+    tool_choice: Optional[Union[dict[str, str], str]] = None
+
+
+COMETAPI_API_PARAMS = {param for param in CometAPIConfig.model_fields.keys()}

camel/configs/minimax_config.py

@@ -0,0 +1,93 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import Optional, Sequence, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class MinimaxConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility with Minimax.
+
+    Reference: https://api.minimax.chat/document/guides/chat-model
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0.0` and :obj:`1.0`. Higher values make the output more
+            random, while lower values make it more focused and deterministic.
+            Recommended to use :obj:`1.0`. Values outside this range will
+            return an error. (default: :obj:`None`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`None`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. Only supports value :obj:`1`.
+            (default: :obj:`None`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length. (default: :obj:`None`)
+        stream (bool, optional): If set, partial message deltas will be sent,
+            like in ChatGPT. Tokens will be sent as data-only server-sent
+            events as they become available, with the stream terminated by
+            a data: [DONE] message. (default: :obj:`None`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help to monitor and detect abuse.
+            (default: :obj:`None`)
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+
+    Note:
+        Some OpenAI parameters such as presence_penalty, frequency_penalty,
+        and logit_bias will be ignored by Minimax.
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    response_format: Optional[dict] = None
+    user: Optional[str] = None
+    tool_choice: Optional[Union[dict[str, str], str]] = None
+
+
+MINIMAX_API_PARAMS = {param for param in MinimaxConfig.model_fields.keys()}

camel/configs/nebius_config.py

@@ -0,0 +1,103 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import Optional, Sequence, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class NebiusConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility with Nebius AI Studio.
+
+    Reference: https://nebius.com/docs/ai-studio/api
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`None`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`None`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`None`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`None`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`None`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`None`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`None`)
+        tools (list[FunctionTool], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    response_format: Optional[dict] = None
+    frequency_penalty: Optional[float] = None
+    user: Optional[str] = None
+    tool_choice: Optional[Union[dict[str, str], str]] = None
+
+
+NEBIUS_API_PARAMS = {param for param in NebiusConfig.model_fields.keys()}