aury-agent 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

aury/agents/react/tools.py

@@ -0,0 +1,318 @@
+"""Tool execution helpers for ReactAgent."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from ..core.logging import react_logger as logger
+from ..core.event_bus import Events
+from ..core.types.block import BlockEvent, BlockKind, BlockOp
+from ..core.types import (
+    ToolContext,
+    ToolResult,
+    ToolInvocation,
+)
+from ..core.signals import SuspendSignal
+from ..llm import LLMMessage
+from ..middleware import HookAction
+
+if TYPE_CHECKING:
+    from .agent import ReactAgent
+    from ..core.types.tool import BaseTool
+
+
+def get_tool(agent: "ReactAgent", tool_name: str) -> "BaseTool | None":
+    """Get tool by name from agent context.
+    
+    Args:
+        agent: ReactAgent instance
+        tool_name: Name of the tool to find
+        
+    Returns:
+        Tool instance or None if not found
+    """
+    if agent._agent_context:
+        for tool in agent._agent_context.tools:
+            if tool.name == tool_name:
+                return tool
+    return None
+
+
+async def execute_tool(agent: "ReactAgent", invocation: ToolInvocation) -> ToolResult:
+    """Execute a single tool call.
+    
+    Args:
+        agent: ReactAgent instance
+        invocation: Tool invocation to execute
+        
+    Returns:
+        ToolResult from tool execution
+    """
+    invocation.mark_call_complete()
+
+    logger.info(
+        f"Executing tool: {invocation.tool_name}",
+        extra={
+            "invocation_id": agent._current_invocation.id if agent._current_invocation else "",
+            "call_id": invocation.tool_call_id,
+            "arguments": invocation.args,
+        },
+    )
+
+    # Build middleware context
+    mw_context = {
+        "session_id": agent.session.id,
+        "invocation_id": agent._current_invocation.id if agent._current_invocation else "",
+        "tool_call_id": invocation.tool_call_id,
+        "agent_id": agent.name,
+    }
+
+    try:
+        # Get tool from agent context
+        tool = get_tool(agent, invocation.tool_name)
+        if tool is None:
+            error_msg = f"Unknown tool: {invocation.tool_name}"
+            invocation.mark_result(error_msg, is_error=True)
+            logger.warning(
+                f"Tool not found: {invocation.tool_name}",
+                extra={"invocation_id": agent._current_invocation.id if agent._current_invocation else ""},
+            )
+            return ToolResult.error(error_msg)
+
+        # === Middleware: on_tool_call ===
+        if agent.middleware:
+            logger.debug(
+                f"Calling middleware: on_tool_call ({invocation.tool_name})",
+                extra={"invocation_id": agent._current_invocation.id, "call_id": invocation.tool_call_id},
+            )
+            hook_result = await agent.middleware.process_tool_call(
+                tool, invocation.args, mw_context
+            )
+            if hook_result.action == HookAction.SKIP:
+                logger.warning(
+                    f"Tool {invocation.tool_name} skipped by middleware",
+                    extra={"invocation_id": agent._current_invocation.id},
+                )
+                return ToolResult(
+                    output=hook_result.message or "Skipped by middleware",
+                    is_error=False,
+                )
+            elif hook_result.action == HookAction.RETRY and hook_result.modified_data:
+                logger.debug(
+                    f"Tool args modified by middleware",
+                    extra={"invocation_id": agent._current_invocation.id},
+                )
+                invocation.args = hook_result.modified_data
+
+        # Create ToolContext
+        tool_ctx = ToolContext(
+            session_id=agent.session.id,
+            invocation_id=agent._current_invocation.id if agent._current_invocation else "",
+            block_id="",
+            call_id=invocation.tool_call_id,
+            agent=agent.config.name,
+            abort_signal=agent._abort,
+            update_metadata=agent._noop_update_metadata,
+            middleware=agent.middleware,
+        )
+
+        # Execute tool (with optional timeout from tool.config)
+        timeout = tool.config.timeout
+        if timeout is not None:
+            result = await asyncio.wait_for(
+                tool.execute(invocation.args, tool_ctx),
+                timeout=timeout,
+            )
+        else:
+            # No timeout - tool runs until completion
+            result = await tool.execute(invocation.args, tool_ctx)
+
+        # === Middleware: on_tool_end ===
+        if agent.middleware:
+            logger.debug(
+                f"Calling middleware: on_tool_end ({invocation.tool_name})",
+                extra={"invocation_id": agent._current_invocation.id},
+            )
+            hook_result = await agent.middleware.process_tool_end(tool, result, mw_context)
+            if hook_result.action == HookAction.RETRY:
+                logger.info(
+                    f"Tool {invocation.tool_name} retry requested by middleware",
+                    extra={"invocation_id": agent._current_invocation.id},
+                )
+
+        invocation.mark_result(result.output, is_error=result.is_error)
+        logger.info(
+            f"Tool executed: {invocation.tool_name}",
+            extra={
+                "invocation_id": agent._current_invocation.id if agent._current_invocation else "",
+                "call_id": invocation.tool_call_id,
+                "is_error": result.is_error,
+                "output_length": len(result.output) if result.output else 0,
+            },
+        )
+        return result
+
+    except asyncio.TimeoutError:
+        timeout = tool.config.timeout if tool else None
+        error_msg = f"Tool {invocation.tool_name} timed out after {timeout}s"
+        invocation.mark_result(error_msg, is_error=True)
+        logger.error(
+            f"Tool timeout: {invocation.tool_name}",
+            extra={
+                "invocation_id": agent._current_invocation.id if agent._current_invocation else "",
+                "timeout": timeout,
+            },
+        )
+        return ToolResult.error(error_msg)
+
+    except SuspendSignal:
+        # HITL/Suspend signal must propagate up
+        raise
+    
+    except Exception as e:
+        error_msg = f"Tool execution error: {str(e)}"
+        invocation.mark_result(error_msg, is_error=True)
+        logger.error(
+            f"Tool execution failed: {invocation.tool_name}",
+            extra={
+                "invocation_id": agent._current_invocation.id if agent._current_invocation else "",
+                "error": str(e),
+            },
+            exc_info=True,
+        )
+        return ToolResult.error(error_msg)
+
+
+async def process_tool_results(agent: "ReactAgent") -> None:
+    """Execute tool calls and add results to history.
+
+    Executes tools in parallel or sequentially based on config.
+    
+    This function directly modifies agent's internal state:
+    - agent._message_history
+    
+    Args:
+        agent: ReactAgent instance
+    """
+    if not agent._tool_invocations:
+        return
+
+    logger.info(
+        f"Executing {len(agent._tool_invocations)} tools",
+        extra={
+            "invocation_id": agent._current_invocation.id,
+            "mode": "parallel" if agent.config.parallel_tool_execution else "sequential",
+            "tools": [inv.tool_name for inv in agent._tool_invocations],
+        },
+    )
+
+    # Execute tools based on configuration
+    if agent.config.parallel_tool_execution:
+        # Parallel execution using asyncio.gather with create_task
+        # create_task ensures each task gets its own ContextVar copy
+        tasks = [asyncio.create_task(execute_tool(agent, inv)) for inv in agent._tool_invocations]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+    else:
+        # Sequential execution
+        results = []
+        for inv in agent._tool_invocations:
+            try:
+                result = await execute_tool(agent, inv)
+                results.append(result)
+            except Exception as e:
+                results.append(e)
+
+    # Check for SuspendSignal - record tool_results first, then propagate
+    suspend_signal = None
+    for result in results:
+        if isinstance(result, SuspendSignal):
+            suspend_signal = result
+            break
+    
+    if suspend_signal:
+        # Must record tool_results to history BEFORE suspending
+        # Otherwise Claude API will reject next request (tool_use without tool_result)
+        for invocation, result in zip(agent._tool_invocations, results):
+            if isinstance(result, SuspendSignal):
+                # HITL tool - record placeholder result
+                invocation.mark_result(f"[等待用户输入: {suspend_signal.request_type}]", is_error=False)
+            else:
+                # Normal tool result
+                invocation.mark_result(
+                    result.output if hasattr(result, 'output') else str(result),
+                    is_error=getattr(result, 'is_error', False)
+                )
+            
+            # Add to in-memory history
+            agent._message_history.append(
+                LLMMessage(
+                    role="tool",
+                    content=invocation.result,
+                    tool_call_id=invocation.tool_call_id,
+                )
+            )
+        
+        # Persist via _save_tool_messages
+        await agent._save_tool_messages()
+        
+        logger.info(
+            "Tool execution suspended (HITL), tool_results recorded",
+            extra={"invocation_id": agent._current_invocation.id},
+        )
+        raise suspend_signal
+    
+    # Process results
+    tool_results = []
+
+    for invocation, result in zip(agent._tool_invocations, results):
+        # Handle exceptions from gather
+        if isinstance(result, Exception):
+            error_msg = f"Tool execution error: {str(result)}"
+            invocation.mark_result(error_msg, is_error=True)
+            result = ToolResult.error(error_msg)
+
+        # Get parent block_id from tool_call mapping
+        parent_block_id = agent._tool_call_blocks.get(invocation.tool_call_id)
+        
+        await agent.ctx.emit(BlockEvent(
+            kind=BlockKind.TOOL_RESULT,
+            op=BlockOp.APPLY,
+            parent_id=parent_block_id,
+            data={
+                "call_id": invocation.tool_call_id,
+                "content": result.output,
+                "is_error": invocation.is_error,
+            },
+        ))
+
+        await agent.bus.publish(
+            Events.TOOL_END,
+            {
+                "call_id": invocation.tool_call_id,
+                "tool": invocation.tool_name,
+                "result": result.output[:500],  # Truncate for event
+                "is_error": invocation.is_error,
+                "duration_ms": invocation.duration_ms,
+            },
+        )
+
+        tool_results.append(
+            {
+                "type": "tool_result",
+                "tool_use_id": invocation.tool_call_id,
+                "content": result.output,
+                "is_error": invocation.is_error,
+            }
+        )
+
+    # Add tool results as tool messages (OpenAI format)
+    for tr in tool_results:
+        print(f"[DEBUG _process_tool_results] Adding tool_result to history: {tr}")
+        agent._message_history.append(
+            LLMMessage(
+                role="tool",
+                content=tr["content"],
+                tool_call_id=tr["tool_use_id"],
+            )
+        )

aury/agents/tool/builtin/bash.py

@@ -6,6 +6,7 @@ import subprocess
 from typing import Any
 
 from ...core.types.tool import BaseTool, ToolContext, ToolResult, ToolInfo
+from ...core.logging import tool_logger as logger
 
 
 class BashTool(BaseTool):
@@ -57,17 +58,23 @@ class BashTool(BaseTool):
         command = params.get("command", "")
         timeout = params.get("timeout", 30)
         working_dir = params.get("working_dir")
+        invocation_id = ctx.invocation_id if ctx else None
+        
+        logger.info(f"BashTool executing command, invocation_id={invocation_id}, timeout={timeout}")
         
         if not command:
+            logger.warning(f"BashTool: command is empty, invocation_id={invocation_id}")
             return ToolResult.error("Command is required")
         
         # Security check
         if self._allowed_commands:
             cmd_prefix = command.split()[0] if command.split() else ""
             if cmd_prefix not in self._allowed_commands:
+                logger.warning(f"BashTool: command not allowed, cmd={cmd_prefix}, invocation_id={invocation_id}")
                 return ToolResult.error(f"Command '{cmd_prefix}' is not allowed")
         
         try:
+            logger.debug(f"BashTool: starting subprocess, working_dir={working_dir}, invocation_id={invocation_id}")
             # Run command
             process = await asyncio.create_subprocess_shell(
                 command,
@@ -83,12 +90,14 @@ class BashTool(BaseTool):
                 )
             except asyncio.TimeoutError:
                 process.kill()
+                logger.warning(f"BashTool: command timeout, timeout={timeout}, invocation_id={invocation_id}")
                 return ToolResult.error(f"Command timed out after {timeout} seconds")
             
             output = stdout.decode("utf-8", errors="replace")
             error_output = stderr.decode("utf-8", errors="replace")
             
             if process.returncode != 0:
+                logger.info(f"BashTool: command failed, exit_code={process.returncode}, invocation_id={invocation_id}")
                 return ToolResult(
                     output=f"Exit code: {process.returncode}\n\nSTDOUT:\n{output}\n\nSTDERR:\n{error_output}",
                     is_error=True,
@@ -98,9 +107,11 @@ class BashTool(BaseTool):
             if error_output:
                 result_output += f"\n\nSTDERR:\n{error_output}"
             
+            logger.info(f"BashTool: command completed successfully, output_len={len(result_output)}, invocation_id={invocation_id}")
             return ToolResult(output=result_output.strip() or "(no output)")
             
         except Exception as e:
+            logger.error(f"BashTool: execution error, error={type(e).__name__}, invocation_id={invocation_id}", exc_info=True)
             return ToolResult.error(str(e))
 
 

aury/agents/tool/builtin/delegate.py

@@ -227,11 +227,22 @@ Specify the agent key and task data."""
         if not agent_key:
             return ToolResult.error("Missing 'agent' parameter")
         
