camel-ai 0.2.65__py3-none-any.whl → 0.2.82__py3-none-any.whl

camel/models/deepseek_model.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
 from typing import Any, Dict, List, Optional, Type, Union
@@ -18,7 +18,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 from openai import AsyncStream, Stream
 from pydantic import BaseModel
 
-from camel.configs import DEEPSEEK_API_PARAMS, DeepSeekConfig
+from camel.configs import DeepSeekConfig
 from camel.logger import get_logger
 from camel.messages import OpenAIMessage
 from camel.models._utils import try_modify_message_with_format
@@ -40,6 +40,11 @@ if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
         from langfuse.decorators import observe
     except ImportError:
         from camel.utils import observe
+elif os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        from traceroot import trace as observe  # type: ignore[import]
+    except ImportError:
+        from camel.utils import observe
 else:
     from camel.utils import observe
 
@@ -78,6 +83,10 @@ class DeepSeekModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
 
     References:
         https://api-docs.deepseek.com/
@@ -96,6 +105,8 @@ class DeepSeekModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = DeepSeekConfig().as_dict()
@@ -112,6 +123,8 @@ class DeepSeekModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _prepare_request(
@@ -152,44 +165,6 @@ class DeepSeekModel(OpenAICompatibleModel):
 
         return request_config
 
-    def _post_handle_response(
-        self, response: ChatCompletion
-    ) -> ChatCompletion:
-        r"""Handle reasoning content with <think> tags at the beginning."""
-        if (
-            self.model_type in [ModelType.DEEPSEEK_REASONER]
-            and os.environ.get("GET_REASONING_CONTENT", "false").lower()
-            == "true"
-        ):
-            reasoning_content = response.choices[0].message.reasoning_content  # type: ignore[attr-defined]
-            combined_content = (  # type: ignore[operator]
-                f"<think>\n{reasoning_content}\n</think>\n"
-                if reasoning_content
-                else ""
-            ) + response.choices[0].message.content
-
-            response = ChatCompletion.construct(
-                id=response.id,
-                choices=[
-                    dict(
-                        index=response.choices[0].index,
-                        message={
-                            "role": response.choices[0].message.role,
-                            "content": combined_content,
-                            "tool_calls": None,
-                        },
-                        finish_reason=response.choices[0].finish_reason
-                        if response.choices[0].finish_reason
-                        else None,
-                    )
-                ],
-                created=response.created,
-                model=response.model,
-                object="chat.completion",
-                usage=response.usage,
-            )
-        return response
-
     @observe()
     def _run(
         self,
@@ -231,7 +206,7 @@ class DeepSeekModel(OpenAICompatibleModel):
             **request_config,
         )
 
-        return self._post_handle_response(response)
+        return response
 
     @observe()
     async def _arun(
@@ -273,19 +248,4 @@ class DeepSeekModel(OpenAICompatibleModel):
             **request_config,
         )
 
-        return self._post_handle_response(response)
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to DeepSeek API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to DeepSeek API.
-        """
-        for param in self.model_config_dict:
-            if param not in DEEPSEEK_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into DeepSeek model backend."
-                )
+        return response

camel/models/fish_audio_model.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
 from typing import Any, Optional
@@ -44,6 +44,12 @@ class FishAudioModel(BaseAudioModel):
         self._url = url or os.environ.get(
             "FISHAUDIO_API_BASE_URL", "https://api.fish.audio"
         )
+        if self._api_key is None:
+            raise ValueError(
+                "API key is required for FishAudio. Please provide it via "
+                "the 'api_key' parameter or set the 'FISHAUDIO_API_KEY' "
+                "environment variable."
+            )
         self.session = Session(apikey=self._api_key, base_url=self._url)
 
     def text_to_speech(

camel/models/gemini_model.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,14 +10,23 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import (
+    Any,
+    AsyncGenerator,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Type,
+    Union,
+)
 
 from openai import AsyncStream, Stream
 from pydantic import BaseModel
 
-from camel.configs import Gemini_API_PARAMS, GeminiConfig
+from camel.configs import GeminiConfig
 from camel.messages import OpenAIMessage
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import (
@@ -37,6 +46,11 @@ if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
         from langfuse.decorators import observe
     except ImportError:
         from camel.utils import observe
+elif os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        from traceroot import trace as observe  # type: ignore[import]
+    except ImportError:
+        from camel.utils import observe
 else:
     from camel.utils import observe
 
@@ -64,6 +78,10 @@ class GeminiModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -79,6 +97,8 @@ class GeminiModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = GeminiConfig().as_dict()
@@ -95,20 +115,344 @@ class GeminiModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _process_messages(self, messages) -> List[OpenAIMessage]:
         r"""Process the messages for Gemini API to ensure no empty content,
-        which is not accepted by Gemini.
+        which is not accepted by Gemini. Also preserves thought signatures
+        required for Gemini 3 Pro function calling.
+
+        This method also merges consecutive assistant messages with single
+        tool calls into a single assistant message with multiple tool calls,
+        as required by Gemini's OpenAI-compatible API for parallel function
+        calling.
         """
-        processed_messages = []
-        for msg in messages:
-            msg_copy = msg.copy()
+        import copy
+
+        processed_messages: List[OpenAIMessage] = []
+        i = 0
+        n = len(messages)
+
+        while i < n:
+            msg = messages[i]
+
+            # Check if this is an assistant message with a single tool_call
+            # that might need to be merged with subsequent ones
+            if (
+                msg.get('role') == 'assistant'
+                and 'tool_calls' in msg
+                and isinstance(msg['tool_calls'], list)
+                and len(msg['tool_calls']) == 1
+            ):
+                # Look ahead to check if there are more assistant messages
+                # with single tool calls (interleaved with their tool results)
+                j = i + 1
+                has_more_tool_calls = False
+
+                # Collect tool_call_ids we've seen so far
+                first_tool_call_id = msg['tool_calls'][0].get('id')
+                seen_tool_call_ids = (
+                    {first_tool_call_id} if first_tool_call_id else set()
+                )
+
+                # Scan ahead to find pattern: tool_result, assistant,
+                # tool_result, ...
+                while j < n:
+                    next_msg = messages[j]
+                    next_role = next_msg.get('role')
+
+                    if next_role == 'tool':
+                        # Tool result - check if it belongs to our batch
+                        if next_msg.get('tool_call_id') in seen_tool_call_ids:
+                            j += 1
+                            continue
+                        else:
+                            # Tool result for unknown call, stop scanning
+                            break
+                    elif (
+                        next_role == 'assistant'
+                        and 'tool_calls' in next_msg
+                        and isinstance(next_msg['tool_calls'], list)
+                        and len(next_msg['tool_calls']) == 1
+                    ):
+                        # Another single tool call - mark for merging
+                        has_more_tool_calls = True
+                        tc_id = next_msg['tool_calls'][0].get('id')
+                        if tc_id:
+                            seen_tool_call_ids.add(tc_id)
+                        j += 1
+                        continue
+                    else:
+                        # Something else, stop scanning
+                        break
+
+                if has_more_tool_calls:
+                    # Need to merge: collect all tool calls and results
+                    merged_tool_calls = []
+                    tool_results = []
+                    is_first = True
+
+                    for k in range(i, j):
+                        m = messages[k]
+                        if m.get('role') == 'assistant' and 'tool_calls' in m:
+                            tc = m['tool_calls'][0]
+                            if is_first:
+                                # Keep extra_content only on first tool call
+                                merged_tool_calls.append(copy.deepcopy(tc))
+                                is_first = False
+                            else:
+                                # Remove extra_content from subsequent tool
+                                # calls
+                                tc_copy = {
+                                    k: v
+                                    for k, v in tc.items()
+                                    if k != 'extra_content'
+                                }
+                                merged_tool_calls.append(tc_copy)
+                        elif m.get('role') == 'tool':
+                            tool_results.append(copy.deepcopy(m))
+
+                    # Build merged assistant message
+                    merged_msg = copy.deepcopy(msg)
+                    merged_msg['tool_calls'] = merged_tool_calls
+                    if 'content' in merged_msg and merged_msg['content'] == '':
+                        merged_msg['content'] = 'null'
+
+                    processed_messages.append(merged_msg)
+                    processed_messages.extend(tool_results)
+                    i = j
+                    continue
+
+            # Regular message processing (no merging needed)
+            msg_copy = copy.deepcopy(msg)
             if 'content' in msg_copy and msg_copy['content'] == '':
                 msg_copy['content'] = 'null'
             processed_messages.append(msg_copy)
+            i += 1
+
         return processed_messages
 
+    def _preserve_thought_signatures(
+        self,
+        response: Union[
+            ChatCompletion,
+            Stream[ChatCompletionChunk],
+            AsyncStream[ChatCompletionChunk],
+        ],
+    ) -> Union[
+        ChatCompletion,
+        Generator[ChatCompletionChunk, None, None],
+        AsyncGenerator[ChatCompletionChunk, None],
+    ]:
+        r"""Preserve thought signatures from Gemini responses for future
+        requests.
+
+        According to the Gemini documentation, when a response contains tool
+        calls with thought signatures, these signatures must be preserved
+        exactly as received when the response is added to conversation history
+        for subsequent requests.
+
+        Args:
+            response: The response from Gemini API
+
+        Returns:
+            The response with thought signatures properly preserved.
+            For streaming responses, returns generators that preserve
+            signatures.
+        """
+        # For streaming responses, we need to wrap the stream to preserve
+        # thought signatures in tool calls as they come in
+        if isinstance(response, Stream):
+            return self._wrap_stream_with_thought_preservation(response)
+        elif isinstance(response, AsyncStream):
+            return self._wrap_async_stream_with_thought_preservation(response)
+
+        # For non-streaming responses, thought signatures are already preserved
+        # in _process_messages when the response becomes part of conversation
+        # history
+        return response
+
+    def _wrap_stream_with_thought_preservation(
+        self, stream: Stream[ChatCompletionChunk]
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        r"""Wrap a streaming response to preserve thought signatures in tool
+        calls.
+
+        This method ensures that when Gemini streaming responses contain tool
+        calls with thought signatures, these are properly preserved in the
+        extra_content field for future conversation context.
+
+        Args:
+            stream: The original streaming response from Gemini
+
+        Returns:
+            A wrapped stream that preserves thought signatures
+        """
+
+        def thought_preserving_generator():
+            accumulated_signatures = {}  # Store signatures by tool call index
+
+            for chunk in stream:
+                # Process chunk normally first
+                processed_chunk = chunk
+
+                # Check if this chunk contains tool call deltas with thought
+                # signatures
+                if (
+                    hasattr(chunk, 'choices')
+                    and chunk.choices
+                    and hasattr(chunk.choices[0], 'delta')
+                    and hasattr(chunk.choices[0].delta, 'tool_calls')
+                ):
+                    delta_tool_calls = chunk.choices[0].delta.tool_calls
+                    if delta_tool_calls:
+                        for tool_call_delta in delta_tool_calls:
+                            index = tool_call_delta.index
+
+                            # Check for thought signatures in the tool call
+                            # response Gemini may include these in custom
+                            # fields
+                            if hasattr(tool_call_delta, 'extra_content'):
+                                extra_content = tool_call_delta.extra_content
+                                if (
+                                    isinstance(extra_content, dict)
+                                    and 'google' in extra_content
+                                ):
+                                    google_content = extra_content['google']
+                                    if 'thought_signature' in google_content:
+                                        # Store the thought signature for this
+                                        # tool call
+                                        accumulated_signatures[index] = (
+                                            extra_content
+                                        )
+
+                            # Also check if thought signature is in function
+                            # response
+                            elif hasattr(
+                                tool_call_delta, 'function'
+                            ) and hasattr(
+                                tool_call_delta.function, 'extra_content'
+                            ):
+                                func_extra = (
+                                    tool_call_delta.function.extra_content
+                                )
+                                if (
+                                    isinstance(func_extra, dict)
+                                    and 'google' in func_extra
+                                ):
+                                    accumulated_signatures[index] = func_extra
+
+                            # If we have accumulated signature for this tool
+                            # call, ensure it's preserved in the chunk
+                            if index in accumulated_signatures:
+                                # Add extra_content to tool call delta if it
+                                # doesn't exist
+                                if not hasattr(
+                                    tool_call_delta, 'extra_content'
+                                ):
+                                    tool_call_delta.extra_content = (
+                                        accumulated_signatures[index]
+                                    )
+                                elif tool_call_delta.extra_content is None:
+                                    tool_call_delta.extra_content = (
+                                        accumulated_signatures[index]
+                                    )
+
+                yield processed_chunk
+
+        return thought_preserving_generator()
+
+    def _wrap_async_stream_with_thought_preservation(
+        self, stream: AsyncStream[ChatCompletionChunk]
+    ) -> AsyncGenerator[ChatCompletionChunk, None]:
+        r"""Wrap an async streaming response to preserve thought signatures in
+        tool calls.
+
+        This method ensures that when Gemini async streaming responses contain
+        tool calls with thought signatures, these are properly preserved in
+        the extra_content field for future conversation context.
+
+        Args:
+            stream: The original async streaming response from Gemini
+
+        Returns:
+            A wrapped async stream that preserves thought signatures
+        """
+
+        async def async_thought_preserving_generator():
+            accumulated_signatures = {}  # Store signatures by tool call index
+
+            async for chunk in stream:
+                # Process chunk normally first
+                processed_chunk = chunk
+
+                # Check if this chunk contains tool call deltas with thought
+                # signatures
+                if (
+                    hasattr(chunk, 'choices')
+                    and chunk.choices
+                    and hasattr(chunk.choices[0], 'delta')
+                    and hasattr(chunk.choices[0].delta, 'tool_calls')
+                ):
+                    delta_tool_calls = chunk.choices[0].delta.tool_calls
+                    if delta_tool_calls:
+                        for tool_call_delta in delta_tool_calls:
+                            index = tool_call_delta.index
+
+                            # Check for thought signatures in the tool call
+                            # response
+                            if hasattr(tool_call_delta, 'extra_content'):
+                                extra_content = tool_call_delta.extra_content
+                                if (
+                                    isinstance(extra_content, dict)
+                                    and 'google' in extra_content
+                                ):
+                                    google_content = extra_content['google']
+                                    if 'thought_signature' in google_content:
+                                        # Store the thought signature for this
+                                        # tool call
+                                        accumulated_signatures[index] = (
+                                            extra_content
+                                        )
+
+                            # Also check if thought signature is in function
+                            # response
+                            elif hasattr(
+                                tool_call_delta, 'function'
+                            ) and hasattr(
+                                tool_call_delta.function, 'extra_content'
+                            ):
+                                func_extra = (
+                                    tool_call_delta.function.extra_content
+                                )
+                                if (
+                                    isinstance(func_extra, dict)
+                                    and 'google' in func_extra
+                                ):
+                                    accumulated_signatures[index] = func_extra
+
+                            # If we have accumulated signature for this tool
+                            # call, ensure it's preserved in the chunk
+                            if index in accumulated_signatures:
+                                # Add extra_content to tool call delta if it
+                                # doesn't exist
+                                if not hasattr(
+                                    tool_call_delta, 'extra_content'
+                                ):
+                                    tool_call_delta.extra_content = (
+                                        accumulated_signatures[index]
+                                    )
+                                elif tool_call_delta.extra_content is None:
+                                    tool_call_delta.extra_content = (
+                                        accumulated_signatures[index]
+                                    )
+
+                yield processed_chunk
+
+        return async_thought_preserving_generator()
+
     @observe()
     def _run(
         self,
@@ -230,7 +574,7 @@ class GeminiModel(OpenAICompatibleModel):
                 function_dict = tool.get('function', {})
                 function_dict.pop("strict", None)
 
-                # Process parameters to remove anyOf
+                # Process parameters to remove anyOf and handle enum/format
                 if 'parameters' in function_dict:
                     params = function_dict['parameters']
                     if 'properties' in params:
@@ -247,14 +591,31 @@ class GeminiModel(OpenAICompatibleModel):
                                         'description'
                                     ] = prop_value['description']
 
+                            # Handle enum and format restrictions for Gemini
+                            # API enum: only allowed for string type
+                            if prop_value.get('type') != 'string':
+                                prop_value.pop('enum', None)
+
+                            # format: only allowed for string, integer, and
+                            # number types
+                            if prop_value.get('type') not in [
+                                'string',
+                                'integer',
+                                'number',
+                            ]:
+                                prop_value.pop('format', None)
+
             request_config["tools"] = tools
 
-        return self._client.chat.completions.create(
+        response = self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,
             **request_config,
         )
 
+        # Preserve thought signatures from the response for future requests
+        return self._preserve_thought_signatures(response)  # type: ignore[return-value]
+
     async def _arequest_chat_completion(
         self,
         messages: List[OpenAIMessage],
@@ -270,7 +631,7 @@ class GeminiModel(OpenAICompatibleModel):
                 function_dict = tool.get('function', {})
                 function_dict.pop("strict", None)
 
-                # Process parameters to remove anyOf
+                # Process parameters to remove anyOf and handle enum/format
                 if 'parameters' in function_dict:
                     params = function_dict['parameters']
                     if 'properties' in params:
@@ -287,25 +648,27 @@ class GeminiModel(OpenAICompatibleModel):
                                         'description'
                                     ] = prop_value['description']
 
+                            # Handle enum and format restrictions for Gemini
+                            # API enum: only allowed for string type
+                            if prop_value.get('type') != 'string':
+                                prop_value.pop('enum', None)
+
+                            # format: only allowed for string, integer, and
+                            # number types
+                            if prop_value.get('type') not in [
+                                'string',
+                                'integer',
+                                'number',
+                            ]:
+                                prop_value.pop('format', None)
+
             request_config["tools"] = tools
 
-        return await self._async_client.chat.completions.create(
+        response = await self._async_client.chat.completions.create(
             messages=messages,
             model=self.model_type,
             **request_config,
         )
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to Gemini API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to Gemini API.
-        """
-        for param in self.model_config_dict:
-            if param not in Gemini_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into Gemini model backend."
-                )
+        # Preserve thought signatures from the response for future requests
+        return self._preserve_thought_signatures(response)  # type: ignore[return-value]