Merge branch 'main' into fix/logger

Author: nitpicker55555

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -12,7 +12,7 @@ body:
     id: version
     attributes:
       label: What version of eigent are you using?
-      placeholder: E.g., 0.0.72
+      placeholder: E.g., 0.0.73
     validations:
       required: true
 

.github/workflows/codeql.yml

@@ -0,0 +1,103 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '42 22 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: actions
+          build-mode: none
+        - language: javascript-typescript
+          build-mode: none
+        - language: python
+          build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Add any setup steps before running the `github/codeql-action/init` action.
+    # This includes steps like installing compilers or runtimes (`actions/setup-node`
+    # or others). This is typically only required for manual builds.
+    # - name: Setup runtime (example)
+    #   uses: actions/setup-example@v1
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v4
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - name: Run manual build steps
+      if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v4
+      with:
+        category: "/language:${{matrix.language}}"

backend/app/component/model_validation.py

@@ -37,5 +37,6 @@ def create_agent(
         system_message="You are a helpful assistant that must use the tool get_website_content to get the content of a website.",
         model=model,
         tools=[get_website_content],
+        step_timeout=900,
     )
     return agent

backend/app/utils/agent.py

@@ -107,6 +107,7 @@ def __init__(
         pause_event: asyncio.Event | None = None,
         prune_tool_calls_from_memory: bool = False,
         enable_snapshot_clean: bool = False,
+        step_timeout: float | None = 900,
     ) -> None:
         super().__init__(
             system_message=system_message,
@@ -128,6 +129,7 @@ def __init__(
             pause_event=pause_event,
             prune_tool_calls_from_memory=prune_tool_calls_from_memory,
             enable_snapshot_clean=enable_snapshot_clean,
+            step_timeout=step_timeout,
         )
         self.api_task_id = api_task_id
         self.agent_name = agent_name
@@ -287,19 +289,25 @@ def _execute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallingRecord
         if asyncio.iscoroutinefunction(tool.func):
             # For async functions, we need to use the async execution path
             return asyncio.run(self._aexecute_tool(tool_call_request))
-        elif hasattr(tool.func, "__wrapped__"):
-            with set_process_task(self.process_task_id):
-                return super()._execute_tool(tool_call_request)
-        else:
-            args = tool_call_request.args
-            tool_call_id = tool_call_request.tool_call_id
-            try:
-                task_lock = get_task_lock(self.api_task_id)
-
-                toolkit_name = getattr(tool, "_toolkit_name") if hasattr(tool, "_toolkit_name") else "mcp_toolkit"
-                traceroot_logger.debug(
-                    f"Agent {self.agent_name} executing tool: {func_name} from toolkit: {toolkit_name} with args: {json.dumps(args, ensure_ascii=False)}"
-                )
+
+        # Handle all sync tools ourselves to maintain ContextVar context
+        args = tool_call_request.args
+        tool_call_id = tool_call_request.tool_call_id
+
+        # Check if tool is wrapped by @listen_toolkit decorator
+        # If so, the decorator will handle activate/deactivate events
+        has_listen_decorator = hasattr(tool.func, "__wrapped__")
+
+        try:
+            task_lock = get_task_lock(self.api_task_id)
+
+            toolkit_name = getattr(tool, "_toolkit_name") if hasattr(tool, "_toolkit_name") else "mcp_toolkit"
+            traceroot_logger.debug(
+                f"Agent {self.agent_name} executing tool: {func_name} from toolkit: {toolkit_name} with args: {json.dumps(args, ensure_ascii=False)}"
+            )
+
+            # Only send activate event if tool is NOT wrapped by @listen_toolkit
+            if not has_listen_decorator:
                 asyncio.create_task(
                     task_lock.put_queue(
                         ActionActivateToolkitData(
@@ -313,29 +321,33 @@ def _execute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallingRecord
                         )
                     )
                 )
+            # Set process_task context for all tool executions
+            with set_process_task(self.process_task_id):
                 raw_result = tool(**args)
-                traceroot_logger.debug(f"Tool {func_name} executed successfully")
-                if self.mask_tool_output:
-                    self._secure_result_store[tool_call_id] = raw_result
-                    result = (
-                        "[The tool has been executed successfully, but the output"
-                        " from the tool is masked. You can move forward]"
-                    )
-                    mask_flag = True
-                else:
-                    result = raw_result
-                    mask_flag = False
-                # Prepare result message with truncation
-                if isinstance(result, str):
-                    result_msg = result
+            traceroot_logger.debug(f"Tool {func_name} executed successfully")
+            if self.mask_tool_output:
+                self._secure_result_store[tool_call_id] = raw_result
+                result = (
+                    "[The tool has been executed successfully, but the output"
+                    " from the tool is masked. You can move forward]"
+                )
+                mask_flag = True
+            else:
+                result = raw_result
+                mask_flag = False
+            # Prepare result message with truncation
+            if isinstance(result, str):
+                result_msg = result
+            else:
+                result_str = repr(result)
+                MAX_RESULT_LENGTH = 500
+                if len(result_str) > MAX_RESULT_LENGTH:
+                    result_msg = result_str[:MAX_RESULT_LENGTH] + f"... (truncated, total length: {len(result_str)} chars)"
                 else:
-                    result_str = repr(result)
-                    MAX_RESULT_LENGTH = 500
-                    if len(result_str) > MAX_RESULT_LENGTH:
-                        result_msg = result_str[:MAX_RESULT_LENGTH] + f"... (truncated, total length: {len(result_str)} chars)"
-                    else:
-                        result_msg = result_str
+                    result_msg = result_str
 
+            # Only send deactivate event if tool is NOT wrapped by @listen_toolkit
+            if not has_listen_decorator:
                 asyncio.create_task(
                     task_lock.put_queue(
                         ActionDeactivateToolkitData(
@@ -349,31 +361,40 @@ def _execute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallingRecord
                         )
                     )
                 )
-            except Exception as e:
-                # Capture the error message to prevent framework crash
-                error_msg = f"Error executing tool '{func_name}': {e!s}"
-                result = f"Tool execution failed: {error_msg}"
-                mask_flag = False
-                traceroot_logger.error(f"Tool execution failed for {func_name}: {e}", exc_info=True)
-
-        return self._record_tool_calling(func_name, args, result, tool_call_id, mask_output=mask_flag)
+        except Exception as e:
+            # Capture the error message to prevent framework crash
+            error_msg = f"Error executing tool '{func_name}': {e!s}"
+            result = f"Tool execution failed: {error_msg}"
+            mask_flag = False
+            traceroot_logger.error(f"Tool execution failed for {func_name}: {e}", exc_info=True)
+
+        return self._record_tool_calling(
+            func_name, args, result, tool_call_id,
+            mask_output=mask_flag,
+            extra_content=tool_call_request.extra_content,
+        )
 
     @traceroot.trace()
     async def _aexecute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallingRecord:
         func_name = tool_call_request.tool_name
         tool: FunctionTool = self._internal_tools[func_name]
-        if hasattr(tool.func, "__wrapped__"):
-            with set_process_task(self.process_task_id):
-                return await super()._aexecute_tool(tool_call_request)
-        else:
-            args = tool_call_request.args
-            tool_call_id = tool_call_request.tool_call_id
-            task_lock = get_task_lock(self.api_task_id)
 
-            toolkit_name = getattr(tool, "_toolkit_name") if hasattr(tool, "_toolkit_name") else "mcp_toolkit"
-            traceroot_logger.info(
-                f"Agent {self.agent_name} executing async tool: {func_name} from toolkit: {toolkit_name} with args: {json.dumps(args, ensure_ascii=False)}"
-            )
+        # Always handle tool execution ourselves to maintain ContextVar context
+        args = tool_call_request.args
+        tool_call_id = tool_call_request.tool_call_id
+        task_lock = get_task_lock(self.api_task_id)
+
+        # Check if tool is wrapped by @listen_toolkit decorator
+        # If so, the decorator will handle activate/deactivate events
+        has_listen_decorator = hasattr(tool.func, "__wrapped__")
+
+        toolkit_name = getattr(tool, "_toolkit_name") if hasattr(tool, "_toolkit_name") else "mcp_toolkit"
+        traceroot_logger.info(
+            f"Agent {self.agent_name} executing async tool: {func_name} from toolkit: {toolkit_name} with args: {json.dumps(args, ensure_ascii=False)}"
+        )
+
+        # Only send activate event if tool is NOT wrapped by @listen_toolkit
+        if not has_listen_decorator:
             await task_lock.put_queue(
                 ActionActivateToolkitData(
                     data={
@@ -385,7 +406,9 @@ async def _aexecute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallin
                     },
                 )
             )
-            try:
+        try:
+            # Set process_task context for all tool executions
+            with set_process_task(self.process_task_id):
                 # Try different invocation paths in order of preference
                 if hasattr(tool, "func") and hasattr(tool.func, "async_call"):
                     # Case: FunctionTool wrapping an MCP tool
@@ -404,29 +427,32 @@ async def _aexecute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallin
                     result = await tool(**args)
 
                 else:
-                    # Fallback: synchronous call
+                    # Fallback: synchronous call - call directly in current context
+                    # DO NOT use run_in_executor to preserve ContextVar
                     result = tool(**args)
                     # Handle case where synchronous call returns a coroutine
                     if asyncio.iscoroutine(result):
                         result = await result
 
-            except Exception as e:
-                # Capture the error message to prevent framework crash
-                error_msg = f"Error executing async tool '{func_name}': {e!s}"
-                result = {"error": error_msg}
-                traceroot_logger.error(f"Async tool execution failed for {func_name}: {e}", exc_info=True)
-
-            # Prepare result message with truncation
-            if isinstance(result, str):
-                result_msg = result
+        except Exception as e:
+            # Capture the error message to prevent framework crash
+            error_msg = f"Error executing async tool '{func_name}': {e!s}"
+            result = {"error": error_msg}
+            traceroot_logger.error(f"Async tool execution failed for {func_name}: {e}", exc_info=True)
+
+        # Prepare result message with truncation
+        if isinstance(result, str):
+            result_msg = result
+        else:
+            result_str = repr(result)
+            MAX_RESULT_LENGTH = 500
+            if len(result_str) > MAX_RESULT_LENGTH:
+                result_msg = result_str[:MAX_RESULT_LENGTH] + f"... (truncated, total length: {len(result_str)} chars)"
             else:
-                result_str = repr(result)
-                MAX_RESULT_LENGTH = 500
-                if len(result_str) > MAX_RESULT_LENGTH:
-                    result_msg = result_str[:MAX_RESULT_LENGTH] + f"... (truncated, total length: {len(result_str)} chars)"
-                else:
-                    result_msg = result_str
+                result_msg = result_str
 
+        # Only send deactivate event if tool is NOT wrapped by @listen_toolkit
+        if not has_listen_decorator:
             await task_lock.put_queue(
                 ActionDeactivateToolkitData(
                     data={
@@ -438,7 +464,10 @@ async def _aexecute_tool(self, tool_call_request: ToolCallRequest) -> ToolCallin
                     },
                 )
             )
-        return self._record_tool_calling(func_name, args, result, tool_call_id)
+        return self._record_tool_calling(
+            func_name, args, result, tool_call_id,
+            extra_content=tool_call_request.extra_content,
+        )
 
     @traceroot.trace()
     def clone(self, with_memory: bool = False) -> ChatAgent:
@@ -468,6 +497,7 @@ def clone(self, with_memory: bool = False) -> ChatAgent:
             mask_tool_output=self.mask_tool_output,
             pause_event=self.pause_event,
             prune_tool_calls_from_memory=self.prune_tool_calls_from_memory,
+            step_timeout=self.step_timeout,
         )
 
         new_agent.process_task_id = self.process_task_id
@@ -746,7 +776,7 @@ def search_agent(options: Chat):
             "browser_enter",
             "browser_visit_page",
             "browser_scroll",
-            "browser_get_som_screenshot",
+            # "browser_get_som_screenshot",
         ],
     )
 
@@ -869,9 +899,6 @@ def search_agent(options: Chat):
     interactive elements, not the full page text. To see more content on
     long pages, Navigate with `browser_click`, `browser_back`, and
     `browser_forward`. Manage multiple pages with `browser_switch_tab`.
-- **Analysis**: Use `browser_get_som_screenshot` to understand the page
-    layout and identify interactive elements. Since this is a heavy
-    operation, only use it when visual analysis is necessary.
 - **Interaction**: Use `browser_type` to fill out forms and
     `browser_enter` to submit or confirm search.