camel-ai 0.2.43__tar.gz → 0.2.45__tar.gz

{camel_ai-0.2.43 → camel_ai-0.2.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.43
+Version: 0.2.45
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -693,10 +693,10 @@ Practical guides and tutorials for implementing specific functionalities in CAME
 ### 3. Model Training & Data Generation
 | Cookbook | Description |
 |:---|:---|
-| **[Data Generation with CAMEL and Finetuning with Unsloth](https://docs.camel-ai.org/cookbooks/model_training/sft_data_generation_and_unsloth_finetuning_Qwen2_5_7B.html)** | Learn how to generate data with CAMEL and fine-tune models effectively with Unsloth. |
-| **[Data Gen with Real Function Calls and Hermes Format](https://docs.camel-ai.org/cookbooks/model_training/data_gen_with_real_function_calls_and_hermes_format.html)** | Explore how to generate data with real function calls and the Hermes format. |
-| **[CoT Data Generation and Upload Data to Huggingface](https://docs.camel-ai.org/cookbooks/model_training/cot_data_gen_upload_to_huggingface.html)** | Uncover how to generate CoT data with CAMEL and seamlessly upload it to Huggingface. |
-| **[CoT Data Generation and SFT Qwen with Unsolth](https://docs.camel-ai.org/cookbooks/model_training/cot_data_gen_sft_qwen_unsolth_upload_huggingface.html)** | Discover how to generate CoT data using CAMEL and SFT Qwen with Unsolth, and seamlessly upload your data and model to Huggingface. |
+| **[Data Generation with CAMEL and Finetuning with Unsloth](https://docs.camel-ai.org/cookbooks/data_generation/sft_data_generation_and_unsloth_finetuning_Qwen2_5_7B.html)** | Learn how to generate data with CAMEL and fine-tune models effectively with Unsloth. |
+| **[Data Gen with Real Function Calls and Hermes Format](https://docs.camel-ai.org/cookbooks/data_generation/data_gen_with_real_function_calls_and_hermes_format.html)** | Explore how to generate data with real function calls and the Hermes format. |
+| **[CoT Data Generation and Upload Data to Huggingface](https://docs.camel-ai.org/cookbooks/data_generation/distill_math_reasoning_data_from_deepseek_r1.html)** | Uncover how to generate CoT data with CAMEL and seamlessly upload it to Huggingface. |
+| **[CoT Data Generation and SFT Qwen with Unsolth](https://docs.camel-ai.org/cookbooks/data_generation/cot_data_gen_sft_qwen_unsolth_upload_huggingface.html)** | Discover how to generate CoT data using CAMEL and SFT Qwen with Unsolth, and seamlessly upload your data and model to Huggingface. |
 
 ### 4. Multi-Agent Systems & Applications
 | Cookbook | Description |

{camel_ai-0.2.43 → camel_ai-0.2.45}/README.md

@@ -372,10 +372,10 @@ Practical guides and tutorials for implementing specific functionalities in CAME
 ### 3. Model Training & Data Generation
 | Cookbook | Description |
 |:---|:---|
-| **[Data Generation with CAMEL and Finetuning with Unsloth](https://docs.camel-ai.org/cookbooks/model_training/sft_data_generation_and_unsloth_finetuning_Qwen2_5_7B.html)** | Learn how to generate data with CAMEL and fine-tune models effectively with Unsloth. |
-| **[Data Gen with Real Function Calls and Hermes Format](https://docs.camel-ai.org/cookbooks/model_training/data_gen_with_real_function_calls_and_hermes_format.html)** | Explore how to generate data with real function calls and the Hermes format. |
-| **[CoT Data Generation and Upload Data to Huggingface](https://docs.camel-ai.org/cookbooks/model_training/cot_data_gen_upload_to_huggingface.html)** | Uncover how to generate CoT data with CAMEL and seamlessly upload it to Huggingface. |
-| **[CoT Data Generation and SFT Qwen with Unsolth](https://docs.camel-ai.org/cookbooks/model_training/cot_data_gen_sft_qwen_unsolth_upload_huggingface.html)** | Discover how to generate CoT data using CAMEL and SFT Qwen with Unsolth, and seamlessly upload your data and model to Huggingface. |
+| **[Data Generation with CAMEL and Finetuning with Unsloth](https://docs.camel-ai.org/cookbooks/data_generation/sft_data_generation_and_unsloth_finetuning_Qwen2_5_7B.html)** | Learn how to generate data with CAMEL and fine-tune models effectively with Unsloth. |
+| **[Data Gen with Real Function Calls and Hermes Format](https://docs.camel-ai.org/cookbooks/data_generation/data_gen_with_real_function_calls_and_hermes_format.html)** | Explore how to generate data with real function calls and the Hermes format. |
+| **[CoT Data Generation and Upload Data to Huggingface](https://docs.camel-ai.org/cookbooks/data_generation/distill_math_reasoning_data_from_deepseek_r1.html)** | Uncover how to generate CoT data with CAMEL and seamlessly upload it to Huggingface. |
+| **[CoT Data Generation and SFT Qwen with Unsolth](https://docs.camel-ai.org/cookbooks/data_generation/cot_data_gen_sft_qwen_unsolth_upload_huggingface.html)** | Discover how to generate CoT data using CAMEL and SFT Qwen with Unsolth, and seamlessly upload your data and model to Huggingface. |
 
 ### 4. Multi-Agent Systems & Applications
 | Cookbook | Description |

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/__init__.py

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

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/datasets/few_shot_generator.py

@@ -235,6 +235,7 @@ class FewShotGenerator(BaseGenerator):
                             "synthetic": str(True),
                             "created": datetime.now().isoformat(),
                             "generator": "few_shot",
+                            "shots": [e.to_dict() for e in examples],
                         },
                     )
                 except ValidationError as e:

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/environments/single_step.py

@@ -200,7 +200,13 @@ class SingleStepEnv:
             self._states_done = [False] * self.current_batch_size
 
             observations = [
-                Observation(question=sample.question, context={}, metadata={})
+                Observation(
+                    question=sample.question,
+                    context={},
+                    metadata=sample.metadata
+                    if sample.metadata is not None
+                    else {},
+                )
                 for sample in self._states
             ]
 
@@ -214,7 +220,13 @@ class SingleStepEnv:
             self._states_done = [False] * batch_size
 
             observations = [
-                Observation(question=sample.question, context={}, metadata={})
+                Observation(
+                    question=sample.question,
+                    context={},
+                    metadata=sample.metadata
+                    if sample.metadata is not None
+                    else {},
+                )
                 for sample in self._states
             ]
 

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/extractors/python_strategies.py

@@ -22,21 +22,30 @@ logger = get_logger(__name__)
 
 
 class BoxedStrategy(BaseExtractorStrategy):
-    r"""Extracts content from \\boxed{} environments."""
+    r"""Extracts content from \\boxed{} and \boxed{} environments."""
 
     async def extract(self, text: str) -> Optional[str]:
-        r"""Extract content from \\boxed{} environments.
+        r"""Extract content from \\boxed{} and \boxed{} environments.
 
         Args:
             text (str): The input text to process.
 
         Returns:
-            Optional[str]: Content inside \\boxed{} if found, else None.
+            Optional[str]: Content inside \\boxed{} or \boxed{} if found, else
+                None.
         """
         # Find the start of the boxed content
         boxed_pattern = "\\boxed{"
-        if boxed_pattern not in text:
-            logger.debug("No \\boxed{} content found in the response")
+        single_backslash_boxed_pattern = "\boxed{"
+
+        if (
+            boxed_pattern not in text
+            and single_backslash_boxed_pattern not in text
+        ):
+            logger.debug(
+                f"Patterns '{boxed_pattern}' or "
+                f"'{single_backslash_boxed_pattern}' not found in text: {text}"
+            )
             return None
 
         start_idx = text.find(boxed_pattern) + len(boxed_pattern)

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/models/cohere_model.py

@@ -44,7 +44,28 @@ except (ImportError, AttributeError):
 
 
 class CohereModel(BaseModelBackend):
-    r"""Cohere API in a unified BaseModelBackend interface."""
+    r"""Cohere API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of Cohere series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`cohere.ClientV2().chat()`. If
+            :obj:`None`, :obj:`CohereConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Cohere service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Cohere service.
+            (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`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+    """
 
     @api_keys_required(
         [
@@ -58,6 +79,7 @@ class CohereModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ):
         import cohere
 
@@ -66,11 +88,17 @@ class CohereModel(BaseModelBackend):
 
         api_key = api_key or os.environ.get("COHERE_API_KEY")
         url = url or os.environ.get("COHERE_API_BASE_URL")
+
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+        self._client = cohere.ClientV2(
+            timeout=self._timeout, api_key=self._api_key
+        )
+        self._async_client = cohere.AsyncClientV2(
+            timeout=self._timeout, api_key=self._api_key
         )
-        self._client = cohere.ClientV2(api_key=self._api_key)
-        self._async_client = cohere.AsyncClientV2(api_key=self._api_key)
 
     def _to_openai_response(self, response: 'ChatResponse') -> ChatCompletion:
         if response.usage and response.usage.tokens:

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/models/litellm_model.py

@@ -11,6 +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 os
 from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
@@ -33,8 +34,8 @@ class LiteLLMModel(BaseModelBackend):
         model_type (Union[ModelType, str]): Model for which a backend is
             created, such as GPT-3.5-turbo, Claude-2, etc.
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into:obj:`openai.ChatCompletion.create()`.
-            If:obj:`None`, :obj:`LiteLLMConfig().as_dict()` will be used.
+            that will be fed into:obj:`completion()`. If:obj:`None`,
+            :obj:`LiteLLMConfig().as_dict()` will be used.
             (default: :obj:`None`)
         api_key (Optional[str], optional): The API key for authenticating with
             the model service. (default: :obj:`None`)
@@ -43,6 +44,10 @@ class LiteLLMModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`LiteLLMTokenCounter` will
             be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     # NOTE: Currently stream mode is not supported.
@@ -55,14 +60,15 @@ class LiteLLMModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         from litellm import completion
 
         if model_config_dict is None:
             model_config_dict = LiteLLMConfig().as_dict()
-
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self.client = completion
 
@@ -127,6 +133,7 @@ class LiteLLMModel(BaseModelBackend):
             ChatCompletion
         """
         response = self.client(
+            timeout=self._timeout,
             api_key=self._api_key,
             base_url=self._url,
             model=self.model_type,

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/models/mistral_model.py

@@ -62,6 +62,10 @@ class MistralModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter` will
             be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -77,6 +81,7 @@ class MistralModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         from mistralai import Mistral
 
@@ -85,10 +90,17 @@ class MistralModel(BaseModelBackend):
 
         api_key = api_key or os.environ.get("MISTRAL_API_KEY")
         url = url or os.environ.get("MISTRAL_API_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+        self._client = Mistral(
+            timeout_ms=int(self._timeout)
+            if self._timeout is not None
+            else None,
+            api_key=self._api_key,
+            server_url=self._url,
         )
-        self._client = Mistral(api_key=self._api_key, server_url=self._url)
 
     def _to_openai_response(
         self, response: 'ChatCompletionResponse'

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/models/reka_model.py

@@ -56,6 +56,10 @@ class RekaModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter` will
             be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -71,6 +75,7 @@ class RekaModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         from reka.client import AsyncReka, Reka
 
@@ -78,12 +83,15 @@ class RekaModel(BaseModelBackend):
             model_config_dict = RekaConfig().as_dict()
         api_key = api_key or os.environ.get("REKA_API_KEY")
         url = url or os.environ.get("REKA_API_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+        self._client = Reka(
+            api_key=self._api_key, base_url=self._url, timeout=self._timeout
         )
-        self._client = Reka(api_key=self._api_key, base_url=self._url)
         self._async_client = AsyncReka(
-            api_key=self._api_key, base_url=self._url
+            api_key=self._api_key, base_url=self._url, timeout=self._timeout
         )
 
     def _convert_reka_to_openai_response(

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/models/togetherai_model.py

@@ -96,70 +96,145 @@ class TogetherAIModel(BaseModelBackend):
             base_url=self._url,
         )
 
-    async def _arun(
+    @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 _run(
         self,
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+    ) -> 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.
+            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]]:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+                `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI client as interface call Together AI
-        # Reference: https://docs.together.ai/docs/openai-api-compatibility
-        response = await self._async_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)
 
-    def _run(
+    async def _arun(
         self,
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-        r"""Runs inference of OpenAI chat completion.
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion in async mode.
 
         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]]:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI client as interface call Together AI
-        # Reference: https://docs.together.ai/docs/openai-api-compatibility
-        response = self._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,
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
-    @property
-    def token_counter(self) -> BaseTokenCounter:
-        r"""Initialize the token counter for the model backend.
+    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()
 
-        Returns:
-            OpenAITokenCounter: The token counter following the model's
-                tokenization style.
-        """
+        if tools:
+            request_config["tools"] = tools
 
-        if not self._token_counter:
-            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
-        return self._token_counter
+        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
+
+        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
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/models/volcano_model.py

@@ -41,6 +41,10 @@ class VolcanoModel(OpenAICompatibleModel):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter`
             will be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -55,6 +59,7 @@ class VolcanoModel(OpenAICompatibleModel):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = {}
@@ -65,9 +70,9 @@ class VolcanoModel(OpenAICompatibleModel):
             or os.environ.get("VOLCANO_API_BASE_URL")
             or "https://ark.cn-beijing.volces.com/api/v3"
         )
-
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
     @property

{camel_ai-0.2.43 → camel_ai-0.2.45}/camel/runtime/__init__.py

@@ -16,6 +16,7 @@ from .configs import TaskConfig
 from .docker_runtime import DockerRuntime
 from .llm_guard_runtime import LLMGuardRuntime
 from .remote_http_runtime import RemoteHttpRuntime
+from .ubuntu_docker_runtime import UbuntuDockerRuntime
 
 # TODO: Add Celery Runtime to support distributed computing,
 # Rate Limiting, Load Balancing, etc.
@@ -26,4 +27,5 @@ __all__ = [
     "RemoteHttpRuntime",
     "LLMGuardRuntime",
     "TaskConfig",
+    "UbuntuDockerRuntime",
 ]