Merge branch 'master' into fix-reset-bug_a7m

Author: Wendong-Fan

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -26,7 +26,7 @@ body:
     attributes:
       label: What version of camel are you using?
       description: Run command `python3 -c 'print(__import__("camel").__version__)'` in your shell and paste the output here.
-      placeholder: E.g., 0.2.80a3
+      placeholder: E.g., 0.2.80
     validations:
       required: true
 

.github/workflows/build_package.yml

@@ -148,6 +148,7 @@ jobs:
           CRYNUX_API_KEY: "${{ secrets.CRYNUX_API_KEY }}"
           NEBIUS_API_KEY: "${{ secrets.NEBIUS_API_KEY }}"
           COMETAPI_KEY: "${{ secrets.COMETAPI_KEY }}"
+          CEREBRAS_API_KEY: "${{ secrets.CEREBRAS_API_KEY }}"
         run: |
           source test_venv/bin/activate
           pytest --fast-test-mode -m "not heavy_dependency" \

.github/workflows/pytest_package.yml

@@ -91,6 +91,7 @@ jobs:
         NEBIUS_API_KEY: "${{ secrets.NEBIUS_API_KEY }}"
         COMETAPI_KEY: "${{ secrets.COMETAPI_KEY }}"
         MINIMAX_API_KEY: "${{ secrets.MINIMAX_API_KEY }}"
+        CEREBRAS_API_KEY: "${{ secrets.CEREBRAS_API_KEY }}"
       run: |
         source .venv/bin/activate
         uv pip install -e ".[all, dev, docs]"
@@ -179,6 +180,7 @@ jobs:
         AMD_API_KEY: "${{ secrets.AMD_API_KEY }}"
         COMETAPI_KEY: "${{ secrets.COMETAPI_KEY }}"
         MINIMAX_API_KEY: "${{ secrets.MINIMAX_API_KEY }}"
+        CEREBRAS_API_KEY: "${{ secrets.CEREBRAS_API_KEY }}"
       run: |
         source .venv/bin/activate
         uv pip install -e ".[all, dev, docs]"
@@ -265,6 +267,7 @@ jobs:
         AMD_API_KEY: "${{ secrets.AMD_API_KEY }}"
         COMETAPI_KEY: "${{ secrets.COMETAPI_KEY }}"
         MINIMAX_API_KEY: "${{ secrets.MINIMAX_API_KEY }}"
