drydock-cli 2.6.84__tar.gz → 2.6.85__tar.gz

drydock_cli-2.6.85/.auto_release.lock

@@ -0,0 +1 @@
+1429635

{drydock_cli-2.6.84 → drydock_cli-2.6.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.84
+Version: 2.6.85
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.6.84 → drydock_cli-2.6.85}/drydock/core/llm/backend/anthropic.py

@@ -65,10 +65,13 @@ class AnthropicMapper:
         return {"role": "assistant", "content": content if content else ""}
 
     def _convert_tool_call(self, tc: ToolCall) -> dict[str, Any]:
-        try:
-            tool_input = json.loads(tc.function.arguments or "{}")
-        except json.JSONDecodeError:
-            tool_input = {}
+        from drydock.core.llm.format import safe_parse_tool_args
+        tool_input = safe_parse_tool_args(
+            tc.function.arguments, tool_name=tc.function.name or "?"
+        )
+        # Strip the synthetic _parse_error key so Anthropic doesn't see it
+        # as a real tool input field.
+        tool_input.pop("_parse_error", None)
         return {
             "type": "tool_use",
             "id": self._sanitize_tool_call_id(tc.id),

{drydock_cli-2.6.84 → drydock_cli-2.6.85}/drydock/core/llm/format.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import json
+import logging
+import re as _re
 from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
@@ -18,6 +20,67 @@ if TYPE_CHECKING:
     from drydock.core.tools.manager import ToolManager
 
 
+_SAFE_PARSE_LOGGER = logging.getLogger(__name__)
+
+
+def safe_parse_tool_args(raw_json: str | None, tool_name: str = "?") -> dict[str, Any]:
+    """Parse a tool-call `arguments` JSON string with Gemma-4 leak/escape
+    sanitization fallback.
+
+    The model frequently leaks thinking-token markers INSIDE JSON string
+    values — `<|\\Fix`, `<|channel>thought<channel|>`, unpaired `<|...|>`.
+    Literal `\\F` (or any `\\X` not in `" \\ / b f n r t u`) is an invalid
+    JSON escape and aborts the stdlib decoder, destroying the whole tool
+    call. This helper:
+
+    1. Tries straight json.loads.
+    2. On failure, strips known leak patterns.
+    3. Escapes any remaining orphan backslashes.
+    4. Retries; if still bad, tries brace-balance fix.
+    5. As last resort, returns {"_parse_error": "..."} so the tool
+       validation can surface a clear error rather than an uncaught
+       JSONDecodeError.
+
+    Use this at every tool-arg json.loads site.
+    """
+    raw = (raw_json or "").strip()
+    if not raw:
+        return {}
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        pass
+
+    _SAFE_PARSE_LOGGER.warning(
+        "Malformed tool call JSON for %s: %s", tool_name, raw[:200]
+    )
+
+    sanitized = raw
+    sanitized = _re.sub(
+        r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)",
+        "", sanitized, flags=_re.DOTALL,
+    )
+    sanitized = _re.sub(
+        r"<\|tool_call\>.*?<tool_call\|>", "", sanitized, flags=_re.DOTALL,
+    )
+    sanitized = _re.sub(r"<\|[^>]{0,200}\|>", "", sanitized)
+    sanitized = _re.sub(r"<\|[^>]{0,200}>", "", sanitized)
+    sanitized = _re.sub(r"<[^>]{0,200}\|>", "", sanitized)
+    sanitized = _re.sub(r'\\(?!["\\/bfnrtu])', r"\\\\", sanitized)
+
+    try:
+        return json.loads(sanitized)
+    except json.JSONDecodeError:
+        pass
+    opens = sanitized.count("{") - sanitized.count("}")
+    if opens > 0:
+        try:
+            return json.loads(sanitized + "}" * opens)
+        except json.JSONDecodeError:
+            pass
+    return {"_parse_error": f"Malformed JSON: {raw[:100]}..."}
+
+
 class ParsedToolCall(BaseModel):
     model_config = ConfigDict(frozen=True)
     tool_name: str
@@ -161,55 +224,7 @@ class APIToolFormatHandler:
                 "Tool call %s: args_len=%d, first_100=%s",
                 function_call.name, len(raw_json), raw_json[:100]
             )
