camel-ai 0.2.50__tar.gz → 0.2.51__tar.gz

{camel_ai-0.2.50 → camel_ai-0.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.50
+Version: 0.2.51
 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.50 → camel_ai-0.2.51}/camel/__init__.py

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

{camel_ai-0.2.50 → camel_ai-0.2.51}/camel/environments/single_step.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import asyncio
 import random
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -58,6 +59,7 @@ class SingleStepEnv:
         self,
         dataset: Union[StaticDataset, BaseGenerator],
         verifier: BaseVerifier,
+        timeout: Optional[float] = 180.0,
         **kwargs,
     ) -> None:
         r"""Initialize the SingleStepEnv.
@@ -67,12 +69,15 @@ class SingleStepEnv:
                 problems from.
             verifier (BaseVerifier): Verifier used to evaluate LLM responses
                 against ground-truth answers.
+            timeout (Optional[float], optional): The execution timeout in
+                seconds. (default: :obj:`180.0`)
             **kwargs: Optional metadata or configuration values.
 
         Notes:
             This class assumes all interactions are single-step: one question,
             one LLM response, one reward.
         """
+        self._timeout = timeout
         self.dataset = dataset
         self.verifier = verifier
         self._metadata = kwargs
@@ -279,6 +284,7 @@ class SingleStepEnv:
                 or if `reset()` has not been called.
             ValueError: If invalid action format, duplicate indices,
                 or out-of-bounds indices are detected.
+            asyncio.TimeoutError: If the step execution exceeds the timeout.
         """
 
         if not self._is_setup:
@@ -307,18 +313,34 @@ class SingleStepEnv:
                 f"total batch size ({self.current_batch_size})"
             )
 
-        indices = [act.index for act in actions]
         proposed_solutions = [act.llm_response for act in actions]
-        ground_truths: List[str] = []
-        for idx in indices:
-            ground_truths.append(self._states[idx].final_answer)
+        ground_truths: List[str] = [
+            self._states[idx].final_answer for idx in indices
+        ]
 
         try:
-            verification_results = await self.verifier.verify_batch(
-                solutions=proposed_solutions,
-                reference_answers=ground_truths,  # type: ignore [arg-type]
-                raise_on_error=True,
+            verification_results = await asyncio.wait_for(
+                self.verifier.verify_batch(
+                    solutions=proposed_solutions,
+                    reference_answers=ground_truths,  # type: ignore [arg-type]
+                    raise_on_error=True,
+                ),
+                timeout=self._timeout,
+            )
+        except asyncio.TimeoutError as e:
+            logger.error(
+                f"Step verification timed out after {self._timeout}s: {e}"
             )
+            # Return timeout verification results
+            verification_results = [
+                VerificationResult(
+                    result="",
+                    status=VerificationOutcome.TIMEOUT,
+                    error_message=f"Verification timed out "
+                    f"after {self._timeout}s",
+                )
+                for _ in range(len(proposed_solutions))
+            ]
         except Exception as e:
             logger.error(f"Verification failed: {e}")
             # Return failed verification results with status=FAILURE
@@ -331,9 +353,55 @@ class SingleStepEnv:
                 for _ in range(len(proposed_solutions))
             ]
 
-        total_rewards, rewards_dicts = await self._compute_reward_batch(
-            proposed_solutions, verification_results
-        )
+        # Track which solutions have been processed and which have timed out
+        total_rewards = [0.0] * len(proposed_solutions)
+        rewards_dicts = [{"correctness": 0.0}] * len(proposed_solutions)
+
+        try:
+            # First try to compute all rewards with a timeout
+            computed_rewards, computed_rewards_dicts = await asyncio.wait_for(
+                self._compute_reward_batch(
+                    proposed_solutions, verification_results
+                ),
+                timeout=self._timeout,
+            )
+            # If successful, use all the computed values
+            total_rewards = computed_rewards
+            rewards_dicts = computed_rewards_dicts
+        except asyncio.TimeoutError as e:
+            logger.error(
+                f"Reward computation timed out after {self._timeout}s: {e}"
+            )
+            # Try to compute rewards one by one to identify which ones time out
+            for i, (solution, result) in enumerate(
+                zip(proposed_solutions, verification_results)
+            ):
+                try:
+                    individual_rewards = await asyncio.wait_for(
+                        self._compute_custom_reward(solution, result),
+                        timeout=self._timeout,
+                    )
+                    # If successful, calculate the reward for this solution
+                    correctness_reward = (
+                        self.ACCURACY_REWARD if result.status else 0.0
+                    )
+                    rewards_dict = {
+                        "correctness": correctness_reward,
+                        **individual_rewards,
+                    }
+                    total_rewards[i] = sum(rewards_dict.values())
+                    rewards_dicts[i] = rewards_dict
+                except asyncio.TimeoutError:
+                    logger.warning(
+                        f"Reward computation for solution {i} timed out"
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Error computing reward for solution {i}: {e}"
+                    )
+        except Exception as e:
+            logger.error(f"Reward computation failed: {e}")
+
         # Create and return step results in batch
         step_results = [
             StepResult(

{camel_ai-0.2.50 → camel_ai-0.2.51}/camel/models/azure_openai_model.py

@@ -12,7 +12,7 @@
 # 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 typing import Any, Callable, Dict, List, Optional, Type, Union
 
 from openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream
 from pydantic import BaseModel
@@ -27,6 +27,8 @@ from camel.types import (
 )
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
+AzureADTokenProvider = Callable[[], str]
+
 
 class AzureOpenAIModel(BaseModelBackend):
     r"""Azure OpenAI API in a unified BaseModelBackend interface.