+        CEREBRAS_API_KEY: "${{ secrets.CEREBRAS_API_KEY }}"
       run: |
         source .venv/bin/activate
         uv pip install -e ".[all, dev, docs]"

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.80a3'
+__version__ = '0.2.80'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -3914,7 +3914,8 @@ async def _aexecute_tool(
 
             else:
                 # Fallback: synchronous call
-                result = tool(**args)
+                loop = asyncio.get_running_loop()
+                result = await loop.run_in_executor(None, lambda: tool(**args))
 
         except Exception as e:
             # Capture the error message to prevent framework crash
@@ -4741,7 +4742,10 @@ async def _aexecute_tool_from_stream_data(
 
                     else:
                         # Fallback: synchronous call
-                        result = tool(**args)
+                        loop = asyncio.get_running_loop()
+                        result = await loop.run_in_executor(
+                            None, lambda: tool(**args)
+                        )
 
                     # Create the tool response message
                     func_msg = FunctionCallingMessage(
@@ -4916,7 +4920,12 @@ async def _astream_response(
                 return
 
             # Handle streaming response
-            if isinstance(response, AsyncStream):
+            # Note: Also check for async generators since some model backends
+            # (e.g., GeminiModel) wrap AsyncStream in async generators for
+            # additional processing
+            if isinstance(response, AsyncStream) or inspect.isasyncgen(
+                response
+            ):
                 stream_completed = False
                 tool_calls_complete = False
 
@@ -5121,7 +5130,10 @@ def _record_assistant_tool_calls_message(
 
     async def _aprocess_stream_chunks_with_accumulator(
         self,
-        stream: AsyncStream[ChatCompletionChunk],
+        stream: Union[
+            AsyncStream[ChatCompletionChunk],
+            AsyncGenerator[ChatCompletionChunk, None],
+        ],
         content_accumulator: StreamContentAccumulator,
         accumulated_tool_calls: Dict[str, Any],
         tool_call_records: List[ToolCallingRecord],

camel/logger.py

@@ -36,8 +36,8 @@ def _configure_library_logging():
             f"CAMEL library logging has been configured "
             f"(level: {_logger.getEffectiveLevel()}). "
             f"To change level, use set_log_level() or "
-            "set CAMEL_LOGGING_LEVEL env var. To disable logging, "
-            "set CAMEL_LOGGING_DISABLED=true or use disable_logging()"
+            f"set CAMEL_LOGGING_LEVEL env var. To disable logging, "
+            f"set CAMEL_LOGGING_DISABLED=true or use disable_logging()"
         )
     else:
         _logger.debug("Existing logger configuration found, using that.")

camel/models/gemini_model.py

@@ -122,19 +122,116 @@ def __init__(
     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. Also preserves thought signatures
-        required for Gemini 3 Pro function calling and adds fallback signatures
-        when they are missing.
+        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.
         """
         import copy
 
-        processed_messages = []
-        for msg in messages:
-            # Use deep copy to preserve all nested structures including
-            # thought signatures in extra_content
+        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(

camel/toolkits/function_tool.py

@@ -12,10 +12,12 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import ast
+import asyncio
 import inspect
 import logging
 import textwrap
 import warnings
+from concurrent.futures import ThreadPoolExecutor
 from inspect import Parameter, getsource, signature
 from typing import Any, Callable, Dict, Mapping, Optional, Tuple, Type
 
@@ -31,6 +33,9 @@
 
 logger = logging.getLogger(__name__)
 
+# Shared thread pool for running sync tools without blocking the event loop
+_SYNC_TOOL_EXECUTOR = ThreadPoolExecutor(max_workers=64)
+
 
 def _remove_a_key(d: Dict, remove_key: Any) -> None:
     r"""Remove a key from a dictionary recursively."""
@@ -500,7 +505,11 @@ async def async_call(self, *args: Any, **kwargs: Any) -> Any:
         if self.is_async:
             return await self.func(*args, **kwargs)
         else:
-            return self.func(*args, **kwargs)
+            # Run sync function in executor to avoid blocking event loop
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(
+                _SYNC_TOOL_EXECUTOR, lambda: self.func(*args, **kwargs)
+            )
 
     @property
     def is_async(self) -> bool:

camel/toolkits/hybrid_browser_toolkit/config_loader.py

@@ -150,14 +150,14 @@ def to_ws_config(self) -> Dict[str, Any]:
             "networkIdleTimeout": self.browser_config.network_idle_timeout,
             "screenshotTimeout": self.browser_config.screenshot_timeout,
             "pageStabilityTimeout": self.browser_config.page_stability_timeout,
-            "browser_log_to_file": self.toolkit_config.browser_log_to_file,
-            "log_dir": self.toolkit_config.log_dir,
-            "session_id": self.toolkit_config.session_id,
             "viewport_limit": self.browser_config.viewport_limit,
             "connectOverCdp": self.browser_config.connect_over_cdp,
             "cdpUrl": self.browser_config.cdp_url,
             "cdpKeepCurrentPage": self.browser_config.cdp_keep_current_page,
             "fullVisualMode": self.browser_config.full_visual_mode,
+            "browser_log_to_file": self.toolkit_config.browser_log_to_file,
+            "log_dir": self.toolkit_config.log_dir,
+            "session_id": self.toolkit_config.session_id,
         }
 
     def get_timeout_config(self) -> Dict[str, Optional[int]]: