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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.43
+Version: 0.2.44
 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.43 → camel_ai-0.2.44}/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.44'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.43 → camel_ai-0.2.44}/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.44}/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.44}/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.44}/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.44}/camel/toolkits/browser_toolkit.py

@@ -1175,6 +1175,8 @@ out the information you need. Sometimes they are extremely useful.
         message = BaseMessage.make_user_message(
             role_name='user', content=observe_prompt, image_list=[img]
         )
+        # Reset the history message of web_agent.
+        self.web_agent.reset()
         resp = self.web_agent.step(message)
 
         resp_content = resp.msgs[0].content
@@ -1404,6 +1406,8 @@ Your output should be in json format, including the following fields:
 - `if_need_replan`: bool, A boolean value indicating whether the task needs to be fundamentally replanned.
 - `replanned_schema`: str, The replanned schema for the task, which should not be changed too much compared with the original one. If the task does not need to be replanned, the value should be an empty string. 
 """
+        # Reset the history message of planning_agent.
+        self.planning_agent.reset()
         resp = self.planning_agent.step(replanning_prompt)
         resp_dict = _parse_json_output(resp.msgs[0].content)
 

{camel_ai-0.2.43 → camel_ai-0.2.44}/camel/types/enums.py

@@ -79,6 +79,10 @@ class ModelType(UnifiedModelType, Enum):
     TOGETHER_LLAMA_3_3_70B = "meta-llama/Llama-3.3-70B-Instruct-Turbo"
     TOGETHER_MIXTRAL_8_7B = "mistralai/Mixtral-8x7B-Instruct-v0.1"
     TOGETHER_MISTRAL_7B = "mistralai/Mistral-7B-Instruct-v0.1"
+    TOGETHER_LLAMA_4_MAVERICK = (
+        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8"
+    )
+    TOGETHER_LLAMA_4_SCOUT = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
 
     # PPIO platform models support tool calling
     PPIO_DEEPSEEK_R1_TURBO = "deepseek/deepseek-r1-turbo"
@@ -851,11 +855,13 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GEMINI_2_0_FLASH_LITE_PREVIEW,
             ModelType.GEMINI_2_0_PRO_EXP,  # Not given in doc, assume the same
             ModelType.GLM_4_LONG,
+            ModelType.TOGETHER_LLAMA_4_MAVERICK,
+            ModelType.OPENROUTER_LLAMA_4_MAVERICK,
         }:
             return 1_048_576
         elif self in {
             ModelType.QWEN_LONG,
-            ModelType.OPENROUTER_LLAMA_4_MAVERICK,
+            ModelType.TOGETHER_LLAMA_4_SCOUT,
         }:
             return 10_000_000
         else:

{camel_ai-0.2.43 → camel_ai-0.2.44}/pyproject.toml

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