camel-ai 0.2.26__tar.gz → 0.2.28__tar.gz

{camel_ai-0.2.26 → camel_ai-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.26
+Version: 0.2.28
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.26'
+__version__ = '0.2.28'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/models/__init__.py

@@ -37,9 +37,11 @@ from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
 from .sglang_model import SGLangModel
+from .siliconflow_model import SiliconFlowModel
 from .stub_model import StubModel
 from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
+from .volcano_model import VolcanoModel
 from .yi_model import YiModel
 from .zhipuai_model import ZhipuAIModel
 
@@ -76,4 +78,6 @@ __all__ = [
     'MoonshotModel',
     'AIMLModel',
     'BaseAudioModel',
+    'SiliconFlowModel',
+    'VolcanoModel',
 ]

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/models/azure_openai_model.py

@@ -128,18 +128,23 @@ class AzureOpenAIModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        response = self._client.chat.completions.create(
-            messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
-            **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -152,18 +157,93 @@ class AzureOpenAIModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        response = await self._async_client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
             messages=messages,
             model=self.azure_deployment_name,  # type:ignore[arg-type]
-            **self.model_config_dict,
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
         )
-        return response
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any
@@ -183,7 +263,8 @@ class AzureOpenAIModel(BaseModelBackend):
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode,
-            which sends partial results each time.
+        which sends partial results each time.
+
         Returns:
             bool: Whether the model is in stream mode.
         """

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/models/model_factory.py

@@ -37,6 +37,7 @@ from camel.models.siliconflow_model import SiliconFlowModel
 from camel.models.stub_model import StubModel
 from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
+from camel.models.volcano_model import VolcanoModel
 from camel.models.yi_model import YiModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType, UnifiedModelType
@@ -107,6 +108,8 @@ class ModelFactory:
             model_class = SiliconFlowModel
         elif model_platform.is_aiml:
             model_class = AIMLModel
+        elif model_platform.is_volcano:
+            model_class = VolcanoModel
 
         elif model_platform.is_openai and model_type.is_openai:
             model_class = OpenAIModel

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/models/openai_compatible_model.py

@@ -86,18 +86,23 @@ class OpenAICompatibleModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        response = self._client.chat.completions.create(
-            messages=messages,
-            model=self.model_type,
-            **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -110,18 +115,93 @@ class OpenAICompatibleModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        response = await self._async_client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
     @property
     def token_counter(self) -> BaseTokenCounter:

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/models/sglang_model.py

@@ -350,8 +350,9 @@ def _wait_for_server(base_url: str, timeout: Optional[int] = 30) -> None:
     r"""Wait for the server to be ready by polling the /v1/models endpoint.
 
     Args:
-        base_url: The base URL of the server
-        timeout: Maximum time to wait in seconds. Default is 30 seconds.
+        base_url (str): The base URL of the server
+        timeout (Optional[int]): Maximum time to wait in seconds.
+            (default: :obj:`30`)
     """
     import requests
 

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/models/vllm_model.py

@@ -139,6 +139,10 @@ class VLLMModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]], optional): The format
+                to return the response in.
+            tools (Optional[List[Dict[str, Any]]], optional): List of tools
+                the model may call.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
@@ -146,10 +150,16 @@ class VLLMModel(BaseModelBackend):
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
 
+        kwargs = self.model_config_dict.copy()
+        if tools:
+            kwargs["tools"] = tools
+        if response_format:
+            kwargs["response_format"] = {"type": "json_object"}
+
         response = await self._async_client.chat.completions.create(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **kwargs,
         )
         return response
 
@@ -164,6 +174,10 @@ class VLLMModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]], optional): The format
+                to return the response in.
+            tools (Optional[List[Dict[str, Any]]], optional): List of tools
+                the model may call.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
@@ -171,10 +185,16 @@ class VLLMModel(BaseModelBackend):
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
 
+        kwargs = self.model_config_dict.copy()
+        if tools:
+            kwargs["tools"] = tools
+        if response_format:
+            kwargs["response_format"] = {"type": "json_object"}
+
         response = self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **kwargs,
         )
         return response
 

camel_ai-0.2.28/camel/models/volcano_model.py

@@ -0,0 +1,100 @@
+# ========= 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. =========
+
+import os
+from typing import Any, Dict, Optional, Union
+
+from camel.configs import OPENAI_API_PARAMS
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class VolcanoModel(OpenAICompatibleModel):
+    r"""Volcano Engine API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into the API call. If
+            :obj:`None`, :obj:`{}` will be used. (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Volcano Engine service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Volcano Engine service.
+            (default: :obj:`https://ark.cn-beijing.volces.com/api/v3`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter`
+            will be used. (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", "VOLCANO_API_KEY"),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = {}
+
+        api_key = api_key or os.environ.get("VOLCANO_API_KEY")
+        url = (
+            url
+            or os.environ.get("VOLCANO_API_BASE_URL")
+            or "https://ark.cn-beijing.volces.com/api/v3"
+        )
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            # Use OpenAI token counter as an approximation
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration is valid for Volcano
+        model backends.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Volcano API.
+        """
+        # Using OpenAI API params as Volcano Engine API is OpenAI-compatible
+        for param in self.model_config_dict:
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Volcano model backend."
+                )

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/storages/graph_storages/neo4j_graph.py

@@ -343,14 +343,14 @@ class Neo4jGraph(BaseGraphStorage):
         self, subj: str, obj: str, rel: str, timestamp: Optional[str] = None
     ) -> None:
         r"""Adds a relationship (triplet) between two entities
-            in the database with a timestamp.
+        in the database with a timestamp.
 
         Args:
             subj (str): The identifier for the subject entity.
             obj (str): The identifier for the object entity.
             rel (str): The relationship between the subject and object.
             timestamp (Optional[str]): The timestamp of the relationship.
-                                Defaults to None.
+                Defaults to None.
         """
         query = """
             MERGE (n1:`%s` {id:$subj})
@@ -737,21 +737,23 @@ class Neo4jGraph(BaseGraphStorage):
         obj: Optional[str] = None,
         rel: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
-        r"""
-        Query triplet information. If subj, obj, or rel is
+        r"""Query triplet information. If subj, obj, or rel is
         not specified, returns all matching triplets.
 
         Args:
             subj (Optional[str]): The ID of the subject node.
-                        If None, matches any subject node.
+                If None, matches any subject node.
+                (default: :obj:`None`)
             obj (Optional[str]): The ID of the object node.
-                        If None, matches any object node.
+                If None, matches any object node.
+                (default: :obj:`None`)
             rel (Optional[str]): The type of relationship.
-                        If None, matches any relationship type.
+                If None, matches any relationship type.
+                (default: :obj:`None`)
 
         Returns:
             List[Dict[str, Any]]: A list of matching triplets,
-                    each containing subj, obj, rel, and timestamp.
+                each containing subj, obj, rel, and timestamp.
         """
         import logging
 

{camel_ai-0.2.26 → camel_ai-0.2.28}/camel/toolkits/__init__.py

@@ -55,7 +55,7 @@ from .excel_toolkit import ExcelToolkit
 from .video_analysis_toolkit import VideoAnalysisToolkit
 from .image_analysis_toolkit import ImageAnalysisToolkit
 from .mcp_toolkit import MCPToolkit
-from .web_toolkit import WebToolkit
+from .browser_toolkit import BrowserToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
 from .pubmed_toolkit import PubMedToolkit
@@ -98,11 +98,12 @@ __all__ = [
     'SymPyToolkit',
     'MinerUToolkit',
     'MCPToolkit',
+    'MCPToolkitManager',
     'AudioAnalysisToolkit',
     'ExcelToolkit',
     'VideoAnalysisToolkit',
     'ImageAnalysisToolkit',
-    'WebToolkit',
+    'BrowserToolkit',
     'FileWriteToolkit',
     'TerminalToolkit',
     'PubMedToolkit',