drydock-cli 3.0.24__tar.gz → 3.0.26__tar.gz

{drydock_cli-3.0.24/drydock_cli.egg-info → drydock_cli-3.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.24
+Version: 3.0.26
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.24 → drydock_cli-3.0.26}/drydock/__init__.py

@@ -7,4 +7,4 @@ try:
     __version__ = _version("drydock-cli")
 except PackageNotFoundError:
     # Running from source before install (e.g. PYTHONPATH dev runs).
-    __version__ = "3.0.24"
+    __version__ = "3.0.26"

{drydock_cli-3.0.24 → drydock_cli-3.0.26}/drydock/providers.py

@@ -86,6 +86,33 @@ class AssistantTurn:
     had_leaked_call: bool = False  # model emitted a tool call as text, not a call
 
 
+# ── Tool-call argument parsing ────────────────────────────────────────────
+
+def _parse_tool_args(raw: str) -> dict:
+    """Parse a model's tool-call arguments tolerantly.
+
+    strict=False is the fix that matters: a Bash command built with a heredoc
+    (`cat <<EOF ...`) carries LITERAL newlines, which strict JSON rejects with
+    "Invalid control character". The call then degraded to {"_raw": ...} with no
+    usable args, Bash failed, and the model's corrections re-wrapped into nested
+    {"_raw": "{\"_raw\": ...}"} — a fatal loop. strict=False accepts control
+    chars inside strings (recovering the common multiline case); we also unwrap
+    a few layers of nested {"_raw": ...} the model may have echoed back.
+    """
+    if not raw:
+        return {}
+    for _ in range(4):  # peel nested _raw layers, then parse
+        try:
+            v = json.loads(raw, strict=False)
+        except (json.JSONDecodeError, TypeError):
+            return {"_raw": raw}
+        if isinstance(v, dict) and set(v) == {"_raw"} and isinstance(v["_raw"], str):
+            raw = v["_raw"]
+            continue
+        return v if isinstance(v, dict) else {"_raw": raw}
+    return {"_raw": raw}
+
+
 # ── Message format conversion ─────────────────────────────────────────────
 
 def messages_to_openai(messages: list, system: str) -> list:
@@ -226,7 +253,12 @@ def stream(
         if delta.content:
             # Strip any leaked thinking-token markers (best-effort per chunk).
             chunk_text = strip_thinking_tokens(delta.content)
-            if chunk_text.strip():
+            # Keep ANY non-empty chunk — including whitespace-only ones. A
+            # `.strip()` guard here used to DROP newline-only chunks (the blank
+            # line a model streams between markdown blocks arrives as its own
+            # chunk), mashing "para### Header" together. `if chunk_text:` still
+            # skips chunks that stripping emptied (e.g. a lone thinking marker).
+            if chunk_text:
                 text += chunk_text
                 yield TextChunk(chunk_text)
 
@@ -250,10 +282,7 @@ def stream(
     tool_calls = []
     for idx in sorted(tool_buf):
         v = tool_buf[idx]
-        try:
-            inp = json.loads(v["args"]) if v["args"] else {}
-        except json.JSONDecodeError:
-            inp = {"_raw": v["args"]}
+        inp = _parse_tool_args(v["args"])
         tool_calls.append({
             "id": v["id"] or f"call_{idx}",
             "name": v["name"],
@@ -283,11 +312,7 @@ def _complete_nonstreaming(
 
     tool_calls = []
     for i, tc in enumerate(getattr(msg, "tool_calls", None) or []):
-        raw_args = tc.function.arguments or ""
-        try:
-            inp = json.loads(raw_args) if raw_args else {}
-        except json.JSONDecodeError:
-            inp = {"_raw": raw_args}
+        inp = _parse_tool_args(tc.function.arguments or "")
         tool_calls.append({
             "id": tc.id or f"call_{i}",
             "name": tc.function.name,

{drydock_cli-3.0.24 → drydock_cli-3.0.26}/drydock/tools/__init__.py

@@ -428,7 +428,16 @@ def tool_edit(params: dict, config: dict) -> str:
 
 
 def tool_bash(params: dict, config: dict) -> str:
-    cmd = params["command"]
+    cmd = params.get("command")
+    if not cmd:
+        if "_raw" in params:
+            return (
+                "Error: your tool arguments were not valid JSON so the command "
+                "could not be read. Resend as ONE JSON object "
+                '{"command": "..."} with the whole command as a single string '
+                "(escape any newline as \\n; avoid raw line breaks in the JSON)."
+            )
+        return "Error: Bash needs a non-empty 'command'."
     timeout = params.get("timeout", 30)
     reason = bash_safety.dangerous_command(cmd)
     if reason is not None:

{drydock_cli-3.0.24 → drydock_cli-3.0.26/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.24
+Version: 3.0.26
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.24 → drydock_cli-3.0.26}/drydock_cli.egg-info/SOURCES.txt

@@ -42,8 +42,10 @@ tests/test_loop_detect.py
 tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py
 tests/test_stop.py
+tests/test_streaming_newlines.py
 tests/test_subagent.py
 tests/test_todo.py
+tests/test_tool_arg_parsing.py
 tests/test_tools_undo.py
 tests/test_tui.py
 tests/test_tuning.py

{drydock_cli-3.0.24 → drydock_cli-3.0.26}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.24"
+version = "3.0.26"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-3.0.26/tests/test_streaming_newlines.py

@@ -0,0 +1,70 @@
+"""Streaming must preserve whitespace-only (newline) chunks.
+
+A `.strip()` guard in the streaming loop used to DROP a chunk that was only
+"\n\n" — the blank line a model streams between markdown blocks — so a long
+response rendered as "paragraph### Header" mashed together (operator-reported).
+"""
+from __future__ import annotations
+
+import drydock.providers as P
+from drydock.providers import AssistantTurn, TextChunk, stream
+
+
+class _Delta:
+    def __init__(self, c):
+        self.content = c
+        self.tool_calls = None
+
+
+class _Choice:
+    def __init__(self, c):
+        self.delta = _Delta(c)
+        self.finish_reason = None
+
+
+class _Chunk:
+    def __init__(self, c):
+        self.choices = [_Choice(c)]
+        self.usage = None
+
+
+def test_streaming_preserves_newline_only_chunks(monkeypatch):
+    chunks = [
+        _Chunk("Intro paragraph."),
+        _Chunk("\n\n"),          # ← blank line between blocks (was dropped)
+        _Chunk("### Header"),
+        _Chunk("\n\n"),
+        _Chunk("body text"),
+    ]
+    monkeypatch.setattr(P, "_safe_create", lambda *a, **k: iter(chunks))
+
+    full = ""
+    streamed = []
+    for ev in stream(
+        model="gemma4", system="s",
+        messages=[{"role": "user", "content": "review"}],
+        tool_schemas=[],  # no tools → text-only → streaming path even for gemma
+        config={"model": "gemma4", "provider": "vllm"},
+    ):
+        if isinstance(ev, TextChunk):
+            streamed.append(ev.text)
+        elif isinstance(ev, AssistantTurn):
+            full = ev.text
+
+    assert "\n\n" in "".join(streamed)            # newline chunks survived streaming
+    assert "Intro paragraph.\n\n### Header" in full  # blocks not mashed
+    assert "### Header\n\nbody text" in full
+
+
+def test_streaming_still_drops_chunk_emptied_by_stripping(monkeypatch):
+    # A chunk that is ONLY a thinking marker strips to "" and is skipped (so we
+    # don't emit empty text), but real whitespace is kept.
+    chunks = [_Chunk("hello"), _Chunk("<|channel>x<channel|>"), _Chunk("\n"), _Chunk("world")]
+    monkeypatch.setattr(P, "_safe_create", lambda *a, **k: iter(chunks))
+    full = ""
+    for ev in stream(model="gemma4", system="s",
+                     messages=[{"role": "user", "content": "hi"}],
+                     tool_schemas=[], config={"model": "gemma4", "provider": "vllm"}):
+        if isinstance(ev, AssistantTurn):
+            full = ev.text
+    assert full == "hello\nworld"  # marker-only chunk gone, newline kept

drydock_cli-3.0.26/tests/test_tool_arg_parsing.py

@@ -0,0 +1,45 @@
+"""Tolerant parsing of a model's tool-call arguments.
+
+Gemma builds Bash commands with heredocs (`cat <<EOF ...`) whose arguments
+carry LITERAL newlines. Strict json.loads rejects those ("Invalid control
+character"), the call degraded to {"_raw": ...} with no `command`, Bash failed,
+and the model's retries nested {"_raw": "{\\"_raw\\": ...}"} into a fatal loop
+(seen live on crack-7z-hash). _parse_tool_args fixes both."""
+from __future__ import annotations
+
+import json
+
+from drydock.providers import _parse_tool_args
+from drydock.tools import tool_bash
+
+
+def test_heredoc_with_literal_newlines_recovers_command():
+    raw = '{"command": "cat <<EOF > p.txt\npassword\n123456\nEOF"}'
+    out = _parse_tool_args(raw)
+    assert out.get("command", "").startswith("cat <<EOF > p.txt")
+    assert "\n" in out["command"]  # newlines preserved
+
+
+def test_nested_raw_is_unwrapped():
+    triple = json.dumps({"_raw": json.dumps({"_raw": json.dumps({"command": "ls -la"})})})
+    assert _parse_tool_args(triple) == {"command": "ls -la"}
+
+
+def test_normal_and_empty_and_broken():
+    assert _parse_tool_args('{"command":"echo hi"}') == {"command": "echo hi"}
+    assert _parse_tool_args("") == {}
+    assert _parse_tool_args("{not json") == {"_raw": "{not json"}
+
+
+def test_bash_gives_recovery_hint_on_unparsed_args():
+    out = tool_bash({"_raw": "garbage"}, {})
+    assert "not valid JSON" in out and '{"command"' in out
+
+
+def test_bash_runs_recovered_heredoc(tmp_path):
+    # End-to-end: a heredoc command recovered by _parse_tool_args actually runs.
+    raw = ('{"command": "cat <<EOF > note.txt\nhello\nworld\nEOF"}')
+    params = _parse_tool_args(raw)
+    out = tool_bash(params, {"cwd": str(tmp_path)})
+    assert "Error" not in out
+    assert (tmp_path / "note.txt").read_text() == "hello\nworld\n"