-        logger.info("Delegating to sub-agent", extra={"agent": agent_key})
+        logger.info(
+            "Delegating to sub-agent",
+            extra={
+                "agent": agent_key,
+                "invocation_id": ctx.invocation_id,
+                "session_id": ctx.session_id,
+            },
+        )
         
         # Get agent config (static or dynamic)
         config = await self._get_agent_config(agent_key, ctx)
         if config is None:
+            logger.error(
+                f"Unknown sub-agent: {agent_key}",
+                extra={"invocation_id": ctx.invocation_id},
+            )
             agents = await self._get_all_agents(ctx)
             available = ", ".join(a.key for a in agents) or "none"
             return ToolResult.error(f"Unknown agent: {agent_key}. Available: {available}")
@@ -246,6 +257,12 @@ Specify the agent key and task data."""
         
         try:
             # 根据 create_invocation 决定执行模式
+            mode = "delegated" if config.create_invocation else "embedded"
+            logger.debug(
+                f"Executing sub-agent in {mode} mode",
+                extra={"agent": agent_key, "invocation_id": ctx.invocation_id},
+            )
+            
             if config.create_invocation:
                 result = await self._execute_delegated(
                     config, ctx, task_context, artifact_refs
@@ -255,6 +272,15 @@ Specify the agent key and task data."""
                     config, ctx, task_context, artifact_refs
                 )
             
