camel-ai 0.2.11__py3-none-any.whl → 0.2.12__py3-none-any.whl

camel/models/sglang_model.py

@@ -0,0 +1,225 @@
+# ========= 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 logging
+import threading
+import time
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import SGLANG_API_PARAMS, SGLangConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import BaseTokenCounter, OpenAITokenCounter
+
+
+class SGLangModel(BaseModelBackend):
+    r"""SGLang service 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:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`SGLangConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the model service. SGLang doesn't need API key, it would be ignored
+            if set. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service. If not
+            provided, :obj:`"http://127.0.0.1:30000/v1"` will be used.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+
+    Reference: https://sgl-project.github.io/backend/openai_api_completions.html
+    """
+
+    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 = SGLangConfig().as_dict()
+
+        self.server_process = None
+        self.last_run_time: Optional[float] = (
+            None  # Will be set when the server starts
+        )
+        self._lock = threading.Lock()
+        self._inactivity_thread: Optional[threading.Thread] = None
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+
+        self._client = None
+
+        if self._url:
+            # Initialize the client if an existing URL is provided
+            self._client = OpenAI(
+                timeout=60,
+                max_retries=3,
+                api_key="Set-but-ignored",  # required but ignored
+                base_url=self._url,
+            )
+
+    def _start_server(self) -> None:
+        from sglang.utils import (  # type: ignore[import-untyped]
+            execute_shell_command,
+            wait_for_server,
+        )
+
+        try:
+            if not self._url:
+                cmd = (
+                    f"python -m sglang.launch_server "
+                    f"--model-path {self.model_type} "
+                    f"--port 30000 "
+                    f"--host 0.0.0.0"
+                )
+
+                server_process = execute_shell_command(cmd)
+                wait_for_server("http://localhost:30000")
+                self._url = "http://127.0.0.1:30000/v1"
+                self.server_process = server_process
+                # Start the inactivity monitor in a background thread
+                self._inactivity_thread = threading.Thread(
+                    target=self._monitor_inactivity, daemon=True
+                )
+                self._inactivity_thread.start()
+            self.last_run_time = time.time()
+            # Initialize the client after the server starts
+            self._client = OpenAI(
+                timeout=60,
+                max_retries=3,
+                api_key="Set-but-ignored",  # required but ignored
+                base_url=self._url,
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to start SGLang server: {e}") from e
+
+    def _ensure_server_running(self) -> None:
+        r"""Ensures that the server is running. If not, starts the server."""
+        with self._lock:
+            if self.server_process is None:
+                self._start_server()
+
+    def _monitor_inactivity(self):
+        r"""Monitor whether the server process has been inactive for over 10
+        minutes.
+        """
+        from sglang.utils import terminate_process
+
+        while True:
+            # Check every 10 seconds
+            time.sleep(10)
+            # Over 10 minutes
+            with self._lock:
+                # Over 10 minutes
+                if self.last_run_time and (
+                    time.time() - self.last_run_time > 600
+                ):
+                    if self.server_process:
+                        terminate_process(self.server_process)
+                        self.server_process = None
+                        self._client = None  # Invalidate the client
+                        logging.info(
+                            "Server process terminated due to inactivity."
+                        )
+                    break
+
+    @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:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to SGLang API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in SGLANG_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into SGLang model backend."
+                )
+
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+
+        # Ensure server is running
+        self._ensure_server_running()
+
+        with self._lock:
+            # Update last run time
+            self.last_run_time = time.time()
+
+        if self._client is None:
+            raise RuntimeError(
+                "Client is not initialized. Ensure the server is running."
+            )
+
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+
+        return response
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/vllm_model.py

@@ -74,7 +74,7 @@ class VLLMModel(BaseModelBackend):
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            api_key="Set-but-ignored",  # required but ignored
+            api_key="EMPTY",  # required but ignored
             base_url=self._url,
         )
 

camel/personas/persona_hub.py

