camel-ai 0.2.34__py3-none-any.whl → 0.2.36__py3-none-any.whl

camel/utils/token_counting.py

@@ -90,6 +90,30 @@ class BaseTokenCounter(ABC):
         """
         pass
 
+    @abstractmethod
+    def encode(self, text: str) -> List[int]:
+        r"""Encode text into token IDs.
+
+        Args:
+            text (str): The text to encode.
+
+        Returns:
+            List[int]: List of token IDs.
+        """
+        pass
+
+    @abstractmethod
+    def decode(self, token_ids: List[int]) -> str:
+        r"""Decode token IDs back to text.
+
+        Args:
+            token_ids (List[int]): List of token IDs to decode.
+
+        Returns:
+            str: Decoded text.
+        """
+        pass
+
 
 class OpenAITokenCounter(BaseTokenCounter):
     def __init__(self, model: UnifiedModelType):
@@ -227,6 +251,28 @@ class OpenAITokenCounter(BaseTokenCounter):
         total = EXTRA_TOKENS + SQUARE_TOKENS * h * w
         return total
 
+    def encode(self, text: str) -> List[int]:
+        r"""Encode text into token IDs.
+
+        Args:
+            text (str): The text to encode.
+
+        Returns:
+            List[int]: List of token IDs.
+        """
+        return self.encoding.encode(text, disallowed_special=())
+
+    def decode(self, token_ids: List[int]) -> str:
+        r"""Decode token IDs back to text.
+
+        Args:
+            token_ids (List[int]): List of token IDs to decode.
+
+        Returns:
+            str: Decoded text.
+        """
+        return self.encoding.decode(token_ids)
+
 
 class AnthropicTokenCounter(BaseTokenCounter):
     @dependencies_required('anthropic')
@@ -266,6 +312,33 @@ class AnthropicTokenCounter(BaseTokenCounter):
             model=self.model,
         ).input_tokens
 
+    def encode(self, text: str) -> List[int]:
+        r"""Encode text into token IDs.
+
+        Args:
+            text (str): The text to encode.
+
+        Returns:
+            List[int]: List of token IDs.
+        """
+        raise NotImplementedError(
+            "The Anthropic API does not provide direct access to token IDs. "
+            "Use count_tokens_from_messages() for token counting instead."
+        )
+
+    def decode(self, token_ids: List[int]) -> str:
+        r"""Decode token IDs back to text.
+
+        Args:
+            token_ids (List[int]): List of token IDs to decode.
+
+        Returns:
+            str: Decoded text.
+        """
+        raise NotImplementedError(
+            "The Anthropic API does not provide functionality to decode token IDs."
+        )
+
 
 class LiteLLMTokenCounter(BaseTokenCounter):
     def __init__(self, model_type: UnifiedModelType):
@@ -319,6 +392,32 @@ class LiteLLMTokenCounter(BaseTokenCounter):
         """
         return self.completion_cost(completion_response=response)
 
+    def encode(self, text: str) -> List[int]:
+        r"""Encode text into token IDs.
+
+        Args:
+            text (str): The text to encode.
+
+        Returns:
+            List[int]: List of token IDs.
+        """
+        from litellm import encoding
+
+        return encoding.encode(text, disallowed_special=())
+
+    def decode(self, token_ids: List[int]) -> str:
+        r"""Decode token IDs back to text.
+
+        Args:
+            token_ids (List[int]): List of token IDs to decode.
+
+        Returns:
+            str: Decoded text.
+        """
+        from litellm import encoding
+
+        return encoding.decode(token_ids)
+
 
 class MistralTokenCounter(BaseTokenCounter):
     def __init__(self, model_type: ModelType):
@@ -390,3 +489,37 @@ class MistralTokenCounter(BaseTokenCounter):
         )
 
         return mistral_request