+            logger.info(
+                f"Sub-agent execution completed",
+                extra={
+                    "agent": agent_key,
+                    "invocation_id": ctx.invocation_id,
+                    "is_error": result.is_error,
+                },
+            )
+            
             # Emit SUB_AGENT block (end)
             await self._emit_subagent_block(ctx, config, "end", block_id)
             
@@ -263,7 +289,11 @@ Specify the agent key and task data."""
             
             return result
         except Exception as e:
-            logger.error("Delegation failed", extra={"agent": agent_key, "error": str(e)})
+            logger.error(
+                "Sub-agent delegation failed",
+                extra={"agent": agent_key, "invocation_id": ctx.invocation_id, "error": str(e)},
+                exc_info=True,
+            )
             # Emit error state
             await self._emit_subagent_block(ctx, config, "error", block_id)
             self._active_block_ids.pop(block_key, None)
@@ -285,7 +315,12 @@ Specify the agent key and task data."""
         """
         logger.info(
             "Parallel delegation",
-            extra={"agents": [a.get("agent") for a in agents_param]},
+            extra={
+                "agents": [a.get("agent") for a in agents_param],
+                "invocation_id": ctx.invocation_id,
+                "session_id": ctx.session_id,
+                "count": len(agents_param),
+            },
         )
         
         # Validate all agents exist

aury/agents/tool/builtin/edit.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any, Literal
 
 from ...core.types.tool import BaseTool, ToolContext, ToolResult
+from ...core.logging import tool_logger as logger
 
 
 class EditTool(BaseTool):
@@ -62,33 +63,43 @@ class EditTool(BaseTool):
         line = params.get("line")
         encoding = params.get("encoding", "utf-8")
         create_dirs = params.get("create_dirs", True)
+        invocation_id = ctx.invocation_id if ctx else None
+        
+        logger.info(f"EditTool editing file, path={file_path}, mode={mode}, content_len={len(content)}, invocation_id={invocation_id}")
         
         if not file_path:
+            logger.warning(f"EditTool: path is empty, invocation_id={invocation_id}")
             return ToolResult.error("Path is required")
         
         path = Path(file_path).expanduser().resolve()
+        logger.debug(f"EditTool: resolved path, path={path}, invocation_id={invocation_id}")
         
         # Security check
         if self._allowed_paths:
             if not any(str(path).startswith(p) for p in self._allowed_paths):
+                logger.warning(f"EditTool: path not allowed, path={path}, invocation_id={invocation_id}")
                 return ToolResult.error(f"Path not allowed: {path}")
         
         try:
             # Create parent directories
             if create_dirs and not path.parent.exists():
+                logger.debug(f"EditTool: creating parent directories, path={path.parent}, invocation_id={invocation_id}")
                 path.parent.mkdir(parents=True, exist_ok=True)
             
             if mode == "overwrite":
                 path.write_text(content, encoding=encoding)
+                logger.info(f"EditTool: file overwritten, path={path}, content_len={len(content)}, invocation_id={invocation_id}")
                 return ToolResult(output=f"File written ({len(content)} chars)")
             
             elif mode == "append":
                 existing = path.read_text(encoding=encoding) if path.exists() else ""
                 path.write_text(existing + content, encoding=encoding)
+                logger.info(f"EditTool: content appended, path={path}, appended_len={len(content)}, invocation_id={invocation_id}")
                 return ToolResult(output=f"Content appended ({len(content)} chars)")
             
             elif mode == "insert":
                 if line is None:
+                    logger.warning(f"EditTool: insert mode requires line number, invocation_id={invocation_id}")
                     return ToolResult.error("Line number required for insert mode")
                 
                 if path.exists():
@@ -96,6 +107,8 @@ class EditTool(BaseTool):
                 else:
                     lines = []
                 
+                logger.debug(f"EditTool: read existing content, total_lines={len(lines)}, invocation_id={invocation_id}")
+                
                 # Pad with empty lines if needed
                 while len(lines) < line - 1:
                     lines.append("\n")
@@ -109,12 +122,15 @@ class EditTool(BaseTool):
                 new_lines = lines[:insert_idx] + content_lines + lines[insert_idx:]
                 path.write_text("".join(new_lines), encoding=encoding)
                 
+                logger.info(f"EditTool: content inserted, path={path}, line={line}, inserted_lines={len(content_lines)}, invocation_id={invocation_id}")
                 return ToolResult(output=f"Content inserted at line {line} ({len(content_lines)} lines)")
             
             else:
+                logger.warning(f"EditTool: unknown mode, mode={mode}, invocation_id={invocation_id}")
                 return ToolResult.error(f"Unknown mode: {mode}")
             
         except Exception as e:
+            logger.error(f"EditTool: edit error, error={type(e).__name__}, path={path}, mode={mode}, invocation_id={invocation_id}", exc_info=True)
             return ToolResult.error(str(e))
 
 

aury/agents/tool/builtin/plan.py

@@ -100,7 +100,16 @@ Use this to track your progress on complex tasks."""
         ctx: ToolContext,
     ) -> ToolResult:
         """Execute plan action."""
