camel-ai 0.2.35__py3-none-any.whl → 0.2.37__py3-none-any.whl

camel/toolkits/thinking_toolkit.py

@@ -0,0 +1,74 @@
+# ========= 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. =========
+
+from typing import List, Optional
+
+from camel.logger import get_logger
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+
+logger = get_logger(__name__)
+
+
+class ThinkingToolkit(BaseToolkit):
+    r"""A toolkit for recording thoughts during reasoning processes.
+
+    Attributes:
+        thoughts (List[str]): A list to store the recorded thoughts.
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initialize the ThinkingToolkit.
+
+        Args:
+            timeout (Optional[float]): The timeout for the toolkit.
+                (default: :obj: `None`)
+        """
+        super().__init__(timeout=timeout)
+        self.thoughts: List[str] = []
+
+    def think(self, thought: str) -> str:
+        r"""Use the tool to think about something.
+        It will not obtain new information or change the database, but just
+        append the thought to the log. Use it when complex reasoning or some
+        cache memory is needed.
+
+        Args:
+            thought (str): A thought to think about.
+
+        Returns:
+            str: The full log of thoughts including the new thought.
+        """
+        try:
+            logger.debug(f"Thought: {thought}")
+            self.thoughts.append(thought)
+
+            thoughts = "\n".join([f"- {t}" for t in self.thoughts])
+            return f"Thoughts:\n{thoughts}"
+
+        except Exception as e:
+            error_msg = f"Error recording thought: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Get all tools in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of tools.
+        """
+        return [FunctionTool(self.think)]

camel/types/enums.py

@@ -63,6 +63,11 @@ class ModelType(UnifiedModelType, Enum):
     GROQ_MIXTRAL_8_7B = "mixtral-8x7b-32768"
     GROQ_GEMMA_2_9B_IT = "gemma2-9b-it"
 
+    # OpenRouter models
+    OPENROUTER_LLAMA_3_1_405B = "meta-llama/llama-3.3-405b-instruct"
+    OPENROUTER_LLAMA_3_1_70B = "meta-llama/llama-3.3-70b-instruct"
+    OPENROUTER_OLYMPICODER_7B = "open-r1/olympiccoder-7b:free"
+
     # TogetherAI platform models support tool calling
     TOGETHER_LLAMA_3_1_8B = "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"
     TOGETHER_LLAMA_3_1_70B = "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"
@@ -118,6 +123,7 @@ class ModelType(UnifiedModelType, Enum):
     NVIDIA_LLAMA3_3_70B_INSTRUCT = "meta/llama-3.3-70b-instruct"
 
     # Gemini models
+    GEMINI_2_5_PRO_EXP = "gemini-2.5-pro-exp-03-25"
     GEMINI_2_0_FLASH = "gemini-2.0-flash-exp"
     GEMINI_2_0_FLASH_THINKING = "gemini-2.0-flash-thinking-exp"
     GEMINI_2_0_PRO_EXP = "gemini-2.0-pro-exp-02-05"
@@ -253,6 +259,7 @@ class ModelType(UnifiedModelType, Enum):
                 self.is_together,
                 self.is_sambanova,
                 self.is_groq,
+                self.is_openrouter,
                 self.is_sglang,
                 self.is_moonshot,
                 self.is_siliconflow,
@@ -342,6 +349,15 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GROQ_GEMMA_2_9B_IT,
         }
 
+    @property
+    def is_openrouter(self) -> bool:
+        r"""Returns whether this type of models is served by OpenRouter."""
+        return self in {
+            ModelType.OPENROUTER_LLAMA_3_1_405B,
+            ModelType.OPENROUTER_LLAMA_3_1_70B,
+            ModelType.OPENROUTER_OLYMPICODER_7B,
+        }
+
     @property
     def is_together(self) -> bool:
         r"""Returns whether this type of models is served by Together AI."""
@@ -405,6 +421,7 @@ class ModelType(UnifiedModelType, Enum):
             bool: Whether this type of models is gemini.
         """
         return self in {
+            ModelType.GEMINI_2_5_PRO_EXP,
             ModelType.GEMINI_2_0_FLASH,
             ModelType.GEMINI_1_5_FLASH,
             ModelType.GEMINI_1_5_PRO,
@@ -580,6 +597,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MOONSHOT_V1_8K,
             ModelType.GLM_4V_FLASH,
             ModelType.GLM_4_AIRX,
+            ModelType.OPENROUTER_OLYMPICODER_7B,
         }:
             return 8_192
         elif self in {
@@ -686,6 +704,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.SGLANG_QWEN_2_5_7B,
             ModelType.SGLANG_QWEN_2_5_32B,
             ModelType.SGLANG_QWEN_2_5_72B,
+            ModelType.OPENROUTER_LLAMA_3_1_70B,
+            ModelType.OPENROUTER_LLAMA_3_1_405B,
         }:
             return 131_072
         elif self in {
@@ -706,6 +726,7 @@ class ModelType(UnifiedModelType, Enum):
         }:
             return 256_000
         elif self in {
+            ModelType.GEMINI_2_5_PRO_EXP,
             ModelType.GEMINI_2_0_FLASH,
             ModelType.GEMINI_1_5_FLASH,
             ModelType.GEMINI_1_5_PRO,
@@ -881,6 +902,7 @@ class ModelPlatformType(Enum):
     AZURE = "azure"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
+    OPENROUTER = "openrouter"
     OLLAMA = "ollama"
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
@@ -931,6 +953,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is groq."""
         return self is ModelPlatformType.GROQ
 
+    @property
+    def is_openrouter(self) -> bool:
+        r"""Returns whether this platform is openrouter."""
+        return self is ModelPlatformType.OPENROUTER
+
     @property
     def is_ollama(self) -> bool:
         r"""Returns whether this platform is ollama."""

camel/types/unified_model_type.py

@@ -78,6 +78,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a Groq served model."""
         return True
 
+    @property
+    def is_openrouter(self) -> bool:
+        r"""Returns whether the model is a OpenRouter served model."""
+        return True
+
     @property
     def is_zhipuai(self) -> bool:
         r"""Returns whether the model is a Zhipuai model."""

camel/utils/chunker/code_chunker.py

@@ -16,9 +16,7 @@ from typing import List, Optional
 
 from unstructured.documents.elements import Element, ElementMetadata
 
-from camel.messages import OpenAIUserMessage
-from camel.types import ModelType
-from camel.utils import BaseTokenCounter, OpenAITokenCounter
+from camel.utils import get_model_encoding
 
 from .base import BaseChunker
 
@@ -38,20 +36,18 @@ class CodeChunker(BaseChunker):
             token counting, if `None`, OpenAITokenCounter will be used.
             (default: :obj:`None`)
         remove_image: (bool, optional): If the chunker should skip the images.
+        model_name (str, optional): The tokenizer model name used
+            for token counting. (default: :obj:`"cl100k_base"`)
     """
 
     def __init__(
         self,
         chunk_size: int = 8192,
-        token_counter: Optional[BaseTokenCounter] = None,
+        model_name: str = "cl100k_base",
         remove_image: Optional[bool] = True,
     ):
         self.chunk_size = chunk_size
-        self.token_counter = (
-            token_counter
-            if token_counter
-            else OpenAITokenCounter(model=ModelType.GPT_4O_MINI)
-        )
+        self.tokenizer = get_model_encoding(model_name)
         self.remove_image = remove_image
         self.struct_pattern = re.compile(
             r'^\s*(?:(def|class|function)\s+\w+|'
@@ -72,9 +68,7 @@ class CodeChunker(BaseChunker):
         Returns:
             int: The number of tokens in the input text.
         """
-        return self.token_counter.count_tokens_from_messages(
-            [OpenAIUserMessage(role="user", name="user", content=text)]
-        )
+        return len(self.tokenizer.encode(text, disallowed_special=()))
 
     def _split_oversized(self, line: str) -> List[str]:
         r"""Splits an oversized line into multiple chunks based on token limits
@@ -86,7 +80,7 @@ class CodeChunker(BaseChunker):
             List[str]: A list of smaller chunks after splitting the
                 oversized line.
         """
-        tokens = self.token_counter.encode(line)
+        tokens = self.tokenizer.encode(line, disallowed_special=())
         chunks = []
         buffer = []
         current_count = 0
@@ -96,12 +90,12 @@ class CodeChunker(BaseChunker):
             current_count += 1
 
             if current_count >= self.chunk_size:
-                chunks.append(self.token_counter.decode(buffer).strip())
+                chunks.append(self.tokenizer.decode(buffer).strip())
                 buffer = []
                 current_count = 0
 
         if buffer:
-            chunks.append(self.token_counter.decode(buffer))
+            chunks.append(self.tokenizer.decode(buffer))
         return chunks
 
     def chunk(self, content: List[str]) -> List[Element]:

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

@@ -16,14 +16,11 @@ import time
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
+from camel.extractors.base import BaseExtractor
 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__)
 