+
+    def encode(self, text: str) -> List[int]:
+        r"""Encode text into token IDs.
+
+        Args:
+            text (str): The text to encode.
+
+        Returns:
+            List[int]: List of token IDs.
+        """
+        # Use the Mistral tokenizer to encode the text
+        return self.tokenizer.encode_chat_completion(
+            ChatCompletionRequest(
+                model=self.model_type,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": text,
+                    }
+                ],
+            )
+        )
+
+    def decode(self, token_ids: List[int]) -> str:
+        r"""Decode token IDs back to text.
+
+        Args:
+            token_ids (List[int]): List of token IDs to decode.
+
+        Returns:
+            str: Decoded text.
+        """
+        # Use the Mistral tokenizer to decode the tokens
+        return self.tokenizer.decode(token_ids)

camel/verifiers/__init__.py

@@ -12,12 +12,11 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .base import BaseVerifier
-from .models import VerificationOutcome, VerifierInput
+from .models import VerificationOutcome
 from .python_verifier import PythonVerifier
 
 __all__ = [
     "BaseVerifier",
     "VerificationOutcome",
-    "VerifierInput",
     "PythonVerifier",
 ]

camel/verifiers/base.py

@@ -19,11 +19,7 @@ from typing import List, Optional
 from camel.logger import get_logger
 from camel.utils import BatchProcessor
 
-from .models import (
-    VerificationOutcome,
-    VerificationResult,
-    VerifierInput,
-)
+from .models import VerificationOutcome, VerificationResult
 
 logger = get_logger(__name__)
 
@@ -157,26 +153,33 @@ class BaseVerifier(ABC):
         r"""Implement verifier-specific cleanup logic."""
         pass
 