+        from ...core.logging import tool_logger as logger
+        
         action = params.get("action", "view")
+        logger.info(
+            f"Plan tool action: {action}",
+            extra={
+                "invocation_id": ctx.invocation_id,
+                "session_id": ctx.session_id,
+            },
+        )
         
         # Storage key
         key = f"plan:{ctx.session_id}"
@@ -132,6 +141,16 @@ Use this to track your progress on complex tasks."""
         # Save plan
         await storage.set("plan", key, plan)
         
+        from ...core.logging import tool_logger as logger
+        logger.debug(
+            f"Plan updated",
+            extra={
+                "action": action,
+                "status": plan.get("status"),
+                "item_count": len(plan.get("items", [])),
+            },
+        )
+        
         # Emit PLAN block
         await self._emit_plan_block(ctx, plan, action)
         

aury/agents/tool/builtin/read.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any
 
 from ...core.types.tool import BaseTool, ToolContext, ToolResult
+from ...core.logging import tool_logger as logger
 
 
 class ReadTool(BaseTool):
@@ -49,32 +50,42 @@ class ReadTool(BaseTool):
         start_line = params.get("start_line")
         end_line = params.get("end_line")
         encoding = params.get("encoding", "utf-8")
+        invocation_id = ctx.invocation_id if ctx else None
+        
+        logger.info(f"ReadTool reading file, path={file_path}, start_line={start_line}, end_line={end_line}, invocation_id={invocation_id}")
         
         if not file_path:
+            logger.warning(f"ReadTool: path is empty, invocation_id={invocation_id}")
             return ToolResult.error("Path is required")
         
         path = Path(file_path).expanduser().resolve()
+        logger.debug(f"ReadTool: resolved path, path={path}, invocation_id={invocation_id}")
         
         # Security check
         if self._allowed_paths:
             if not any(str(path).startswith(p) for p in self._allowed_paths):
+                logger.warning(f"ReadTool: path not allowed, path={path}, invocation_id={invocation_id}")
                 return ToolResult.error(f"Path not allowed: {path}")
         
         if not path.exists():
+            logger.warning(f"ReadTool: file not found, path={path}, invocation_id={invocation_id}")
             return ToolResult.error(f"File not found: {path}")
         
         if not path.is_file():
+            logger.warning(f"ReadTool: not a file, path={path}, invocation_id={invocation_id}")
             return ToolResult.error(f"Not a file: {path}")
         
         try:
             content = path.read_text(encoding=encoding)
             lines = content.splitlines(keepends=True)
+            logger.debug(f"ReadTool: read file, total_lines={len(lines)}, invocation_id={invocation_id}")
             
             # Apply line range
             if start_line is not None or end_line is not None:
                 start_idx = (start_line - 1) if start_line else 0
                 end_idx = end_line if end_line else len(lines)
                 lines = lines[start_idx:end_idx]
+                logger.debug(f"ReadTool: applied line range, start_idx={start_idx}, end_idx={end_idx}, selected_lines={len(lines)}, invocation_id={invocation_id}")
                 
                 # Add line numbers
                 output_lines = []
@@ -82,9 +93,11 @@ class ReadTool(BaseTool):
                     output_lines.append(f"{i:4d}| {line.rstrip()}")
                 content = "\n".join(output_lines)
             
+            logger.info(f"ReadTool: read completed, content_len={len(content)}, invocation_id={invocation_id}")
             return ToolResult(output=content or "(empty file)")
             
         except Exception as e:
+            logger.error(f"ReadTool: read error, error={type(e).__name__}, path={path}, invocation_id={invocation_id}", exc_info=True)
             return ToolResult.error(str(e))
 
 

aury/agents/tool/builtin/thinking.py

@@ -70,17 +70,18 @@ This makes your reasoning visible and traceable."""
         """Execute thinking - emit reasoning block."""
         thought = params.get("thought", "")
         category = params.get("category", "analysis")