@@ -48,6 +45,7 @@ class BaseVerifier(ABC):
 
     def __init__(
         self,
+        extractor: Optional[BaseExtractor] = None,
         max_parallel: Optional[int] = None,
         timeout: Optional[float] = None,
         max_retries: int = 3,
@@ -76,6 +74,9 @@ class BaseVerifier(ABC):
                 down. (default: :obj:`85.0`)
             **kwargs: Additional verifier parameters.
         """
+
+        self.extractor = extractor
+
         self._is_setup: bool = False
         self._max_parallel: Optional[int] = max_parallel
         self._timeout: Optional[float] = timeout
@@ -86,7 +87,7 @@ class BaseVerifier(ABC):
         self._memory_threshold: float = memory_threshold
         self._batch_processor: BatchProcessor = BatchProcessor()
 
-    async def setup(self) -> None:
+    async def setup(self, **kwargs) -> None:
         r"""Set up the verifier with necessary resources.
 
         Initializes:
@@ -101,6 +102,8 @@ class BaseVerifier(ABC):
             return
 
         try:
+            if self.extractor:
+                await self.extractor.setup()
             batch_size = max(1, self._initial_batch_size or 10)
             max_parallel = max(1, self._max_parallel or 1)
             self._batch_processor = BatchProcessor()
@@ -110,7 +113,7 @@ class BaseVerifier(ABC):
                 f"batch_size={batch_size}, max_parallel={max_parallel}"
             )
 