@@ -46,6 +48,12 @@ class AzureOpenAIModel(BaseModelBackend):
             (default: :obj:`None`)
         azure_deployment_name (Optional[str], optional): The deployment name
             you chose when you deployed an azure model. (default: :obj:`None`)
+        azure_ad_token (Optional[str], optional): Your Azure Active Directory
+            token, https://www.microsoft.com/en-us/security/business/
+            identity-access/microsoft-entra-id. (default: :obj:`None`)
+        azure_ad_token_provider (Optional[AzureADTokenProvider], optional): A
+            function that returns an Azure Active Directory token, will be
+            invoked on every request. (default: :obj:`None`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter`
             will be used. (default: :obj:`None`)
@@ -68,6 +76,8 @@ class AzureOpenAIModel(BaseModelBackend):
         token_counter: Optional[BaseTokenCounter] = None,
         api_version: Optional[str] = None,
         azure_deployment_name: Optional[str] = None,
+        azure_ad_token_provider: Optional["AzureADTokenProvider"] = None,
+        azure_ad_token: Optional[str] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
@@ -79,15 +89,19 @@ class AzureOpenAIModel(BaseModelBackend):
         )
 
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
-        self.azure_deployment_name = azure_deployment_name or os.environ.get(
+        self._azure_deployment_name = azure_deployment_name or os.environ.get(
             "AZURE_DEPLOYMENT_NAME"
         )
+        self._azure_ad_token = azure_ad_token or os.environ.get(
+            "AZURE_AD_TOKEN"
+        )
+        self.azure_ad_token_provider = azure_ad_token_provider
         if self.api_version is None:
             raise ValueError(
                 "Must provide either the `api_version` argument "
                 "or `AZURE_API_VERSION` environment variable."
             )
-        if self.azure_deployment_name is None:
+        if self._azure_deployment_name is None:
             raise ValueError(
                 "Must provide either the `azure_deployment_name` argument "
                 "or `AZURE_DEPLOYMENT_NAME` environment variable."
@@ -95,18 +109,22 @@ class AzureOpenAIModel(BaseModelBackend):
 
         self._client = AzureOpenAI(
             azure_endpoint=str(self._url),
-            azure_deployment=self.azure_deployment_name,
+            azure_deployment=self._azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
+            azure_ad_token=self._azure_ad_token,
+            azure_ad_token_provider=self.azure_ad_token_provider,
             timeout=self._timeout,
             max_retries=3,
         )
 
         self._async_client = AsyncAzureOpenAI(
             azure_endpoint=str(self._url),
-            azure_deployment=self.azure_deployment_name,
+            azure_deployment=self._azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
+            azure_ad_token=self._azure_ad_token,
+            azure_ad_token_provider=self.azure_ad_token_provider,
             timeout=self._timeout,
             max_retries=3,
         )
@@ -193,7 +211,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.chat.completions.create(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 
@@ -209,7 +227,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.chat.completions.create(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 
@@ -232,7 +250,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.beta.chat.completions.parse(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 
@@ -255,7 +273,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.beta.chat.completions.parse(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 

{camel_ai-0.2.50 → camel_ai-0.2.51}/camel/models/ollama_model.py

@@ -16,10 +16,13 @@ import subprocess
 from typing import Any, Dict, Optional, Union
 
 from camel.configs import OLLAMA_API_PARAMS, OllamaConfig
+from camel.logger import get_logger
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import BaseTokenCounter
 
+logger = get_logger(__name__)
+
 
 class OllamaModel(OpenAICompatibleModel):
     r"""Ollama service interface.
@@ -60,20 +63,22 @@ class OllamaModel(OpenAICompatibleModel):
     ) -> None:
         if model_config_dict is None:
             model_config_dict = OllamaConfig().as_dict()
-        url = url or os.environ.get("OLLAMA_BASE_URL")
+        self._url = url or os.environ.get("OLLAMA_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        self._model_type = model_type
+
+        if not self._url:
+            self._start_server()
+
         super().__init__(
-            model_type=model_type,
+            model_type=self._model_type,
             model_config_dict=model_config_dict,
-            api_key=api_key,
-            url=url,
+            api_key="Not_Used",
+            url=self._url,
             token_counter=token_counter,
             timeout=timeout,
         )
 
-        if not self._url:
-            self._start_server()
-
     def _start_server(self) -> None:
         r"""Starts the Ollama server in a subprocess."""
         try:
@@ -83,12 +88,12 @@ class OllamaModel(OpenAICompatibleModel):
                 stderr=subprocess.PIPE,
             )
             self._url = "http://localhost:11434/v1"
-            print(
+            logger.info(
                 f"Ollama server started on {self._url} "
-                f"for {self.model_type} model."
+                f"for {self._model_type} model."
             )
         except Exception as e:
-            print(f"Failed to start Ollama server: {e}.")
+            logger.error(f"Failed to start Ollama server: {e}.")
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

{camel_ai-0.2.50 → camel_ai-0.2.51}/camel/models/vllm_model.py

@@ -16,10 +16,13 @@ import subprocess
 from typing import Any, Dict, Optional, Union
 
 from camel.configs import VLLM_API_PARAMS, VLLMConfig
+from camel.logger import get_logger
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import BaseTokenCounter
 
+logger = get_logger(__name__)
+
 
 # flake8: noqa: E501
 class VLLMModel(OpenAICompatibleModel):
@@ -62,18 +65,21 @@ class VLLMModel(OpenAICompatibleModel):
     ) -> None:
         if model_config_dict is None:
             model_config_dict = VLLMConfig().as_dict()
-        url = url or os.environ.get("VLLM_BASE_URL")
+        self._url = url or os.environ.get("VLLM_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        self._model_type = model_type
+
+        if not self._url:
+            self._start_server()
+
         super().__init__(
-            model_type=model_type,
+            model_type=self._model_type,
             model_config_dict=model_config_dict,
-            api_key=api_key,
-            url=url,
+            api_key="Not_Used",
+            url=self._url,
             token_counter=token_counter,
             timeout=timeout,
         )
-        if not self._url:
-            self._start_server()
 
     def _start_server(self) -> None:
         r"""Starts the vllm server in a subprocess."""
@@ -84,12 +90,12 @@ class VLLMModel(OpenAICompatibleModel):
                 stderr=subprocess.PIPE,
             )
             self._url = "http://localhost:8000/v1"
-            print(
+            logger.info(
                 f"vllm server started on {self._url} "
-                f"for {self.model_type} model."
+                f"for {self._model_type} model."
             )
         except Exception as e:
-            print(f"Failed to start vllm server: {e}.")
+            logger.error(f"Failed to start vllm server: {e}.")
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

{camel_ai-0.2.50 → camel_ai-0.2.51}/camel/types/enums.py

@@ -105,6 +105,7 @@ class ModelType(UnifiedModelType, Enum):
     TOGETHER_LLAMA_4_SCOUT = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
 
     # PPIO platform models support tool calling
+    PPIO_DEEPSEEK_PROVER_V2_671B = "deepseek/deepseek-prover-v2-671b"
     PPIO_DEEPSEEK_R1_TURBO = "deepseek/deepseek-r1-turbo"
     PPIO_DEEPSEEK_V3_TURBO = "deepseek/deepseek-v3-turbo"
     PPIO_DEEPSEEK_R1_COMMUNITY = "deepseek/deepseek-r1/community"
@@ -716,6 +717,7 @@ class ModelType(UnifiedModelType, Enum):
     @property
     def is_ppio(self) -> bool:
         return self in {
+            ModelType.PPIO_DEEPSEEK_PROVER_V2_671B,
             ModelType.PPIO_DEEPSEEK_R1_TURBO,
             ModelType.PPIO_DEEPSEEK_V3_TURBO,
             ModelType.PPIO_DEEPSEEK_R1_COMMUNITY,
@@ -928,6 +930,7 @@ class ModelType(UnifiedModelType, Enum):
         }:
             return 14_336
         elif self in {
+            ModelType.PPIO_DEEPSEEK_PROVER_V2_671B,
             ModelType.NOVITA_DOLPHIN_MIXTRAL_8X22B,
         }:
             return 16_000

{camel_ai-0.2.50 → camel_ai-0.2.51}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "camel-ai"
-version = "0.2.50"
+version = "0.2.51"
 description = "Communicative Agents for AI Society Study"
 authors = [{ name = "CAMEL-AI.org" }]
 requires-python = ">=3.10,<3.13"