abstractcore 2.6.8__py3-none-any.whl → 2.9.0__py3-none-any.whl

abstractcore/providers/vllm_provider.py

@@ -59,7 +59,16 @@ class VLLMProvider(BaseProvider):
             self.client = httpx.Client(timeout=timeout_value)
         except Exception as e:
             try:
-                self.client = httpx.Client(timeout=300.0)
+                fallback_timeout = None
+                try:
+                    from ..config.manager import get_config_manager
+
+                    fallback_timeout = float(get_config_manager().get_default_timeout())
+                except Exception:
+                    fallback_timeout = 7200.0
+                if isinstance(fallback_timeout, (int, float)) and float(fallback_timeout) <= 0:
+                    fallback_timeout = None
+                self.client = httpx.Client(timeout=fallback_timeout)
             except Exception:
                 raise RuntimeError(f"Failed to create HTTP client for vLLM: {e}")
 
@@ -154,19 +163,24 @@ class VLLMProvider(BaseProvider):
         chat_messages = []
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
-        if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+        final_system_prompt = system_prompt
+        # Prefer native tools when the model supports them. Only inject a prompted tool list
+        # when native tool calling is not available.
+        if tools and self.tool_handler.supports_prompted and not self.tool_handler.supports_native:
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Add system message if provided
-        if enhanced_system_prompt:
+        if final_system_prompt:
             chat_messages.append({
                 "role": "system",
-                "content": enhanced_system_prompt
+                "content": final_system_prompt
             })
 
         # Add conversation history
@@ -222,6 +236,11 @@ class VLLMProvider(BaseProvider):
             "top_p": kwargs.get("top_p", 0.9),
         }
 
+        # Native tools (OpenAI-compatible): send structured tools/tool_choice when supported.
+        if tools and self.tool_handler.supports_native:
+            payload["tools"] = self.tool_handler.prepare_tools_for_native(tools)
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
+
         # Add additional generation parameters if provided
         if "frequency_penalty" in kwargs:
             payload["frequency_penalty"] = kwargs["frequency_penalty"]
@@ -283,8 +302,9 @@ class VLLMProvider(BaseProvider):
                 raise ProviderAPIError("HTTP client not initialized")
 
             start_time = time.time()
+            request_url = f"{self.base_url}/chat/completions"
             response = self.client.post(
-                f"{self.base_url}/chat/completions",
+                request_url,
                 json=payload,
                 headers=self._get_headers()
             )
@@ -296,10 +316,18 @@ class VLLMProvider(BaseProvider):
             # Extract response from OpenAI format
             if "choices" in result and len(result["choices"]) > 0:
                 choice = result["choices"][0]
-                content = choice.get("message", {}).get("content", "")
+                message = choice.get("message") or {}
+                if not isinstance(message, dict):
+                    message = {}
+
+                content = message.get("content", "")
+                tool_calls = message.get("tool_calls")
+                if tool_calls is None:
+                    tool_calls = choice.get("tool_calls")
                 finish_reason = choice.get("finish_reason", "stop")
             else:
                 content = "No response generated"
+                tool_calls = None
                 finish_reason = "error"
 
             # Extract usage info
@@ -310,6 +338,13 @@ class VLLMProvider(BaseProvider):
                 model=self.model,
                 finish_reason=finish_reason,
                 raw_response=result,