-            await self._setup()
+            await self._setup(**kwargs)
             self._is_setup = True
 
         except Exception as e:
@@ -122,7 +125,7 @@ class BaseVerifier(ABC):
             raise RuntimeError(error_msg) from e
 
     @abstractmethod
-    async def _setup(self) -> None:
+    async def _setup(self, **kwargs) -> None:
         r"""Implement verifier-specific setup logic."""
         pass
 
@@ -140,6 +143,8 @@ class BaseVerifier(ABC):
             return
 
         try:
+            if self.extractor:
+                await self.extractor.cleanup()
             self._batch_processor = BatchProcessor()
             await self._cleanup()
             logger.info(f"{self.__class__.__name__} cleaned up successfully")
@@ -157,26 +162,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(
@@ -188,14 +200,29 @@ class BaseVerifier(ABC):
         start_time = time.time()
 
         while attempt < self._max_retries:
+            # Extract verifiable part of the proposed solution,
+            # if verifier has been initialized with extractor.
+            verifiable_solution = (
+                await self.extractor.extract(solution)
+                if self.extractor
+                else solution
+            )
+
+            if not verifiable_solution:
+                continue
+
             try:
                 verification_result = (
                     await asyncio.wait_for(
-                        self._verify_implementation(result),
+                        self._verify_implementation(
+                            verifiable_solution, ground_truth
+                        ),
                         timeout=self._timeout,
                     )
                     if self._timeout
-                    else await self._verify_implementation(result)
+                    else await self._verify_implementation(
+                        verifiable_solution, ground_truth
+                    )
                 )
 
                 verification_result.duration = time.time() - start_time
@@ -240,101 +267,134 @@ 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()"
         )
 
+    # TODO: check again
+    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__},
+                )
 
-    return all_results
+        # 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]
+
+            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."""