-            try:
-                args = json.loads(raw_json)
-            except json.JSONDecodeError:
-                # Gemma 4 frequently leaks thinking-token markers INSIDE
-                # JSON string values. Tokens like "<|\Fix" make `\F` an
-                # invalid JSON escape, which crashes the decoder and loses
-                # the whole tool call. Sanitize and retry before giving up.
-                import logging
-                import re as _re
-                logging.getLogger(__name__).warning(
-                    "Malformed tool call JSON for %s: %s",
-                    function_call.name,
-                    (function_call.arguments or "")[:200],
-                )
-                raw = (function_call.arguments or "").strip()
-                args = {}
-                if raw:
-                    sanitized = raw
-                    # Strip complete <|channel>...<channel|>/<tool_call|> blocks
-                    sanitized = _re.sub(
-                        r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)",
-                        "", sanitized, flags=_re.DOTALL,
-                    )
-                    sanitized = _re.sub(
-                        r"<\|tool_call\>.*?<tool_call\|>",
-                        "", sanitized, flags=_re.DOTALL,
-                    )
-                    # Strip unpaired/truncated <|...|> and <|...> tokens.
-                    sanitized = _re.sub(r"<\|[^>]{0,200}\|>", "", sanitized)
-                    sanitized = _re.sub(r"<\|[^>]{0,200}>", "", sanitized)
-                    sanitized = _re.sub(r"<[^>]{0,200}\|>", "", sanitized)
-                    # Escape any remaining invalid backslash escapes (JSON
-                    # only allows \" \\ \/ \b \f \n \r \t \u). Catches e.g.
-                    # `<|\Fix` residue where `\F` would abort the decoder.
-                    sanitized = _re.sub(
-                        r'\\(?!["\\/bfnrtu])', r'\\\\', sanitized,
-                    )
-                    try:
-                        args = json.loads(sanitized)
-                    except json.JSONDecodeError:
-                        # Last-ditch: try closing any unbalanced braces.
-                        opens = sanitized.count("{") - sanitized.count("}")
-                        if opens > 0:
-                            try:
-                                args = json.loads(sanitized + "}" * opens)
-                            except json.JSONDecodeError:
-                                args = {"_parse_error": f"Malformed JSON after sanitize: {sanitized[:100]}..."}
-                        else:
-                            args = {"_parse_error": f"Malformed JSON: {raw[:100]}..."}
+            args = safe_parse_tool_args(raw_json, tool_name=function_call.name)
 
             tool_calls.append(
                 ParsedToolCall(

{drydock_cli-2.6.84 → drydock_cli-2.6.85}/drydock/core/tools/builtins/search_replace.py

@@ -349,12 +349,20 @@ class SearchReplace(
                         f"Fix this before continuing."
                     )
 
+        # Terse success content (Claude Code pattern) — don't echo the
+        # SEARCH/REPLACE payload back. Model already has it in history;
+        # echoing wastes context and tempts re-reading. Warnings still go
+        # through so the model sees actionable issues.
         yield SearchReplaceResult(
             file=str(file_path),
             blocks_applied=block_result.applied,
             lines_changed=lines_changed,
             warnings=block_result.warnings,
-            content=args.content,
+            content=(
+                f"{file_path.name} edited successfully "
+                f"({block_result.applied} block(s), "
+                f"{lines_changed:+d} line(s))."
+            ),
         )
 
     @final

{drydock_cli-2.6.84 → drydock_cli-2.6.85}/drydock/core/tools/builtins/write_file.py

@@ -659,17 +659,23 @@ class WriteFile(
                 "limit": None,
             }
 
+        # Terse success message (Claude Code pattern). Do NOT echo
+        # args.content back — the model already has the content in its
+        # assistant-message history. Echoing wastes context AND gives the
+        # model an easy path to re-read what it just wrote instead of
+        # moving on (one of the oscillation triggers). If there's a
+        # warning/advisory, surface that INSTEAD of the content echo.
+        action = "updated" if file_existed else "created"
+        success_msg = (
+            f"File {file_path.name} {action} successfully ({content_bytes} bytes)."
+        )
         result = WriteFileResult(
             path=str(file_path),
             bytes_written=content_bytes,
             file_existed=file_existed,
-            content=args.content,
+            content=success_msg,
         )
         if syntax_warning or path_warning:
-            # Override content with diagnostics wrapped in a system-reminder
-            # so the model treats these with more weight than ordinary
-            # result text. Per Claude Code's read-tool empty-file warning
-            # pattern (<system-reminder> framing for high-signal advisories).
             combined = (syntax_warning or "") + (path_warning or "")
             result.content = (
                 f"<system-reminder>{combined}\n</system-reminder>"

{drydock_cli-2.6.84 → drydock_cli-2.6.85}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.6.84"
+version = "2.6.85"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-2.6.84/.auto_release.lock

@@ -1 +0,0 @@
-1428101