@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-import ast
+import json
 import re
 import uuid
 from functools import lru_cache
@@ -130,7 +130,7 @@ class PersonaHub:
                 text_to_persona_prompt_instruction,
                 response_format=PersonaResponse,  # type: ignore[arg-type]
             )
-            parsed_content = ast.literal_eval(response.msg.content)
+            parsed_content = json.loads(response.msg.content)
             persona.name = parsed_content["persona_name"]
             persona.description = parsed_content["persona_description"]
         except Exception as e:

camel/schemas/openai_converter.py

@@ -28,8 +28,8 @@ from camel.utils import (
 from .base import BaseConverter
 
 DEFAULT_CONVERTER_PROMPTS = """
-    Extract key entities and attributes from the provided text,
-        and convert them into a structured JSON format.
+    Extract key entities and attributes from the user 
+    provided text, and convert them into a structured JSON format.
 """
 
 

camel/societies/workforce/role_playing_worker.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import ast
+import json
 from typing import Dict, List, Optional
 
 from colorama import Fore
@@ -173,7 +173,7 @@ class RolePlayingWorker(Worker):
             content=prompt,
         )
         response = self.summarize_agent.step(req, response_format=TaskResult)
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
         task.result = task_result.content
 

camel/societies/workforce/single_agent_worker.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import ast
+import json
 from typing import Any, List
 
 from colorama import Fore
@@ -87,7 +87,7 @@ class SingleAgentWorker(Worker):
 
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
 
         color = Fore.RED if task_result.failed else Fore.GREEN

camel/societies/workforce/workforce.py

@@ -13,8 +13,8 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import ast
 import asyncio
+import json
 import logging
 from collections import deque
 from typing import Deque, Dict, List, Optional
@@ -289,7 +289,7 @@ class Workforce(BaseNode):
         response = self.coordinator_agent.step(
             req, response_format=TaskAssignResult
         )
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         task_assign_result = TaskAssignResult(**result_dict)
         return task_assign_result.assignee_id
 
@@ -320,7 +320,7 @@ class Workforce(BaseNode):
             content=prompt,
         )
         response = self.coordinator_agent.step(req, response_format=WorkerConf)
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         new_node_conf = WorkerConf(**result_dict)
 
         new_agent = self._create_new_agent(

camel/storages/object_storages/amazon_s3.py

@@ -17,7 +17,7 @@ from pathlib import Path, PurePath
 from typing import Optional, Tuple
 from warnings import warn
 
-from camel.loaders import File
+from camel.loaders import File, create_file_from_raw_bytes
 from camel.storages.object_storages.base import BaseObjectStorage
 
 
@@ -156,7 +156,7 @@ class AmazonS3Storage(BaseObjectStorage):
             Bucket=self._bucket_name, Key=file_key
         )
         raw_bytes = response["Body"].read()
