fix: parallel tool call sequence bug, upadte doc and readme (camel-ai#2148)

Author: Wendong-Fan

README.md

@@ -416,6 +416,13 @@ For more information please contact [email protected]
 
 - **Ambassador Project:** Advocate for CAMEL-AI, host events, and contribute content. [Learn more](https://www.camel-ai.org/community)
 
+- **WeChat Community:** Scan the QR code below to join our WeChat community.
+
+  <div align="center">
+    <img src="misc/wechat.jpg" alt="WeChat QR Code" width="200">
+  </div>
+
+
 <br>
 
 ## Citation

camel/embeddings/azure_embedding.py

@@ -31,7 +31,7 @@ class AzureEmbedding(BaseEmbedding[str]):
     Args:
         model_type (EmbeddingModelType, optional): The model type to be
             used for text embeddings.
-            (default: :obj:`TEXT_EMBEDDING_ADA_2`)
+            (default: :obj:`TEXT_EMBEDDING_3_SMALL`)
         url (Optional[str], optional): The url to the Azure OpenAI service.
             (default: :obj:`None`)
         api_key (str, optional): The API key for authenticating with the

camel/models/base_model.py

@@ -108,42 +108,125 @@ def preprocess_messages(
     ) -> List[OpenAIMessage]:
         r"""Preprocess messages before sending to model API.
         Removes thinking content from assistant and user messages.
+        Automatically formats messages for parallel tool calls if tools are
+        detected.
 
         Args:
-            messages (List[OpenAIMessage]): Original messages
+            messages (List[OpenAIMessage]): Original messages.
 
         Returns:
             List[OpenAIMessage]: Preprocessed messages
         """
-
-        def should_process_thinking(msg: OpenAIMessage) -> bool:
-            # Only process thinking content for assistant and user messages
-            return msg['role'] in ['assistant', 'user'] and isinstance(
-                msg['content'], str
+        # Process all messages in a single pass
+        processed_messages = []
+        tool_calls_buffer: List[OpenAIMessage] = []
+        tool_responses_buffer: Dict[str, OpenAIMessage] = {}
+        has_tool_calls = False
+
+        for msg in messages:
+            # Remove thinking content if needed
+            role = msg.get('role')
+            content = msg.get('content')
+            if role in ['assistant', 'user'] and isinstance(content, str):
+                if '<think>' in content and '</think>' in content:
+                    content = re.sub(
+                        r'<think>.*?</think>', '', content, flags=re.DOTALL
+                    ).strip()
+                processed_msg = dict(msg)
+                processed_msg['content'] = content
+            else:
+                processed_msg = dict(msg)
+
+            # Check and track tool calls/responses
+            is_tool_call = (
+                processed_msg.get("role") == "assistant"
+                and "tool_calls" in processed_msg
+            )
+            is_tool_response = (
+                processed_msg.get("role") == "tool"
+                and "tool_call_id" in processed_msg
             )
 
-        def remove_thinking(content: str) -> str:
-            # Only remove thinking content if the tags are present
-            if '<think>' in content and '</think>' in content:
-                return re.sub(
-                    r'<think>.*?</think>',
-                    '',
-                    content,
-                    flags=re.DOTALL,
-                ).strip()
-            return content
-
-        return [
-            {  # type: ignore[misc]
-                **msg,
-                'content': (
-                    remove_thinking(msg['content'])  # type: ignore[arg-type]
-                    if should_process_thinking(msg)
-                    else msg['content']
-                ),
-            }
-            for msg in messages
-        ]
+            if is_tool_call or is_tool_response:
+                has_tool_calls = True
+
+            # Store the processed message for later formatting if needed
+            processed_messages.append(processed_msg)
+
+        # If no tool calls detected, return the processed messages
+        if not has_tool_calls:
+            return processed_messages  # type: ignore[return-value]
+
+        # Format messages for parallel tool calls
+        formatted_messages = []
+        tool_calls_buffer = []
+        tool_responses_buffer = {}
+
+        for msg in processed_messages:  # type: ignore[assignment]
+            # If this is an assistant message with tool calls, add it to the
+            # buffer
+            if msg.get("role") == "assistant" and "tool_calls" in msg:
+                tool_calls_buffer.append(msg)
+                continue
+
+            # If this is a tool response, add it to the responses buffer
+            if msg.get("role") == "tool" and "tool_call_id" in msg:
+                tool_call_id = msg.get("tool_call_id")
+                if isinstance(tool_call_id, str):
+                    tool_responses_buffer[tool_call_id] = msg
+                continue
+
+            # Process any complete tool call + responses before adding regular
+            # messages
+            if tool_calls_buffer and tool_responses_buffer:
+                # Add the assistant message with tool calls
+                assistant_msg = tool_calls_buffer[0]
+                formatted_messages.append(assistant_msg)
+
+                # Add all matching tool responses for this assistant message
+                tool_calls = assistant_msg.get("tool_calls", [])
+                if isinstance(tool_calls, list):
+                    for tool_call in tool_calls:
+                        tool_call_id = tool_call.get("id")
+                        if (
+                            isinstance(tool_call_id, str)
+                            and tool_call_id in tool_responses_buffer
+                        ):
+                            formatted_messages.append(
+                                tool_responses_buffer[tool_call_id]
+                            )
+                            del tool_responses_buffer[tool_call_id]
+
+                tool_calls_buffer.pop(0)
+
+            # Add the current regular message
+            formatted_messages.append(msg)
+
+        # Process any remaining buffered tool calls and responses
+        while tool_calls_buffer:
+            assistant_msg = tool_calls_buffer[0]
+            formatted_messages.append(assistant_msg)
+
+            tool_calls = assistant_msg.get("tool_calls", [])
+            if isinstance(tool_calls, list):
+                for tool_call in tool_calls:
+                    tool_call_id = tool_call.get("id")
+                    if (
+                        isinstance(tool_call_id, str)
+                        and tool_call_id in tool_responses_buffer
+                    ):
+                        formatted_messages.append(
+                            tool_responses_buffer[tool_call_id]
+                        )
+                        del tool_responses_buffer[tool_call_id]
+
+            tool_calls_buffer.pop(0)
+
+        # Add any remaining tool responses
+        for response in tool_responses_buffer.values():
+            formatted_messages.append(response)
+
+        return formatted_messages
 
     @abstractmethod
     def _run(

camel/toolkits/google_calendar_toolkit.py

@@ -20,7 +20,7 @@
 from camel.logger import get_logger
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
-from camel.utils.commons import MCPServer, api_keys_required
+from camel.utils import MCPServer, api_keys_required
 
 logger = get_logger(__name__)
 

docs/key_modules/embeddings.md

@@ -37,6 +37,9 @@ Utilizes OpenAI's models for generating image embeddings. This will requires Ope
 ### 2.5. `AzureOpenAI`
 Utilizes OpenAI's models for generating text embeddings. This will requires Azure OpenAI API Key.
 
+### 2.6. `TogetherEmbedding`
+Utilizes Together AI's models for generating text embeddings. This will requires Together AI API Key.
+
 
 ## 3. Get Started
 To use the embedding functionalities, you need to import the necessary classes.
@@ -100,3 +103,14 @@ azure_openai_embedding = AzureEmbedding(model_type=EmbeddingModelType.TEXT_EMBED
 # Generate embeddings for a list of texts
 embeddings = azure_openai_embedding.embed_list(["Hello, world!", "Another example"])
 ```
+
+### 3.6. Using `TogetherEmbedding`
+```python
+from camel.embeddings import TogetherEmbedding
+
+# Initialize the Together AI embedding with a specific model
+together_embedding = TogetherEmbedding(model_name="togethercomputer/m2-bert-80M-8k-retrieval")
+
+# Generate embeddings for a list of texts
+embeddings = together_embedding.embed_list(["Hello, world!", "Another example"])
+```