+                tool_calls=tool_calls if isinstance(tool_calls, list) else None,
+                metadata={
+                    "_provider_request": {
+                        "url": request_url,
+                        "payload": payload,
+                    }
+                },
                 usage={
                     "input_tokens": usage.get("prompt_tokens", 0),
                     "output_tokens": usage.get("completion_tokens", 0),
@@ -335,7 +370,7 @@ class VLLMProvider(BaseProvider):
                 except Exception:
                     raise ModelNotFoundError(f"Model '{self.model}' not found in vLLM and could not fetch available models")
             else:
-                raise ProviderAPIError(f"vLLM API error: {str(e)}")
+                raise
 
     def _stream_generate(self, payload: Dict[str, Any]) -> Iterator[GenerateResponse]:
         """Generate streaming response."""
@@ -366,13 +401,17 @@ class VLLMProvider(BaseProvider):
                                 if "choices" in chunk and len(chunk["choices"]) > 0:
                                     choice = chunk["choices"][0]
                                     delta = choice.get("delta", {})
+                                    if not isinstance(delta, dict):
+                                        delta = {}
                                     content = delta.get("content", "")
+                                    tool_calls = delta.get("tool_calls") or choice.get("tool_calls")
                                     finish_reason = choice.get("finish_reason")
 
                                     yield GenerateResponse(
                                         content=content,
                                         model=self.model,
                                         finish_reason=finish_reason,
+                                        tool_calls=tool_calls if isinstance(tool_calls, list) else None,
                                         raw_response=chunk
                                     )
 
@@ -408,16 +447,20 @@ class VLLMProvider(BaseProvider):
         # Build messages (same logic as sync)
         chat_messages = []
 
-        enhanced_system_prompt = system_prompt
-        if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+        final_system_prompt = system_prompt
+        # Prefer native tools when available; only inject prompted tool syntax as fallback.
+        if tools and self.tool_handler.supports_prompted and not self.tool_handler.supports_native:
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
-        if enhanced_system_prompt:
-            chat_messages.append({"role": "system", "content": enhanced_system_prompt})
+        if final_system_prompt:
+            chat_messages.append({"role": "system", "content": final_system_prompt})
 
         if messages:
             chat_messages.extend(messages)
@@ -469,6 +512,11 @@ class VLLMProvider(BaseProvider):
             "top_p": kwargs.get("top_p", 0.9),
         }
 
+        # Native tools (OpenAI-compatible): send structured tools/tool_choice when supported.
+        if tools and self.tool_handler.supports_native:
+            payload["tools"] = self.tool_handler.prepare_tools_for_native(tools)
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
+
         if "frequency_penalty" in kwargs:
             payload["frequency_penalty"] = kwargs["frequency_penalty"]
         if "presence_penalty" in kwargs:
@@ -700,7 +748,16 @@ class VLLMProvider(BaseProvider):
                 if hasattr(self, 'logger'):
                     self.logger.warning(f"Failed to update HTTP client timeout: {e}")
                 try:
-                    self.client = httpx.Client(timeout=300.0)
+                    fallback_timeout = None
+                    try:
+                        from ..config.manager import get_config_manager
+
+                        fallback_timeout = float(get_config_manager().get_default_timeout())
+                    except Exception:
+                        fallback_timeout = 7200.0
+                    if isinstance(fallback_timeout, (int, float)) and float(fallback_timeout) <= 0:
+                        fallback_timeout = None
+                    self.client = httpx.Client(timeout=fallback_timeout)
                 except Exception:
                     pass
 

abstractcore/server/app.py

@@ -517,6 +517,16 @@ class ChatCompletionRequest(BaseModel):
         example="http://localhost:1234/v1"
     )
 