-        return File.create_file_from_raw_bytes(raw_bytes, filename)
+        return create_file_from_raw_bytes(raw_bytes, filename)
 
     def _upload_file(
         self, local_file_path: Path, remote_file_key: str

camel/storages/object_storages/azure_blob.py

@@ -16,7 +16,7 @@ from pathlib import Path, PurePath
 from typing import Optional, Tuple
 from warnings import warn
 
-from camel.loaders import File
+from camel.loaders import File, create_file_from_raw_bytes
 from camel.storages.object_storages.base import BaseObjectStorage
 
 
@@ -123,7 +123,7 @@ class AzureBlobStorage(BaseObjectStorage):
             File: The object from the container.
         """
         raw_bytes = self._client.download_blob(file_key).readall()
-        file = File.create_file_from_raw_bytes(raw_bytes, filename)
+        file = create_file_from_raw_bytes(raw_bytes, filename)
         return file
 
     def _upload_file(

camel/storages/object_storages/google_cloud.py

@@ -15,7 +15,7 @@ from pathlib import Path, PurePath
 from typing import Tuple
 from warnings import warn
 
-from camel.loaders import File
+from camel.loaders import File, create_file_from_raw_bytes
 from camel.storages.object_storages.base import BaseObjectStorage
 
 
@@ -111,7 +111,7 @@ class GoogleCloudStorage(BaseObjectStorage):
             File: The object from the S3 bucket.
         """
         raw_bytes = self._client.get_blob(file_key).download_as_bytes()
-        return File.create_file_from_raw_bytes(raw_bytes, filename)
+        return create_file_from_raw_bytes(raw_bytes, filename)
 
     def _upload_file(
         self, local_file_path: Path, remote_file_key: str

camel/toolkits/__init__.py

@@ -41,6 +41,7 @@ from .open_api_toolkit import OpenAPIToolkit
 from .retrieval_toolkit import RetrievalToolkit
 from .notion_toolkit import NotionToolkit
 from .human_toolkit import HumanToolkit
+from .stripe_toolkit import StripeToolkit
 from .video_toolkit import VideoDownloaderToolkit
 
 __all__ = [
@@ -70,5 +71,6 @@ __all__ = [
     'ArxivToolkit',
     'HumanToolkit',
     'VideoDownloaderToolkit',
+    'StripeToolkit',
     'MeshyToolkit',
 ]

camel/toolkits/code_execution.py

@@ -15,6 +15,7 @@ from typing import List, Literal, Optional, Union
 
 from camel.interpreters import (
     DockerInterpreter,
+    E2BInterpreter,
     InternalPythonInterpreter,
     JupyterKernelInterpreter,
     SubprocessInterpreter,
@@ -41,7 +42,7 @@ class CodeExecutionToolkit(BaseToolkit):
     def __init__(
         self,
         sandbox: Literal[
-            "internal_python", "jupyter", "docker", "subprocess"
+            "internal_python", "jupyter", "docker", "subprocess", "e2b"
         ] = "internal_python",
         verbose: bool = False,
         unsafe_mode: bool = False,
@@ -58,6 +59,7 @@ class CodeExecutionToolkit(BaseToolkit):
             JupyterKernelInterpreter,
             DockerInterpreter,
             SubprocessInterpreter,
+            E2BInterpreter,
         ]
 
         if sandbox == "internal_python":
@@ -83,6 +85,8 @@ class CodeExecutionToolkit(BaseToolkit):
                 print_stdout=self.verbose,
                 print_stderr=self.verbose,
             )
+        elif sandbox == "e2b":
+            self.interpreter = E2BInterpreter(require_confirm=require_confirm)
         else:
             raise RuntimeError(
                 f"The sandbox type `{sandbox}` is not supported."

camel/toolkits/function_tool.py

@@ -165,9 +165,15 @@ def get_openai_tool_schema(func: Callable) -> Dict[str, Any]:
     else:
         func_description = short_description
 
+    # OpenAI client.beta.chat.completions.parse for structured output has
+    # additional requirements for the schema, refer:
+    # https://platform.openai.com/docs/guides/structured-outputs/some-type-specific-keywords-are-not-yet-supported#supported-schemas
+    parameters_dict["additionalProperties"] = False
+
     openai_function_schema = {
         "name": func.__name__,
         "description": func_description,
+        "strict": True,
         "parameters": parameters_dict,
     }
 
@@ -175,9 +181,44 @@ def get_openai_tool_schema(func: Callable) -> Dict[str, Any]:
         "type": "function",
         "function": openai_function_schema,
     }
+
+    openai_tool_schema = sanitize_and_enforce_required(openai_tool_schema)
     return openai_tool_schema
 
 
+def sanitize_and_enforce_required(parameters_dict):
+    r"""Cleans and updates the function schema to conform with OpenAI's
+    requirements:
+    - Removes invalid 'default' fields from the parameters schema.
+    - Ensures all fields or function parameters are marked as required.
+
+    Args:
+        parameters_dict (dict): The dictionary representing the function
+            schema.
+
+    Returns:
+        dict: The updated dictionary with invalid defaults removed and all
+            fields set as required.
+    """
+    # Check if 'function' and 'parameters' exist
+    if (
+        'function' in parameters_dict
+        and 'parameters' in parameters_dict['function']
+    ):
+        # Access the 'parameters' section
+        parameters = parameters_dict['function']['parameters']
+        properties = parameters.get('properties', {})
+
+        # Remove 'default' key from each property
+        for field in properties.values():
+            field.pop('default', None)
+
+        # Mark all keys in 'properties' as required
+        parameters['required'] = list(properties.keys())
+
+    return parameters_dict
+
+
 def generate_docstring(
     code: str,
     model: Optional[BaseModelBackend] = None,

camel/toolkits/math_toolkit.py

@@ -22,44 +22,73 @@ class MathToolkit(BaseToolkit):
     r"""A class representing a toolkit for mathematical operations.
 
     This class provides methods for basic mathematical operations such as
-    addition, subtraction, and multiplication.
+    addition, subtraction, multiplication, division, and rounding.
     """
 
-    def add(self, a: int, b: int) -> int:
+    def add(self, a: float, b: float) -> float:
         r"""Adds two numbers.
 
         Args:
-            a (int): The first number to be added.
-            b (int): The second number to be added.
+            a (float): The first number to be added.
+            b (float): The second number to be added.
 
         Returns:
-            integer: The sum of the two numbers.
+            float: The sum of the two numbers.
         """
         return a + b
 
-    def sub(self, a: int, b: int) -> int:
+    def sub(self, a: float, b: float) -> float:
         r"""Do subtraction between two numbers.
 
         Args:
-            a (int): The minuend in subtraction.
-            b (int): The subtrahend in subtraction.
+            a (float): The minuend in subtraction.
+            b (float): The subtrahend in subtraction.
 
         Returns:
-            integer: The result of subtracting :obj:`b` from :obj:`a`.
+            float: The result of subtracting :obj:`b` from :obj:`a`.
         """
         return a - b
 
-    def mul(self, a: int, b: int) -> int:
-        r"""Multiplies two integers.
+    def multiply(self, a: float, b: float, decimal_places: int = 2) -> float:
+        r"""Multiplies two numbers.
 
         Args:
-            a (int): The multiplier in the multiplication.
-            b (int): The multiplicand in the multiplication.
+            a (float): The multiplier in the multiplication.
+            b (float): The multiplicand in the multiplication.
+            decimal_places (int, optional): The number of decimal
+                places to round to. Defaults to 2.
 
         Returns:
-            integer: The product of the two numbers.
+            float: The product of the two numbers.
         """
-        return a * b
+        return round(a * b, decimal_places)
+
+    def divide(self, a: float, b: float, decimal_places: int = 2) -> float:
+        r"""Divides two numbers.
+
+        Args:
+            a (float): The dividend in the division.
+            b (float): The divisor in the division.
+            decimal_places (int, optional): The number of
+                decimal places to round to. Defaults to 2.
+
+        Returns:
+            float: The result of dividing :obj:`a` by :obj:`b`.
+        """
+        return round(a / b, decimal_places)
+
+    def round(self, a: float, decimal_places: int = 0) -> float:
+        r"""Rounds a number to a specified number of decimal places.
+
+        Args:
+            a (float): The number to be rounded.
+            decimal_places (int, optional): The number of decimal places
+                to round to. Defaults to 0.
+
+        Returns:
+            float: The rounded number.
+        """
+        return round(a, decimal_places)
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
@@ -72,5 +101,7 @@ class MathToolkit(BaseToolkit):
         return [
             FunctionTool(self.add),
             FunctionTool(self.sub),
-            FunctionTool(self.mul),
+            FunctionTool(self.multiply),
+            FunctionTool(self.divide),
+            FunctionTool(self.round),
         ]