+        invocation_id = ctx.invocation_id if ctx else None
         
-        logger.debug(
-            "Agent thinking",
-            extra={"category": category, "length": len(thought)},
+        logger.info(
+            f"ThinkingTool processing, category={category}, thought_len={len(thought)}, invocation_id={invocation_id}"
         )
         
         # Emit THINKING block
-        await self._emit_thinking_block(ctx, thought, category)
+        await self._emit_thinking_block(ctx, thought, category, invocation_id)
         
         # Thinking doesn't produce actionable output
         # It's purely for transparency/logging
+        logger.debug(f"ThinkingTool completed, invocation_id={invocation_id}")
         return ToolResult(output=thought)
     
     async def _emit_thinking_block(
@@ -88,12 +89,16 @@ This makes your reasoning visible and traceable."""
         ctx: ToolContext,
         thought: str,
         category: str,
+        invocation_id: int | None = None,
     ) -> None:
         """Emit THINKING block."""
         emit = getattr(ctx, 'emit', None)
         if emit is None:
+            logger.debug(f"ThinkingTool: emit not available, invocation_id={invocation_id}")
             return
         
+        logger.debug(f"ThinkingTool: emitting block, category={category}, invocation_id={invocation_id}")
+        
         block = BlockEvent(
             kind=BlockKind.THINKING,
             op=BlockOp.APPLY,
@@ -106,6 +111,7 @@ This makes your reasoning visible and traceable."""
         )
         
         await emit(block)
+        logger.debug(f"ThinkingTool: block emitted successfully, invocation_id={invocation_id}")
 
 
 __all__ = ["ThinkingTool"]