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

camel/toolkits/thinking_toolkit.py

@@ -0,0 +1,230 @@
+# ========= 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."""
+
+    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.plans: List[str] = []
+        self.hypotheses: List[str] = []
+        self.thoughts: List[str] = []
+        self.contemplations: List[str] = []
+        self.critiques: List[str] = []
+        self.syntheses: List[str] = []
+        self.reflections: List[str] = []
+
+    def plan(self, plan: str) -> str:
+        r"""Use the tool to create a plan or strategy.
+        This tool is for outlining the approach or steps to be taken before
+        starting the actual thinking process.
+
+        Args:
+            plan (str): A forward-looking plan or strategy.
+
+        Returns:
+            str: The recorded plan.
+        """
+        try:
+            logger.debug(f"Plan: {plan}")
+            self.plans.append(plan)
+            return f"Plan: {plan}"
+
+        except Exception as e:
+            error_msg = f"Error recording plan: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def hypothesize(self, hypothesis: str) -> str:
+        r"""Use the tool to form a hypothesis or make a prediction.
+        This tool is for making educated guesses or predictions based on
+        the plan, before detailed thinking.
+
+        Args:
+            hypothesis (str): A hypothesis or prediction to test.
+
+        Returns:
+            str: The recorded hypothesis.
+        """
+        try:
+            logger.debug(f"Hypothesis: {hypothesis}")
+            if not self.plans:
+                return "Consider creating a plan before forming hypotheses."
+            self.hypotheses.append(hypothesis)
+            return f"Hypothesis: {hypothesis}"
+
+        except Exception as e:
+            error_msg = f"Error recording hypothesis: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    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 for initial thoughts and
+        observations during the execution of the plan.
+
+        Args:
+            thought (str): A thought to think about.
+
+        Returns:
+            str: The recorded thought.
+        """
+        try:
+            logger.debug(f"Thought: {thought}")
+            if not self.plans:
+                return (
+                    "Consider creating a plan before thinking "
+                    "through the process."
+                )
+            self.thoughts.append(thought)
+            return f"Thought: {thought}"
+
+        except Exception as e:
+            error_msg = f"Error recording thought: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def contemplate(self, contemplation: str) -> str:
+        r"""Use the tool to deeply contemplate an idea or concept.
+        This tool is for deeper, more thorough exploration of thoughts,
+        considering multiple perspectives and implications. It's more
+        comprehensive than basic thinking but more focused than reflection.
+
+        Args:
+            contemplation (str): A deeper exploration of thoughts or concepts.
+
+        Returns:
+            str: The recorded contemplation.
+        """
+        try:
+            logger.debug(f"Contemplation: {contemplation}")
+            if not self.thoughts:
+                return (
+                    "Consider thinking about the topic before "
+                    "deep contemplation."
+                )
+            self.contemplations.append(contemplation)
+            return f"Contemplation: {contemplation}"
+
+        except Exception as e:
+            error_msg = f"Error recording contemplation: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def critique(self, critique: str) -> str:
+        r"""Use the tool to critically evaluate current thoughts.
+        This tool is for identifying potential flaws, biases, or
+        weaknesses in the current thinking process.
+
+        Args:
+            critique (str): A critical evaluation of current thoughts.
+
+        Returns:
+            str: The recorded critique.
+        """
+        try:
+            logger.debug(f"Critique: {critique}")
+            if not self.contemplations:
+                return "Consider contemplating deeply before critiquing."
+            self.critiques.append(critique)
+            return f"Critique: {critique}"
+
+        except Exception as e:
+            error_msg = f"Error recording critique: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def synthesize(self, synthesis: str) -> str:
+        r"""Use the tool to combine and integrate various thoughts.
+        This tool is for bringing together different thoughts, contemplations,
+        and critiques into a coherent understanding.
+
+        Args:
+            synthesis (str): An integration of multiple thoughts and insights.
+
+        Returns:
+            str: The recorded synthesis.
+        """
+        try:
+            logger.debug(f"Synthesis: {synthesis}")
+            if not self.critiques:
+                return "Consider critiquing thoughts before synthesizing."
+            self.syntheses.append(synthesis)
+            return f"Synthesis: {synthesis}"
+
+        except Exception as e:
+            error_msg = f"Error recording synthesis: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def reflect(self, reflection: str) -> str:
+        r"""Use the tool to reflect on the entire process.
+        This tool is for final evaluation of the entire thinking process,
+        including plans, hypotheses, thoughts, contemplations, critiques,
+        and syntheses.
+
+        Args:
+            reflection (str): A comprehensive reflection on the process.
+
+        Returns:
+            str: The recorded reflection.
+        """
+        try:
+            logger.debug(f"Reflection: {reflection}")
+            if not self.syntheses:
+                return (
+                    "Consider synthesizing insights before final reflection."
+                )
+            self.reflections.append(reflection)
+            return f"Reflection: {reflection}"
+
+        except Exception as e:
+            error_msg = f"Error recording reflection: {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.plan),
+            FunctionTool(self.hypothesize),
+            FunctionTool(self.think),
+            FunctionTool(self.contemplate),
+            FunctionTool(self.critique),
+            FunctionTool(self.synthesize),
+            FunctionTool(self.reflect),
+        ]

camel/types/enums.py

@@ -123,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"
@@ -420,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,
@@ -724,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,
@@ -879,6 +882,7 @@ class OpenAIVisionDetailType(Enum):
 class StorageType(Enum):
     MILVUS = "milvus"
     QDRANT = "qdrant"
+    TIDB = "tidb"
 
 
 class OpenAPIName(Enum):

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/base.py

@@ -16,6 +16,7 @@ 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
 
@@ -44,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,
@@ -72,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
@@ -82,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:
@@ -97,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()
@@ -106,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:
@@ -118,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
 
@@ -136,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")
@@ -191,15 +200,28 @@ 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(solution, ground_truth),
+                        self._verify_implementation(
+                            verifiable_solution, ground_truth
+                        ),
                         timeout=self._timeout,
                     )
                     if self._timeout
                     else await self._verify_implementation(
-                        solution, ground_truth
+                        verifiable_solution, ground_truth
                     )
                 )
 
@@ -267,6 +289,7 @@ class BaseVerifier(ABC):
             "Subclasses must implement _verify_implementation()"
         )
 
+    # TODO: check again
     async def verify_batch(
         self,
         solutions: List[str],