lm-deluge 0.0.83__tar.gz → 0.0.85__tar.gz

{lm_deluge-0.0.83/src/lm_deluge.egg-info → lm_deluge-0.0.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.83
+Version: 0.0.85
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.83"
+version = "0.0.85"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/api_requests/anthropic.py

@@ -167,6 +167,9 @@ def _build_anthropic_request(
                     "bash_20241022",
                 ]:
                     _add_beta(base_headers, "computer-use-2024-10-22")
+                elif tool["type"] == "computer_20251124":
+                    # Claude Opus 4.5 - newest computer use with zoom support
+                    _add_beta(base_headers, "computer-use-2025-11-24")
                 elif tool["type"] == "computer_20250124":
                     _add_beta(base_headers, "computer-use-2025-01-24")
                 elif tool["type"] == "code_execution_20250522":

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/api_requests/gemini.py

@@ -114,8 +114,40 @@ async def _build_gemini_request(
 
     # Add tools if provided
     if tools:
-        tool_declarations = [tool.dump_for("google") for tool in tools]
-        request_json["tools"] = [{"functionDeclarations": tool_declarations}]
+        request_tools = []
+        function_declarations = []
+
+        for tool in tools:
+            if isinstance(tool, dict) and tool.get("type") == "gemini_computer_use":
+                # Gemini computer use tool - add as separate tool entry
+                env_map = {
+                    "browser": "ENVIRONMENT_BROWSER",
+                    "android": "ENVIRONMENT_ANDROID",
+                }
+                env = env_map.get(
+                    tool.get("environment", "browser"), "ENVIRONMENT_BROWSER"
+                )
+                cu_tool: dict = {
+                    "computerUse": {
+                        "environment": env,
+                    }
+                }
+                excluded = tool.get("excluded_predefined_functions")
+                if excluded:
+                    cu_tool["computerUse"]["excludedPredefinedFunctions"] = excluded
+                request_tools.append(cu_tool)
+            elif hasattr(tool, "dump_for"):
+                # Regular Tool object
+                function_declarations.append(tool.dump_for("google"))
+            elif isinstance(tool, dict):
+                # Raw dict tool - assume it's a function declaration
+                function_declarations.append(tool)
+
+        if function_declarations:
+            request_tools.append({"functionDeclarations": function_declarations})
+
+        if request_tools:
+            request_json["tools"] = request_tools
 
     # Handle JSON mode
     if sampling_params.json_mode and model.supports_json:

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/api_requests/openai.py

@@ -367,7 +367,7 @@ async def _build_oa_responses_request(
         elif isinstance(tool, dict):
             # if computer use, make sure model supports it
             if tool["type"] == "computer_use_preview":
-                if model.name != "openai-computer-use-preview":
+                if model.name != "computer-use-preview":
                     raise ValueError(f"model {model.id} does not support computer use")
                 # have to use truncation
                 request_json["truncation"] = "auto"

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/client.py

@@ -1012,6 +1012,92 @@ class _LLMClient(BaseModel):
             )
         )
 
+    async def process_agent_loops_async(
+        self,
+        prompts: Sequence[Prompt],
+        *,
+        tools: Sequence[Tool | dict | MCPServer] | None = None,
+        max_rounds: int = 5,
+        max_concurrent_agents: int = 10,
+        show_progress: bool = True,
+    ) -> list[tuple[Conversation, APIResponse]]:
+        """Process multiple agent loops concurrently.
+
+        Each prompt becomes an independent agent loop that can make multiple LLM
+        calls and execute tools until completion. The agent loops run concurrently,
+        limited by ``max_concurrent_agents``, while the underlying LLM requests
+        are still governed by ``max_concurrent_requests``.
+
+        Args:
+            prompts: Sequence of prompts, each becoming a separate agent loop.
+            tools: Tools available to all agent loops.
+            max_rounds: Maximum rounds per agent loop (default 5).
+            max_concurrent_agents: Maximum number of agent loops running
+                concurrently (default 10). This is separate from the LLM request
+                concurrency limit.
+            show_progress: Whether to show progress bar for LLM requests.
+
+        Returns:
+            List of (Conversation, APIResponse) tuples in the same order as
+            the input prompts.
+        """
+        # Convert prompts to Conversations
+        conversations = prompts_to_conversations(list(prompts))
+
+        # Ensure tracker exists for underlying LLM requests
+        if self._tracker is None:
+            self.open(total=0, show_progress=show_progress)
+            tracker_preopened = False
+        else:
+            tracker_preopened = True
+
+        # Semaphore to limit concurrent agent loops
+        agent_semaphore = asyncio.Semaphore(max_concurrent_agents)
+
+        async def run_single_loop(
+            idx: int, conv: Conversation
+        ) -> tuple[int, Conversation, APIResponse]:
+            """Run a single agent loop with semaphore protection."""
+            async with agent_semaphore:
+                task_id = self._next_task_id
+                self._next_task_id += 1
+                result = await self._run_agent_loop_internal(
+                    task_id, conv, tools=tools, max_rounds=max_rounds
+                )
+                return idx, result.conversation, result.final_response
+
+        # Launch all agent loops concurrently (semaphore limits actual concurrency)
+        tasks = [run_single_loop(idx, conv) for idx, conv in enumerate(conversations)]
+        completed = await asyncio.gather(*tasks)
+
+        # Close tracker if we opened it
+        if not tracker_preopened:
+            self.close()
+
+        # Sort by original index and extract results
+        completed_sorted = sorted(completed, key=lambda x: x[0])
+        return [(conv, resp) for _, conv, resp in completed_sorted]
+
+    def process_agent_loops_sync(
+        self,
+        prompts: Sequence[Prompt],
+        *,
+        tools: Sequence[Tool | dict | MCPServer] | None = None,
+        max_rounds: int = 5,
+        max_concurrent_agents: int = 10,
+        show_progress: bool = True,
+    ) -> list[tuple[Conversation, APIResponse]]:
+        """Synchronous wrapper for :meth:`process_agent_loops_async`."""
+        return asyncio.run(
+            self.process_agent_loops_async(
+                prompts,
+                tools=tools,
+                max_rounds=max_rounds,
+                max_concurrent_agents=max_concurrent_agents,
+                show_progress=show_progress,
+            )
+        )
+
     async def submit_batch_job(
         self,
         prompts: Prompt | Sequence[Prompt],

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/models/google.py

@@ -153,4 +153,18 @@ GOOGLE_MODELS = {
         # Note: >200k tokens pricing is $4/$18 per million
         "reasoning_model": True,
     },
+    # Gemini 2.5 Computer Use model
+    "gemini-2.5-computer-use": {
+        "id": "gemini-2.5-computer-use",
+        "name": "gemini-2.5-computer-use-preview-10-2025",
+        "api_base": "https://generativelanguage.googleapis.com/v1beta",
+        "api_key_env_var": "GEMINI_API_KEY",
+        "supports_json": True,
+        "supports_logprobs": False,
+        "api_spec": "gemini",
+        "input_cost": 1.25,  # same as gemini-2.5-pro for now
+        "cached_input_cost": 0.31,
+        "output_cost": 10.0,
+        "reasoning_model": True,
+    },
 }

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/models/openai.py

@@ -149,6 +149,34 @@ OPENAI_MODELS = {
         "output_cost": 6.0,
         "reasoning_model": True,
     },
+    "o4-mini-deep-research": {
+        "id": "o4-mini-deep-research",
+        "name": "o4-mini-deep-research",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": True,
+        "supports_logprobs": False,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 2,
+        "cached_input_cost": 0.5,
+        "output_cost": 8.0,
+        "reasoning_model": True,
+    },
+    "o3-deep-research": {
+        "id": "o3-deep-research",
+        "name": "o3-deep-research",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": True,
+        "supports_logprobs": False,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 10,
+        "cached_input_cost": 2.50,
+        "output_cost": 40.0,
+        "reasoning_model": True,
+    },
     "o3": {
         "id": "o3",
         "name": "o3-2025-04-16",

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/prompt.py

@@ -203,6 +203,8 @@ class ToolResult:
                 "call_id": self.tool_call_id,
             }
             if self.built_in_type == "computer_call":
+                # OpenAI expects "computer_call_output" for the result type
+                result["type"] = "computer_call_output"
                 result["output"] = output_data.get("output", {})
                 if "acknowledged_safety_checks" in output_data:
                     result["acknowledged_safety_checks"] = output_data[
@@ -235,15 +237,41 @@ class ToolResult:
             raise ValueError("unsupported self.result type")
 
     def gemini(self) -> dict:
-        if not isinstance(self.result, str):
-            raise ValueError("can't handle content blocks for gemini yet")
-        return {
-            "functionResponse": {
-                "name": self.tool_call_id,  # Gemini uses name field for ID
-                "response": {"result": self.result},
-            }
+        # Build the function response
+        func_response: dict = {
+            "name": self.tool_call_id,  # Gemini uses name field for ID
         }
 
+        # Handle different result types
+        if isinstance(self.result, str):
+            func_response["response"] = {"result": self.result}
+        elif isinstance(self.result, dict):
+            # Check for Gemini computer use format with inline screenshot
+            if self.built_in_type == "gemini_computer_use":
+                # Gemini CU expects response dict with optional inline_data parts
+                func_response["response"] = self.result.get("response", {})
+                # Include inline data (screenshot) if present
+                if "inline_data" in self.result:
+                    func_response["parts"] = [
+                        {
+                            "inlineData": {
+                                "mimeType": self.result["inline_data"].get(
+                                    "mime_type", "image/png"
+                                ),
+                                "data": self.result["inline_data"]["data"],
+                            }
+                        }
+                    ]
+            else:
+                func_response["response"] = self.result
+        elif isinstance(self.result, list):
+            # Handle content blocks (images, etc.) - not yet implemented
+            raise ValueError("can't handle content blocks for gemini yet")
+        else:
+            func_response["response"] = {"result": str(self.result)}
+
+        return {"functionResponse": func_response}
+
     def mistral(self) -> dict:
         return {
             "type": "tool_result",
@@ -1367,14 +1395,14 @@ class Conversation:
                 # For assistant messages, extract computer calls as separate items
                 text_parts = []
                 for p in m.parts:
-                    if isinstance(p, ToolCall) and p.name.startswith("_computer_"):
+                    if isinstance(p, ToolCall) and p.built_in_type == "computer_call":
                         # Computer calls become separate items in the input array
-                        action_type = p.name.replace("_computer_", "")
+                        # p.arguments already contains the full action dict with "type"
                         input_items.append(
                             {
                                 "type": "computer_call",
                                 "call_id": p.id,
-                                "action": {"type": action_type, **p.arguments},
+                                "action": p.arguments,
                             }
                         )
                     elif isinstance(p, Text):
@@ -1752,7 +1780,7 @@ class Conversation:
 Prompt: TypeAlias = str | list[dict] | Message | Conversation
 
 
-def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Prompt]:
+def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Conversation]:
     converted = []
     for prompt in prompts:
         if isinstance(prompt, Conversation):

{lm_deluge-0.0.83 → lm_deluge-0.0.85}/src/lm_deluge/tool/__init__.py

@@ -614,6 +614,7 @@ class Tool(BaseModel):
         cls,
         func: Callable,
         *,
+        name: str | None = None,
         include_output_schema_in_description: bool = False,
     ) -> "Tool":
         """
@@ -629,6 +630,8 @@ class Tool(BaseModel):
 
         Args:
             func: The function to create a tool from.
+            name: Optional name override for the tool. If not provided,
+                uses the function's __name__.
             include_output_schema_in_description: If True, append the return type
                 and any complex type definitions to the tool description. This can
                 help the model understand what the tool returns. Default is False.
@@ -646,6 +649,10 @@ class Tool(BaseModel):
             # tool.output_schema contains schema for list[dict]
             # tool.call(query="test", validate_output=True) validates return value
 
+            # With custom name:
+            tool = Tool.from_function(search, name="search_database")
+            # tool.name is "search_database"
+
             # With output schema in description:
             tool = Tool.from_function(search, include_output_schema_in_description=True)
             # Description becomes:
@@ -653,11 +660,11 @@ class Tool(BaseModel):
             #
             # Returns: list[dict]"
         """
-        # Get function name
-        name = func.__name__
+        # Get function name (use override if provided)
+        tool_name = name if name is not None else func.__name__
 
         # Get docstring for description
-        description = func.__doc__ or f"Call the {name} function"
+        description = func.__doc__ or f"Call the {tool_name} function"
         description = description.strip()
 
         # Use TypeAdapter for robust schema generation
@@ -705,7 +712,7 @@ class Tool(BaseModel):
                 description = f"{description}\n\n{output_info}"
 
         tool = cls(
-            name=name,
+            name=tool_name,
             description=description,
             parameters=parameters,
             required=required,

lm_deluge-0.0.85/src/lm_deluge/tool/builtin/anthropic/__init__.py

@@ -0,0 +1,300 @@
+from typing import Literal
+
+# Tool version identifiers corresponding to Anthropic's versioned tools
+# - 2024-10-22: Claude 3.5/3.6 (original computer use)
+# - 2025-01-24: Claude Sonnet 3.7 and Claude 4 models
+# - 2025-11-24: Claude Opus 4.5 (adds zoom action)
+ToolVersion = Literal["2024-10-22", "2025-01-24", "2025-11-24"]
+ToolType = Literal["bash", "computer", "editor"]
+
+
+def model_to_version(model: str) -> ToolVersion:
+    """
+    Determine the appropriate tool version for a given model.
+
+    Model compatibility:
+    - Claude Opus 4.5 (claude-opus-4-5-*): Uses 2025-11-24 tools with zoom support
+    - Claude 4 models (claude-4-*, claude-sonnet-4-*, claude-opus-4-*, etc.): Uses 2025-01-24 tools
+    - Claude Sonnet 3.7 (deprecated): Uses 2025-01-24 tools
+    - Claude 3.5/3.6: Uses 2024-10-22 tools
+    """
+    model_lower = model.lower()
+
+    # Check for valid model families
+    if not any(x in model_lower for x in ["opus", "sonnet", "haiku"]):
+        raise ValueError(
+            f"Cannot use computer tools with model '{model}'. "
+            "Computer use requires Claude Opus, Sonnet, or Haiku models."
+        )
+
+    # Claude Opus 4.5 - newest tool version with zoom support
+    # Matches: claude-opus-4-5-*, claude-4.5-opus, etc.
+    if (
+        "opus-4-5" in model_lower
+        or "opus-4.5" in model_lower
+        or "4.5-opus" in model_lower
+    ):
+        return "2025-11-24"
+
+    # Claude 4 models (Sonnet 4.5, Opus 4, Sonnet 4, Haiku 4.5, etc.)
+    # Matches aliases like claude-4-sonnet, claude-4.5-sonnet
+    # and full names like claude-sonnet-4-20250514, claude-sonnet-4-5-20250929
+    claude_4_patterns = [
+        "claude-4",  # alias prefix: claude-4-sonnet, claude-4-opus
+        "4.5-sonnet",  # alias: claude-4.5-sonnet
+        "4.5-haiku",  # alias: claude-4.5-haiku
+        "sonnet-4-5",  # full name: claude-sonnet-4-5-*
+        "sonnet-4-",  # full name: claude-sonnet-4-* (note trailing dash to avoid matching 3-5)
+        "opus-4-",  # full name: claude-opus-4-* (but not opus-4-5 handled above)
+        "haiku-4-5",  # full name: claude-haiku-4-5-*
+    ]
+    if any(p in model_lower for p in claude_4_patterns):
+        return "2025-01-24"
+
+    # Claude Sonnet 3.7 (deprecated but still supported)
+    if "3.7" in model_lower or "3-7" in model_lower:
+        return "2025-01-24"
+
+    # Claude 3.5/3.6 (older models)
+    if any(x in model_lower for x in ["3.5", "3-5", "3.6", "3-6"]):
+        return "2024-10-22"
+
+    raise ValueError(
+        f"Unsupported model '{model}' for Anthropic computer use. "
+        "Supported: Claude Opus 4.5, Claude 4 models, Sonnet 3.7, or 3.5/3.6."
+    )
+
+
+def get_beta_header(model: str) -> str:
+    """
+    Get the appropriate beta header for computer use with the given model.
+
+    Returns:
+        Beta header string to use in the API request.
+    """
+    version = model_to_version(model)
+
+    if version == "2025-11-24":
+        return "computer-use-2025-11-24"
+    elif version == "2025-01-24":
+        return "computer-use-2025-01-24"
+    else:  # 2024-10-22
+        return "computer-use-2024-10-22"
+
+
+def get_anthropic_cu_tools(
+    model: str,
+    display_width: int = 1024,
+    display_height: int = 768,
+    exclude_tools: list[ToolType] | None = None,
+    enable_zoom: bool = False,
+) -> list[dict]:
+    """
+    Get the computer use tools for the given model.
+
+    Args:
+        model: The model name (e.g., "claude-opus-4-5-20251124", "claude-4-sonnet")
+        display_width: Display width in pixels (recommended <= 1280)
+        display_height: Display height in pixels (recommended <= 800)
+        exclude_tools: List of tool types to exclude ("bash", "computer", "editor")
+        enable_zoom: Enable zoom action for Opus 4.5 (computer_20251124 only)
+
+    Returns:
+        List of tool definitions for the Anthropic API.
+
+    Note:
+        Keep display resolution at or below 1280x800 (WXGA) for best performance.
+        Higher resolutions may cause accuracy issues due to image resizing.
+    """
+    version = model_to_version(model)
+
+    if version == "2024-10-22":
+        # Claude 3.5/3.6 - original computer use
+        result = [
+            {
+                "name": "computer",
+                "type": "computer_20241022",
+                "display_width_px": display_width,
+                "display_height_px": display_height,
+                "display_number": None,
+            },
+            {"name": "str_replace_editor", "type": "text_editor_20241022"},
+            {"name": "bash", "type": "bash_20241022"},
+        ]
+    elif version == "2025-01-24":
+        # Claude 4 models and Sonnet 3.7
+        # Uses computer_20250124 and text_editor_20250728
+        result = [
+            {
+                "name": "computer",
+                "type": "computer_20250124",
+                "display_width_px": display_width,
+                "display_height_px": display_height,
+                "display_number": None,
+            },
+            {"name": "str_replace_based_edit_tool", "type": "text_editor_20250728"},
+            {"name": "bash", "type": "bash_20250124"},
+        ]
+    elif version == "2025-11-24":
+        # Claude Opus 4.5 - newest with zoom support
+        computer_tool: dict = {
+            "name": "computer",
+            "type": "computer_20251124",
+            "display_width_px": display_width,
+            "display_height_px": display_height,
+            "display_number": None,
+        }
+        # Enable zoom action if requested (allows Claude to zoom into screen regions)
+        if enable_zoom:
+            computer_tool["enable_zoom"] = True
+
+        result = [
+            computer_tool,
+            {"name": "str_replace_based_edit_tool", "type": "text_editor_20250728"},
+            {"name": "bash", "type": "bash_20250124"},
+        ]
+    else:
+        raise ValueError(f"Invalid tool version: {version}")
+
+    if exclude_tools is None:
+        return result
+
+    if "bash" in exclude_tools:
+        result = [x for x in result if x["name"] != "bash"]
+    if "editor" in exclude_tools:
+        result = [x for x in result if "edit" not in x["name"]]
+    if "computer" in exclude_tools:
+        result = [x for x in result if x["name"] != "computer"]
+
+    return result
+
+
+def bash_tool(model: str = "claude-4-sonnet") -> dict:
+    """
+    Get the bash tool definition for the given model.
+
+    The bash tool allows Claude to execute shell commands.
+
+    Note: Claude 3.5 requires the computer-use-2024-10-22 beta header.
+    The bash tool is generally available in Claude 4 and Sonnet 3.7.
+    """
+    version = model_to_version(model)
+
+    if version in ("2025-11-24", "2025-01-24"):
+        return {"type": "bash_20250124", "name": "bash"}
+    else:  # 2024-10-22
+        return {"type": "bash_20241022", "name": "bash"}
+
+
+def text_editor_tool(model: str = "claude-4-sonnet") -> dict:
+    """
+    Get the text editor tool definition for the given model.
+
+    The text editor tool allows Claude to view, create, and edit files.
+
+    Note:
+    - Claude 4 and Opus 4.5 use text_editor_20250728 with name "str_replace_based_edit_tool"
+      (no undo_edit command, has optional max_characters parameter)
+    - Claude Sonnet 3.7 uses text_editor_20250124 with name "str_replace_editor"
+      (includes undo_edit command)
+    - Claude 3.5/3.6 uses text_editor_20241022 with name "str_replace_editor"
+    """
+    version = model_to_version(model)
+
+    if version in ("2025-11-24", "2025-01-24"):
+        return {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}
+    else:  # 2024-10-22
+        return {"type": "text_editor_20241022", "name": "str_replace_editor"}
+
+
+def computer_tool(
+    model: str = "claude-4-sonnet",
+    display_width: int = 1024,
+    display_height: int = 768,
+    enable_zoom: bool = False,
+) -> dict:
+    """
+    Get the computer use tool definition for the given model.
+
+    The computer tool allows Claude to see and control desktop environments
+    through screenshots and mouse/keyboard actions.
+
+    Args:
+        model: The model name
+        display_width: Display width in pixels (recommended <= 1280)
+        display_height: Display height in pixels (recommended <= 800)
+        enable_zoom: Enable zoom action (Opus 4.5 only). When enabled, Claude can
+            use the zoom action to view specific screen regions at full resolution.
+
+    Available actions by version:
+    - All versions: screenshot, left_click, type, key, mouse_move
+    - computer_20250124+: scroll, left_click_drag, right_click, middle_click,
+      double_click, triple_click, left_mouse_down, left_mouse_up, hold_key, wait
+    - computer_20251124 (Opus 4.5): All above + zoom (requires enable_zoom=True)
+    """
+    version = model_to_version(model)
+
+    if version == "2025-11-24":
+        tool: dict = {
+            "name": "computer",
+            "type": "computer_20251124",
+            "display_width_px": display_width,
+            "display_height_px": display_height,
+            "display_number": None,
+        }
+        if enable_zoom:
+            tool["enable_zoom"] = True
+        return tool
+    elif version == "2025-01-24":
+        return {
+            "name": "computer",
+            "type": "computer_20250124",
+            "display_width_px": display_width,
+            "display_height_px": display_height,
+            "display_number": None,
+        }
+    else:  # 2024-10-22
+        return {
+            "name": "computer",
+            "type": "computer_20241022",
+            "display_width_px": display_width,
+            "display_height_px": display_height,
+            "display_number": None,
+        }
+
+
+def web_search_tool(
+    max_uses: int = 5,
+    allowed_domains: list[str] | None = None,
+    blocked_domains: list[str] | None = None,
+) -> dict:
+    """
+    Get the web search tool definition.
+
+    Args:
+        max_uses: Maximum number of searches per request (default: 5)
+        allowed_domains: Only include results from these domains
+        blocked_domains: Never include results from these domains
+
+    Note: You can use either allowed_domains or blocked_domains, but not both.
+    """
+    res: dict = {
+        "type": "web_search_20250305",
+        "name": "web_search",
+        "max_uses": max_uses,
+    }
+    if allowed_domains:
+        res["allowed_domains"] = allowed_domains
+    if blocked_domains:
+        res["blocked_domains"] = blocked_domains
+    return res
+
+
+def code_execution_tool() -> dict:
+    """
+    Get the code execution tool definition.
+
+    The code execution tool is currently in beta.
+    This feature requires the beta header: "anthropic-beta": "code-execution-2025-05-22"
+    """
+    return {"type": "code_execution_20250522", "name": "code_execution"}