+    # Runtime/orchestrator policy (AbstractCore-specific feature)
+    timeout_s: Optional[float] = Field(
+        default=None,
+        description="Per-request provider HTTP timeout in seconds (AbstractCore-specific feature). "
+                    "Intended for orchestrators (e.g. AbstractRuntime) to enforce execution policy. "
+                    "If omitted, the server uses its own defaults. "
+                    "Values <= 0 are treated as unlimited.",
+        example=7200.0,
+    )
+
     class Config:
         schema_extra = {
             "examples": {
@@ -2064,6 +2074,10 @@ async def process_chat_completion(
                 request_id=request_id,
                 base_url=request.base_url
             )
+        if request.timeout_s is not None:
+            # Orchestrator policy: allow the caller to specify the provider timeout.
+            # Note: BaseProvider treats non-positive values as "unlimited".
+            provider_kwargs["timeout"] = request.timeout_s
 
         llm = create_llm(provider, model=model, **provider_kwargs)
 
@@ -2214,31 +2228,49 @@ def generate_streaming_response(
                     }
                     yield f"data: {json.dumps(openai_chunk)}\n\n"
 
-            # Tool calls - always convert to OpenAI format for streaming
+            # Tool calls
             if hasattr(chunk, 'tool_calls') and chunk.tool_calls:
                 has_tool_calls = True
-                openai_tool_calls = syntax_rewriter.convert_to_openai_format(chunk.tool_calls)
-
-                for i, openai_tool_call in enumerate(openai_tool_calls):
-                    tool_chunk = {
-                        "id": chat_id,
-                        "object": "chat.completion.chunk",
-                        "created": created_time,
-                        "model": f"{provider}/{model}",
-                        "choices": [{
-                            "index": 0,
-                            "delta": {
-                                "tool_calls": [{
-                                    "index": i,  # Proper indexing for multiple tools
-                                    "id": openai_tool_call["id"],
-                                    "type": "function",
-                                    "function": openai_tool_call["function"]
-                                }]
-                            },
-                            "finish_reason": "tool_calls"  # Critical for Codex
-                        }]
-                    }
-                    yield f"data: {json.dumps(tool_chunk)}\n\n"
+                # OpenAI/Codex clients expect structured tool_calls deltas.
+                if syntax_rewriter.target_format in [SyntaxFormat.OPENAI, SyntaxFormat.CODEX]:
+                    openai_tool_calls = syntax_rewriter.convert_to_openai_format(chunk.tool_calls)
+
+                    for i, openai_tool_call in enumerate(openai_tool_calls):
+                        tool_chunk = {
+                            "id": chat_id,
+                            "object": "chat.completion.chunk",
+                            "created": created_time,
+                            "model": f"{provider}/{model}",
+                            "choices": [{
+                                "index": 0,
+                                "delta": {
+                                    "tool_calls": [{
+                                        "index": i,  # Proper indexing for multiple tools
+                                        "id": openai_tool_call["id"],
+                                        "type": "function",
+                                        "function": openai_tool_call["function"]
+                                    }]
+                                },
+                                "finish_reason": "tool_calls"  # Critical for Codex
+                            }]
+                        }
+                        yield f"data: {json.dumps(tool_chunk)}\n\n"
+                # Tag-based clients parse tool calls from assistant content.
+                elif syntax_rewriter.target_format != SyntaxFormat.PASSTHROUGH:
+                    tool_text = syntax_rewriter.rewrite_content("", detected_tool_calls=chunk.tool_calls)
+                    if tool_text and tool_text.strip():
+                        openai_chunk = {
+                            "id": chat_id,
+                            "object": "chat.completion.chunk",
+                            "created": created_time,
+                            "model": f"{provider}/{model}",
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"content": tool_text},
+                                "finish_reason": None
+                            }]
+                        }
+                        yield f"data: {json.dumps(openai_chunk)}\n\n"
 
         # Final chunk
         final_chunk = {
@@ -2319,6 +2351,7 @@ def convert_to_openai_response(
 
     # Apply syntax rewriting to content
     content = response.content if hasattr(response, 'content') else str(response)
+    tool_calls = getattr(response, "tool_calls", None) if hasattr(response, "tool_calls") else None
 
     # For OpenAI/Codex format: only clean if content contains tool calls
     # For other formats: apply syntax rewriting
@@ -2328,8 +2361,12 @@ def convert_to_openai_response(
         if any(pattern in content for pattern in ['<function_call>', '<tool_call>', '<|tool_call|>', '```tool_code']):
             content = syntax_rewriter.remove_tool_call_patterns(content)
     elif syntax_rewriter.target_format != SyntaxFormat.PASSTHROUGH:
-        # Apply format-specific rewriting for non-OpenAI formats
-        content = syntax_rewriter.rewrite_content(content)
+        # Apply format-specific rewriting for non-OpenAI formats.
+        # Prefer structured tool_calls when present (content may be cleaned upstream).
+        if tool_calls:
+            content = syntax_rewriter.rewrite_content(content, detected_tool_calls=tool_calls)
+        else:
+            content = syntax_rewriter.rewrite_content(content)
 
     response_dict = {
         "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
@@ -2349,15 +2386,15 @@ def convert_to_openai_response(
     }
 
     # Add tool calls if present
-    if hasattr(response, 'tool_calls') and response.tool_calls:
-        openai_tool_calls = syntax_rewriter.convert_to_openai_format(response.tool_calls)
+    if tool_calls:
+        openai_tool_calls = syntax_rewriter.convert_to_openai_format(tool_calls)
         response_dict["choices"][0]["message"]["tool_calls"] = openai_tool_calls
         response_dict["choices"][0]["finish_reason"] = "tool_calls"
 
         logger.info(
             "🔧 Tool calls converted",
             request_id=request_id,
-            tool_count=len(response.tool_calls),
+            tool_count=len(tool_calls),
             target_format=syntax_rewriter.target_format.value
         )
 

abstractcore/structured/retry.py

@@ -62,17 +62,20 @@ class FeedbackRetry(Retry):
 
     def should_retry(self, attempt: int, error: Exception) -> bool:
         """
-        Retry only for Pydantic ValidationErrors and within attempt limit.
+        Retry for structured-output errors that the model can often self-correct:
+        - Pydantic ValidationError (schema mismatch)
+        - JSONDecodeError (not valid JSON at all)
         """
-        return isinstance(error, ValidationError) and attempt < self.max_attempts
+        return isinstance(error, (ValidationError, json.JSONDecodeError)) and attempt < self.max_attempts
 
-    def prepare_retry_prompt(self, original_prompt: str, error: ValidationError, attempt: int) -> str:
+    def prepare_retry_prompt(self, original_prompt: str, error: Exception, attempt: int) -> str:
         """
         Create a retry prompt with validation error feedback.
         """
-        error_feedback = self._format_validation_errors(error)
+        if isinstance(error, ValidationError):
+            error_feedback = self._format_validation_errors(error)
 
-        retry_prompt = f"""{original_prompt}
+            retry_prompt = f"""{original_prompt}
 
 IMPORTANT: Your previous response (attempt {attempt}) had validation errors:
 
@@ -80,7 +83,17 @@ IMPORTANT: Your previous response (attempt {attempt}) had validation errors:
 
 Please correct these errors and provide a valid JSON response that matches the required schema exactly."""
 
-        return retry_prompt
+            return retry_prompt
+
+        # JSONDecodeError (or other JSON parsing issues): retry with a simpler instruction.
+        return f"""{original_prompt}
+
+IMPORTANT: Your previous response (attempt {attempt}) was not valid JSON:
+
+{error}
+
+Please respond again with a single valid JSON object that matches the required schema exactly.
+Return ONLY the JSON object, with no additional text or formatting."""
 
     def _format_validation_errors(self, error: ValidationError) -> str:
         """
@@ -113,4 +126,4 @@ Please correct these errors and provide a valid JSON response that matches the r
             else:
                 error_lines.append(f"• Field '{field_path}': {error_msg}")
 
-        return "\n".join(error_lines)
+        return "\n".join(error_lines)

abstractcore/tools/__init__.py

@@ -10,8 +10,9 @@ Tool Execution Modes
 AbstractCore supports two tool execution modes:
 
 **Passthrough Mode (Default)** - execute_tools=False
-    The LLM returns raw tool call tags that downstream runtimes
-    (AbstractRuntime, Codex, Claude Code) parse and execute.
+    AbstractCore detects/parses tool calls (native API fields or prompted tags)
+    and returns structured `GenerateResponse.tool_calls` plus cleaned `content`.
+    Downstream runtimes (AbstractRuntime, Codex, Claude Code) execute tools.
     Use case: Agent loops, custom orchestration, multi-step workflows.
 
 **Direct Execution Mode** - execute_tools=True
@@ -38,7 +39,7 @@ def get_weather(city: str) -> str:
 
 llm = create_llm("ollama", model="qwen3:4b")
 response = llm.generate("Weather in Paris?", tools=[get_weather])
-# response.content has tool call tags - parse with your runtime
+# response.tool_calls contains structured tool calls; response.content is cleaned
 ```
 
 Example: Direct Execution Mode
@@ -119,4 +120,4 @@ __all__ = [
     "execute_tool",
     "execute_tools",
     "clear_registry",
-]
+]

abstractcore/tools/abstractignore.py

@@ -0,0 +1,166 @@
+"""`.abstractignore` support for filesystem tools.
+
+This module provides a small, runtime-enforced ignore policy for AbstractCore
+filesystem tools (search/list/read/write/edit/analyze).
+
+Goals:
+- Avoid accidental scanning/editing of runtime artifacts (e.g. JsonFileRunStore
+  directories ending in `.d/`).
+- Allow users to define additional ignore rules via a `.abstractignore` file,
+  inspired by `.gitignore` (not full parity).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import fnmatch
+from typing import Iterable, List, Optional, Tuple
+
+
+_DEFAULT_IGNORE_LINES: List[str] = [
+    # VCS + caches
+    ".git/",
+    ".hg/",
+    ".svn/",
+    "__pycache__/",
+    ".pytest_cache/",
+    ".mypy_cache/",
+    ".ruff_cache/",
+    # Common build/env dirs
+    "node_modules/",
+    "dist/",
+    "build/",
+    ".venv/",
+    "venv/",
+    "env/",
+    ".env/",
+    # Editor/host artifacts
+    ".cursor/",
+    # AbstractFramework runtime stores (AbstractCode/Runtime file-backed stores)
+    "*.d/",
+]
+
+
+@dataclass(frozen=True)
+class AbstractIgnoreRule:
+    pattern: str
+    negate: bool = False
+    dir_only: bool = False
+    anchored: bool = False
+
+
+def _parse_rules(lines: Iterable[str]) -> List[AbstractIgnoreRule]:
+    rules: List[AbstractIgnoreRule] = []
+    for raw in lines:
+        line = str(raw or "").strip()
+        if not line or line.startswith("#"):
+            continue
+        negate = False
+        if line.startswith("!"):
+            negate = True
+            line = line[1:].strip()
+        if not line:
+            continue
+        dir_only = line.endswith("/")
+        if dir_only:
+            line = line[:-1].strip()
+        anchored = line.startswith("/")
+        if anchored:
+            line = line[1:].strip()
+        if not line:
+            continue
+        rules.append(AbstractIgnoreRule(pattern=line, negate=negate, dir_only=dir_only, anchored=anchored))
+    return rules
+
+
+def _find_nearest_abstractignore(start: Path) -> Optional[Path]:
+    """Find the nearest `.abstractignore` by walking upward from start."""
+    cur = start if start.is_dir() else start.parent
+    cur = cur.resolve()
+    for p in (cur, *cur.parents):
+        candidate = p / ".abstractignore"
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+class AbstractIgnore:
+    """A simple ignore matcher loaded from `.abstractignore` + defaults."""
+
+    def __init__(self, *, root: Path, rules: List[AbstractIgnoreRule], source: Optional[Path] = None):
+        self.root = root.resolve()
+        self.rules = list(rules)
+        self.source = source.resolve() if isinstance(source, Path) else None
+
+    @classmethod
+    def for_path(cls, path: Path) -> "AbstractIgnore":
+        """Create an ignore matcher for a given path (file or dir)."""
+        start = path if path.is_dir() else path.parent
+        ignore_file = _find_nearest_abstractignore(start)
+        root = ignore_file.parent if ignore_file is not None else start
+        file_rules: List[AbstractIgnoreRule] = []
+        if ignore_file is not None:
+            try:
+                file_rules = _parse_rules(ignore_file.read_text(encoding="utf-8").splitlines())
+            except Exception:
+                file_rules = []
+        # Defaults first; user file rules can override via negation.
+        rules = _parse_rules(_DEFAULT_IGNORE_LINES) + file_rules
+        return cls(root=root, rules=rules, source=ignore_file)
+
+    def _rel(self, path: Path) -> Tuple[str, List[str]]:
+        p = path.resolve()
+        try:
+            rel = p.relative_to(self.root)
+            rel_str = rel.as_posix()
+            parts = list(rel.parts)
+        except Exception:
+            # If the target is outside root, fall back to absolute matching.
+            rel_str = p.as_posix().lstrip("/")
+            parts = list(p.parts)
+        return rel_str, [str(x) for x in parts if str(x)]
+
+    def is_ignored(self, path: Path, *, is_dir: Optional[bool] = None) -> bool:
+        p = path.resolve()
+        if is_dir is None:
+            try:
+                is_dir = p.is_dir()
+            except Exception:
+                is_dir = False
+
+        rel_str, parts = self._rel(p)
+        name = parts[-1] if parts else p.name
+        dir_parts = parts if is_dir else parts[:-1]
+
+        ignored = False
+        for rule in self.rules:
+            pat = rule.pattern
+            if not pat:
+                continue
+
+            matched = False
+            if rule.dir_only:
+                # Match against any directory prefix.
+                for i in range(1, len(dir_parts) + 1):
+                    prefix = "/".join(dir_parts[:i])
+                    if fnmatch.fnmatchcase(prefix, pat) or fnmatch.fnmatchcase(dir_parts[i - 1], pat):
+                        matched = True
+                        break
+                if not matched and is_dir:
+                    matched = fnmatch.fnmatchcase(rel_str, pat) or fnmatch.fnmatchcase(name, pat)
+            else:
+                if rule.anchored or ("/" in pat):
+                    matched = fnmatch.fnmatchcase(rel_str, pat)
+                else:
+                    matched = fnmatch.fnmatchcase(name, pat)
+
+            if matched:
+                ignored = not rule.negate
+
+        return ignored
+
+
+__all__ = ["AbstractIgnore", "AbstractIgnoreRule"]
+
+

abstractcore/tools/arg_canonicalizer.py

@@ -0,0 +1,61 @@
+"""Tool argument canonicalization (aliases -> canonical).
+
+AbstractCore owns tool-call parsing/rewriting. This module provides a small,
+central place to normalize common argument-name drift that appears in LLM
+generated calls, while keeping the runtime/tool implementations stable.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from ..utils.jsonish import loads_dict_like
+
+
+def _loads_dict(value: Any) -> Optional[Dict[str, Any]]:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return dict(value)
+    if isinstance(value, str):
+        parsed = loads_dict_like(value)
+        return dict(parsed) if isinstance(parsed, dict) else None
+    return None
+
+
+def canonicalize_tool_arguments(tool_name: str, arguments: Any) -> Dict[str, Any]:
+    """Return a canonical argument dict for a tool call (best-effort)."""
+    name = str(tool_name or "").strip()
+    args = _loads_dict(arguments) or {}
+
+    if not name or not args:
+        return args
+
+    if name == "read_file":
+        return _canonicalize_read_file_args(args)
+
+    return args
+
+
+def _canonicalize_read_file_args(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    out = dict(arguments)
+
+    if "start_line" not in out:
+        if "start_line_one_indexed" in out:
+            out["start_line"] = out.get("start_line_one_indexed")
+        elif "start" in out:
+            out["start_line"] = out.get("start")
+
+    if "end_line" not in out:
+        if "end_line_one_indexed_inclusive" in out:
+            out["end_line"] = out.get("end_line_one_indexed_inclusive")
+        elif "end" in out:
+            out["end_line"] = out.get("end")
+
+    for k in ("start_line_one_indexed", "end_line_one_indexed_inclusive", "start", "end"):
+        out.pop(k, None)
+
+    return out
+
+
+__all__ = ["canonicalize_tool_arguments"]