-    async def verify(self, result: VerifierInput) -> VerificationResult:
+    async def verify(
+        self, solution: str, ground_truth: Optional[str]
+    ) -> VerificationResult:
         r"""Perform verification with full error handling.
 
-        Verifies correctness, expected output, reasoning, and symbolic
-        consistency.
+        This method verifies the correctness of a generated solution by
+        comparing it against the provided ground truth. It handles
+        execution errors, timeouts, and retry attempts to ensure robust
+        validation.
 
         Args:
-            result: The response to verify.
+            solution (str): The generated response that needs verification.
+            ground_truth (Optional[str]): The expected correct answer to
+                compare against.
 
         Returns:
-            VerificationResult: Structured result containing:
-                - status: SUCCESS/FAILURE/ERROR/TIMEOUT
-                - result: Verification outcome description
-                - duration: Time taken for verification
-                - metadata: Additional details
-                - error_message: Error description if applicable
+            VerificationResult: A structured object containing:
+                - status (SUCCESS/FAILURE/ERROR/TIMEOUT)
+                - result (str): The verification outcome or processed output.
+                - duration (float): Time taken for verification.
+                - metadata (dict): Additional details such as retry attempts.
+                - error_message (Optional[str]): Error description,
+                if applicable.
 
         Raises:
             RuntimeError: If verification fails unexpectedly.
-            asyncio.TimeoutError: If verification times out.
+            asyncio.TimeoutError: If verification exceeds the time limit.
         """
         if not self._is_setup:
             logger.warning(
@@ -191,11 +194,13 @@ class BaseVerifier(ABC):
             try:
                 verification_result = (
                     await asyncio.wait_for(
-                        self._verify_implementation(result),
+                        self._verify_implementation(solution, ground_truth),
                         timeout=self._timeout,
                     )
                     if self._timeout
-                    else await self._verify_implementation(result)
+                    else await self._verify_implementation(
+                        solution, ground_truth
+                    )
                 )
 
                 verification_result.duration = time.time() - start_time
@@ -240,101 +245,133 @@ class BaseVerifier(ABC):
 
     @abstractmethod
     async def _verify_implementation(
-        self, result: VerifierInput
+        self, solution: str, ground_truth: Optional[str]
     ) -> VerificationResult:
-        r"""Implement the actual verification logic.
+        r"""Abstract method for verification logic.
+
+        Subclasses must implement this method to define how the solution
+        should be processed, evaluated, and compared to the ground truth.
 
         Args:
-            result: The response to verify.
+            solution (str): The generated response requiring verification.
+            ground_truth (Optional[str]): The expected reference output.
 
         Returns:
-            VerificationResult: Containing the verification outcome.
+            VerificationResult: Contains verification status and details.
 
         Raises:
-            NotImplementedError: Must be implemented in subclasses.
+            NotImplementedError: If the method is not implemented
+                in a subclass.
         """
         raise NotImplementedError(
             "Subclasses must implement _verify_implementation()"
         )
 
+    async def verify_batch(
+        self,
+        solutions: List[str],
+        ground_truths: List[Optional[str]],
+        raise_on_error: bool = False,
+    ) -> List[VerificationResult]:
+        r"""Verify multiple solutions in parallel with controlled concurrency.
 
-async def verify_batch(
-    self, results: List[VerifierInput], raise_on_error: bool = False
-) -> List[VerificationResult]:
-    r"""Verify multiple results in parallel with controlled concurrency.
+        This method verifies multiple generated solutions against their
+        respective ground truths using parallel execution. It handles
+        timeouts, execution errors, and batch processing optimizations.
 
-    Args:
-        results: List of responses to verify.
-        raise_on_error: Whether to raise an exception if any verification
-            fails. (default: :obj:`False`)
+        Args:
+            solutions (List[str]): A list of generated solutions to be
+                verified.
+            ground_truths (List[Optional[str]]): A list of expected outputs for
+                comparison. Each element corresponds to a solution.
+            raise_on_error (bool, optional): If True, raises an exception if
+                any verification fails. (default: :obj:`False`)
 
-    Returns:
-        List[VerificationResult]: One for each input response.
+        Returns:
+            List[VerificationResult]: A list of verification results, one per
+                input solution.
 
-    Raises:
-        RuntimeError: If any verification fails and raise_on_error is True.
-        asyncio.TimeoutError: If verifications time out and max retries
-            exceeded.
-    """
-    if not self._is_setup:
-        logger.warning(
-            f"{self.__class__.__name__} not set up, calling setup()"
-        )
-        await self.setup()
-
-    # Get current batch parameters from processor with defaults if not
-    #  present
-    max_workers = getattr(
-        self._batch_processor, 'max_workers', self._max_parallel or 1
-    )
-    batch_size = getattr(
-        self._batch_processor, 'batch_size', self._initial_batch_size or 10
-    )
-    semaphore = asyncio.Semaphore(max(1, max_workers))
-
-    async def _verify_with_semaphore(
-        response: VerifierInput,
-    ) -> VerificationResult:
-        start_time = time.time()
-        try:
-            async with semaphore:
-                verification_result = await self.verify(response)
-            processing_time = time.time() - start_time
-            success = verification_result.status == VerificationOutcome.SUCCESS
-            self._batch_processor.adjust_batch_size(success, processing_time)
-            return verification_result
-        except Exception as e:
-            processing_time = time.time() - start_time
-            self._batch_processor.adjust_batch_size(False, processing_time)
-            logger.error(f"Verification failed: {e!s}", exc_info=True)
-            return VerificationResult(
-                status=VerificationOutcome.ERROR,
-                result="",
-                error_message=str(e),
-                metadata={"error_type": type(e).__name__},
+        Raises:
+            RuntimeError: If any verification fails and `raise_on_error` is
+                True.
+            asyncio.TimeoutError: If verifications time out after maximum
+                retries.
+        """
+
+        if not self._is_setup:
+            logger.warning(
+                f"{self.__class__.__name__} not set up, calling setup()"
             )
+            await self.setup()
 
-    # Process in batches
-    all_results: List[VerificationResult] = []
-    for i in range(0, len(results), batch_size):
-        batch = results[i : i + batch_size]
-        verification_tasks = [
-            _verify_with_semaphore(result) for result in batch
-        ]
-        try:
-            batch_results = await asyncio.gather(*verification_tasks)
-            all_results.extend(batch_results)
-        except Exception as e:
-            logger.error(f"Batch verification failed: {e!s}", exc_info=True)
-            if raise_on_error:
-                raise RuntimeError(f"Batch verification failed: {e!s}") from e
+        # Retrieve batch processing settings
+        max_workers = getattr(
+            self._batch_processor, 'max_workers', self._max_parallel or 1
+        )
+        batch_size = getattr(
+            self._batch_processor, 'batch_size', self._initial_batch_size or 10
+        )
+        semaphore = asyncio.Semaphore(max(1, max_workers))
 
-    if raise_on_error and any(
-        r.status in {VerificationOutcome.ERROR, VerificationOutcome.TIMEOUT}
-        for r in all_results
-    ):
-        error_msg = "One or more verifications failed"
-        logger.error(error_msg)
-        raise RuntimeError(error_msg)
+        async def _verify_with_semaphore(
+            solution: str, ground_truth: Optional[str]
+        ) -> VerificationResult:
+            start_time = time.time()
+            try:
+                async with semaphore:
+                    verification_result = await self.verify(
+                        solution, ground_truth
+                    )
+                processing_time = time.time() - start_time
+                success = (
+                    verification_result.status == VerificationOutcome.SUCCESS
+                )
+                self._batch_processor.adjust_batch_size(
+                    success, processing_time
+                )
+                return verification_result
+            except Exception as e:
+                processing_time = time.time() - start_time
+                self._batch_processor.adjust_batch_size(False, processing_time)
+                logger.error(f"Verification failed: {e!s}", exc_info=True)
+                return VerificationResult(
+                    status=VerificationOutcome.ERROR,
+                    result="",
+                    error_message=str(e),
+                    metadata={"error_type": type(e).__name__},
+                )
+
+        # Process in batches
+        all_results: List[VerificationResult] = []
+        for i in range(0, len(solutions), batch_size):
+            batch_solutions = solutions[i : i + batch_size]
+            batch_ground_truths = ground_truths[i : i + batch_size]
 
-    return all_results
+            verification_tasks = [
+                _verify_with_semaphore(solution, ground_truth)
+                for solution, ground_truth in zip(
+                    batch_solutions, batch_ground_truths
+                )
+            ]
+            try:
+                batch_results = await asyncio.gather(*verification_tasks)
+                all_results.extend(batch_results)
+            except Exception as e:
+                logger.error(
+                    f"Batch verification failed: {e!s}", exc_info=True
+                )
+                if raise_on_error:
+                    raise RuntimeError(
+                        f"Batch verification failed: {e!s}"
+                    ) from e
+
+        if raise_on_error and any(
+            r.status
+            in {VerificationOutcome.ERROR, VerificationOutcome.TIMEOUT}
+            for r in all_results
+        ):
+            error_msg = "One or more verifications failed"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        return all_results

camel/verifiers/models.py

@@ -18,18 +18,6 @@ from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field
 
 
-class VerifierInput(BaseModel):
-    r"""Structured input to the verifier"""
-
-    llm_response: str = Field(
-        description="The LLM response to be verified."
-        "Needs to be in a format that the verifier can handle."
-    )
-    ground_truth: Optional[str] = Field(
-        None, description="The ground truth data, if available."
-    )
-
-
 class VerificationOutcome(Enum):
     r"""Enum representing the status of a verification."""
 

camel/verifiers/python_verifier.py

@@ -20,10 +20,11 @@ import tempfile
 import venv
 from typing import List, Optional
 
+from camel.extractors import BaseExtractor
 from camel.logger import get_logger
 from camel.verifiers import BaseVerifier
 
-from .models import VerificationOutcome, VerificationResult, VerifierInput
+from .models import VerificationOutcome, VerificationResult
 
 logger = get_logger(__name__)
 
@@ -47,6 +48,7 @@ class PythonVerifier(BaseVerifier):
         self,
         timeout: Optional[float] = 30.0,
         required_packages: Optional[List[str]] = None,
+        extractor: Optional[BaseExtractor] = None,
     ):
         r"""Initializes the PythonVerifier.
 
@@ -102,24 +104,33 @@ class PythonVerifier(BaseVerifier):
             self.venv_path = None
 
     async def _verify_implementation(
-        self, result: VerifierInput
+        self, solution: str, ground_truth: Optional[str]
     ) -> VerificationResult:
-        r"""Executes the LLM-generated response in a Python virtual
-        environment.
+        r"""Executes and verifies the LLM-generated Python solution in an
+        isolated virtual environment.
+
+        This method runs the given Python solution inside a controlled virtual
+        environment, captures its execution output, and optionally compares it
+        against a provided ground truth. Handles timeouts and execution errors.
 
         Args:
-            result (VerifierInput): Contains the LLM-generated Python code to
-                execute and optional ground truth for comparison.
+            solution (str): The Python code to execute and verify.
+            ground_truth (Optional[str]): The expected output for comparison.
+                If None, verification is based only on execution success.
 
         Returns:
-            VerificationResult: Contains verification status (SUCCESS/FAILURE/
-                ERROR), execution output, error messages if any, and execution
-                duration.
+            VerificationResult: A structured object containing:
+                - status (VerificationOutcome): SUCCESS, FAILURE, ERROR,
+                or TIMEOUT.
+                - result (str): The execution output of the solution.
+                - error_message (Optional[str]): Captured error message,
+                if any.
+                - duration (float, optional): Execution time (set externally).
 
         Raises:
             asyncio.TimeoutError: If execution exceeds the configured timeout.
-            Exception: Any unexpected errors during execution are caught and
-                converted to an ERROR verification result.
+            Exception: Any unexpected errors are caught and converted to an
+                ERROR verification result.
         """
         if not self.venv_path:
             return VerificationResult(
@@ -128,7 +139,7 @@ class PythonVerifier(BaseVerifier):
                 error_message="Virtual environment is not set up.",
             )
 
-        script = result.llm_response.strip()
+        script = solution.strip()
         venv_python = os.path.join(self.venv_path, self.bin_dir, "python")
 
         if not os.path.exists(venv_python):
@@ -156,11 +167,11 @@ class PythonVerifier(BaseVerifier):
 
             if process.returncode == 0:
                 # If ground truth is provided, compare it with the result
-                if result.ground_truth is not None:
+                if ground_truth is not None:
                     # Normalize both strings by removing extra whitespace
                     normalized_output = ' '.join(output_result.strip().split())
                     normalized_truth = ' '.join(
-                        str(result.ground_truth).strip().split()
+                        str(ground_truth).strip().split()
                     )
 
                     if normalized_output == normalized_truth:

{camel_ai-0.2.34.dist-info → camel_ai-0.2.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.34
+Version: 0.2.36
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -58,6 +58,7 @@ Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'all'
 Requires-Dist: linkup-sdk<0.3,>=0.2.1; extra == 'all'
 Requires-Dist: litellm<2,>=1.38.1; extra == 'all'
 Requires-Dist: mcp>=1.3.0; extra == 'all'
+Requires-Dist: mem0ai>=0.1.67; extra == 'all'
 Requires-Dist: mistralai<2,>=1.1.0; extra == 'all'
 Requires-Dist: mock<6,>=5; extra == 'all'
 Requires-Dist: mypy<2,>=1.5.1; extra == 'all'
@@ -225,6 +226,7 @@ Provides-Extra: storage
 Requires-Dist: azure-storage-blob<13,>=12.21.0; extra == 'storage'
 Requires-Dist: botocore<2,>=1.35.3; extra == 'storage'
 Requires-Dist: google-cloud-storage<3,>=2.18.0; extra == 'storage'
+Requires-Dist: mem0ai>=0.1.73; extra == 'storage'
 Requires-Dist: nebula3-python==3.8.2; extra == 'storage'
 Requires-Dist: neo4j<6,>=5.18.0; extra == 'storage'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'storage'