drydock-cli 3.0.46__tar.gz → 3.0.47__tar.gz

{drydock_cli-3.0.46/drydock_cli.egg-info → drydock_cli-3.0.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.46
+Version: 3.0.47
 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.46 → drydock_cli-3.0.47}/drydock/detect.py

@@ -63,7 +63,7 @@ def onboarding_message(found: list[dict]) -> str:
         return (
             "No local LLM detected (" + ports + "). Point Drydock at your model "
             "right here:\n"
-            "  /model url <http://host:port/v1>     then     /model <model-name>\n"
+            "  /model url <http://localhost:8000/v1>     then     /model <model-name>\n"
             "(saved to ~/.drydock/config.toml). Or start a local server "
             "(llama.cpp / vLLM / Ollama / LM Studio) and restart."
         )

{drydock_cli-3.0.46 → drydock_cli-3.0.47}/drydock/loop_detect.py

@@ -86,6 +86,49 @@ def path_thrash_note(path: str, count: int) -> str | None:
     )
 
 
+def runaway_repetition_len(
+    text: str,
+    *,
+    window: int = 2000,
+    min_run: int = 600,
+    max_unit: int = 80,
+    min_reps: int = 6,
+) -> int:
+    """Length (in chars) of a runaway repeated SUFFIX of *text*, else 0.
+
+    A weak local model sometimes collapses mid-generation into emitting the same
+    short unit hundreds of times (observed: gemma4 streamed ``295:`` ~1365× on
+    make-mips-interpreter). The tool-call loop guard never sees this — it's
+    streamed assistant TEXT, not a tool call — so the turn balloons unchecked.
+
+    This detects that one failure mode and nothing else. It is deliberately
+    CONSERVATIVE: it requires a long pure-repetition run (>= ``min_run`` chars
+    AND >= ``min_reps`` repeats of one <= ``max_unit``-char unit) so that
+    legitimate repetition — a ``---`` rule, a short bulleted list, an ASCII
+    table — never trips it. Pure-whitespace units (the blank line between
+    markdown blocks) are ignored. Returns the run length so the caller can trim
+    exactly the repeated tail; 0 means "looks fine, keep going".
+    """
+    if len(text) < min_run:
+        return 0
+    tail = text[-window:]
+    n = len(tail)
+    best = 0
+    for p in range(1, min(max_unit, n // min_reps) + 1):
+        unit = tail[-p:]
+        if not unit.strip():
+            continue  # ignore blank-line / whitespace units
+        reps = 0
+        i = n
+        while i - p >= 0 and tail[i - p:i] == unit:
+            reps += 1
+            i -= p
+        run = reps * p
+        if reps >= min_reps and run >= min_run:
+            best = max(best, run)
+    return best
+
+
 class LoopTracker:
     """Counts identical tool calls across a run and produces advisory notes."""
 

{drydock_cli-3.0.46 → drydock_cli-3.0.47}/drydock/providers.py

@@ -23,7 +23,8 @@ _LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_pre
 class _StopRequested(Exception):
     """Internal: STOP was pressed during a blocking LLM call."""
 
-from drydock.tuning import strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
+from drydock.loop_detect import runaway_repetition_len
+from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
 # ── Provider registry ─────────────────────────────────────────────────────
 
@@ -167,6 +168,14 @@ def _stream_chunks(response, cancel):
 class TextChunk:
     text: str
 
+@dataclass
+class ReasoningChunk:
+    """Thinking tokens emitted by the model before its answer (Gemma 4 only).
+    Yielded once per non-streaming turn, before any TextChunk, when the model
+    included a <|channel>…<channel|> block in its response.
+    """
+    text: str
+
 @dataclass
 class AssistantTurn:
     text: str
@@ -405,6 +414,11 @@ def stream(
     text = ""
     tool_buf: dict = {}  # index → {id, name, args}
     in_tok = out_tok = 0
+    # Runaway-repetition guard: a weak model can collapse into streaming one
+    # short unit hundreds of times (gemma4: `295:` ×1365). Advisory, never
+    # raises — on detection we trim the repeated tail, emit a note, and stop
+    # reading (the orphaned producer drains in the background, like STOP).
+    _rep_checked_at = 0
 
     try:
         response = _create_abortable(client, kwargs, base_url, provider, cancel, read_timeout)
@@ -432,6 +446,20 @@ def stream(
             if chunk_text:
                 text += chunk_text
                 yield TextChunk(chunk_text)
+                # Throttled: only scan once text is long enough and every ~200
+                # new chars, so the common path pays almost nothing.
+                if len(text) - _rep_checked_at >= 200:
+                    _rep_checked_at = len(text)
+                    run = runaway_repetition_len(text)
+                    if run:
+                        text = (
+                            text[: len(text) - run]
+                            + "\n[… output began repeating — stopped by drydock]"
+                        )
+                        yield TextChunk(
+                            "\n[stopped — model output began repeating itself]"
+                        )
+                        break
 
         if delta.tool_calls:
             for tc in delta.tool_calls:
@@ -479,10 +507,12 @@ def _complete_nonstreaming(
     msg = choice.message
 
     # Order matters: remove <|tool_call> blobs FIRST (sets had_leak for the
-    # retry nudge), THEN strip channel/special-token markers — otherwise the
-    # generic special-token pass would eat the tool_call markers.
+    # retry nudge), THEN extract+strip channel/special-token markers — otherwise
+    # the generic special-token pass would eat the tool_call markers.
     text, had_leak = strip_leaked_tool_calls(msg.content or "")
-    text = strip_thinking_tokens(text)
+    thinking, text = extract_thinking(text)
+    if thinking:
+        yield ReasoningChunk(thinking)
     if text.strip():
         yield TextChunk(text)
 

{drydock_cli-3.0.46 → drydock_cli-3.0.47}/drydock/tui/app.py

@@ -530,7 +530,7 @@ class DrydockApp(App):
         """Model + endpoint setup. Subcommands persist so they survive restart:
           /model                      show model, provider, endpoint
           /model <name>               set the model name
-          /model url <base_url>       set the server URL (e.g. http://host:8000/v1)
+          /model url <base_url>       set the server URL (e.g. http://localhost:8000/v1)
           /model provider <name>      vllm | ollama | lmstudio | openai
         """
         arg = (arg or "").strip()
@@ -541,7 +541,7 @@ class DrydockApp(App):
                 f"model:    {self.config.get('model')}\n"
                 f"provider: {prov}\n"
                 f"endpoint: {url}\n"
-                "Set up:  /model <name>  ·  /model url <http://host:port/v1>  ·  "
+                "Set up:  /model <name>  ·  /model url <http://localhost:8000/v1>  ·  "
                 "/model provider <vllm|ollama|lmstudio|openai>"
             )
             return
@@ -550,7 +550,7 @@ class DrydockApp(App):
         val = parts[1].strip() if len(parts) > 1 else ""
         if sub == "url":
             if not val:
-                self._info("usage: /model url <http://host:port/v1>")
+                self._info("usage: /model url <http://localhost:8000/v1>")
                 return
             self.config["base_url"] = val
             self._persist_config()

{drydock_cli-3.0.46 → drydock_cli-3.0.47}/drydock/tuning.py

@@ -121,6 +121,33 @@ def is_gemma(model: str | None) -> bool:
     return bool(model) and "gemma" in model.lower()
 
 
+def extract_thinking(text: str) -> tuple[str, str]:
+    """Return (thinking_content, cleaned_text).
+
+    Extracts the content of Gemma's <|channel>…<channel|> blocks so callers
+    can surface it in the UI, then strips the markers from the returned text.
+    Returns ("", text) when no thinking block is present.
+    """
+    if not text or "<|channel>" not in text:
+        return "", text
+    spans = _THINKING_RE.findall(text)
+    # Each match includes the delimiters — strip them to get bare thought text.
+    thoughts = []
+    for span in spans:
+        inner = span
+        if inner.startswith("<|channel>"):
+            inner = inner[len("<|channel>"):]
+        for closer in ("<channel|>", "<tool_call|>"):
+            if inner.endswith(closer):
+                inner = inner[: -len(closer)]
+                break
+        if inner.strip():
+            thoughts.append(inner.strip())
+    thinking = "\n\n".join(thoughts)
+    cleaned = strip_thinking_tokens(text)
+    return thinking, cleaned
+
+
 def strip_thinking_tokens(text: str) -> str:
     """Remove Gemma's leaked channel/thinking markers and stray special tokens.
 

{drydock_cli-3.0.46 → drydock_cli-3.0.47/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.46
+Version: 3.0.47
 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.46 → drydock_cli-3.0.47}/drydock_cli.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ tests/test_loop_detect.py
 tests/test_oneshot_unreachable.py
 tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py
+tests/test_runaway_repetition.py
 tests/test_stop.py
 tests/test_streaming_newlines.py
 tests/test_subagent.py

{drydock_cli-3.0.46 → drydock_cli-3.0.47}/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.46"
+version = "3.0.47"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.47/tests/test_runaway_repetition.py

@@ -0,0 +1,128 @@
+"""The streamed-text runaway-repetition guard (loop_detect.runaway_repetition_len).
+
+Detects the rare failure where a weak local model collapses into repeating one
+short unit hundreds of times (gemma4 emitted `295:` ~1365× on make-mips). Must
+fire on real collapses but NEVER on legitimate repeated content.
+"""
+from __future__ import annotations
+
+from drydock.loop_detect import runaway_repetition_len
+
+
+# ── fires on real collapses ────────────────────────────────────────────────
+
+def test_detects_repeated_line_collapse():
+    text = "Here is the output:\n" + "295:\n" * 1365
+    run = runaway_repetition_len(text)
+    assert run > 0
+    # The non-repeating prefix must survive a trim of exactly `run` chars.
+    assert text[: len(text) - run].startswith("Here is the output:")
+
+
+def test_detects_repeated_token_without_newlines():
+    text = "blah " + "ha" * 1000
+    assert runaway_repetition_len(text) > 0
+
+
+def test_detects_repeated_word_unit():
+    text = "intro\n" + "the same thing over and over " * 60
+    assert runaway_repetition_len(text) > 0
+
+
+# ── does NOT fire on legitimate content ────────────────────────────────────
+
+def test_short_repetition_is_fine():
+    # A handful of identical short lines is normal, not a collapse.
+    assert runaway_repetition_len("foo\n" * 10) == 0
+
+
+def test_horizontal_rule_is_fine():
+    text = "## Section\n" + "-" * 80 + "\nbody text here, perfectly normal."
+    assert runaway_repetition_len(text) == 0
+
+
+def test_normal_prose_is_fine():
+    text = (
+        "I fixed the bug by reordering the messages so a user turn never "
+        "follows a tool result. I added a regression test and ran the suite; "
+        "all 252 tests pass. Let me know if you want anything else.\n"
+    ) * 3
+    assert runaway_repetition_len(text) == 0
+
+
+def test_blank_lines_do_not_trip_it():
+    # Many blank lines (whitespace-only unit) must be ignored.
+    assert runaway_repetition_len("text\n" + "\n" * 500) == 0
+
+
+def test_empty_and_short_text():
+    assert runaway_repetition_len("") == 0
+    assert runaway_repetition_len("short") == 0
+
+
+def test_code_with_repeated_short_lines_is_fine():
+    # Real code often repeats short lines (e.g. closing braces); a dozen is fine.
+    text = "def f():\n" + "    pass\n" * 12
+    assert runaway_repetition_len(text) == 0
+
+
+# ── integration: the real stream() path trims + stops a collapse ────────────
+
+import drydock.providers as P  # noqa: E402
+from drydock.providers import AssistantTurn, TextChunk, stream  # noqa: E402
+
+
+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_stream_trims_and_stops_a_collapse(monkeypatch):
+    # A normal opener, then the model collapses into '295:\n' a thousand times.
+    chunks = [_Chunk("Here's the trace:\n")] + [_Chunk("295:\n") for _ in range(1000)]
+    monkeypatch.setattr(P, "_create_abortable", lambda *a, **k: iter(chunks))
+
+    full = ""
+    streamed = []
+    for ev in stream(
+        model="gemma4", system="s",
+        messages=[{"role": "user", "content": "go"}],
+        tool_schemas=[], config={"model": "gemma4", "provider": "vllm"},
+    ):
+        if isinstance(ev, TextChunk):
+            streamed.append(ev.text)
+        elif isinstance(ev, AssistantTurn):
+            full = ev.text
+
+    # Stored turn keeps the real prefix, is trimmed (NOT all 1000 reps), and
+    # carries the stop marker.
+    assert full.startswith("Here's the trace:")
+    assert "stopped by drydock" in full
+    assert full.count("295:") < 500           # the runaway tail was trimmed off
+    assert any("began repeating" in s for s in streamed)  # user saw the notice
+
+
+def test_stream_leaves_normal_output_untouched(monkeypatch):
+    chunks = [_Chunk("All "), _Chunk("done — "), _Chunk("tests pass.")]
+    monkeypatch.setattr(P, "_create_abortable", lambda *a, **k: iter(chunks))
+    full = ""
+    for ev in stream(model="gemma4", system="s",
+                     messages=[{"role": "user", "content": "go"}],
+                     tool_schemas=[], config={"model": "gemma4", "provider": "vllm"}):
+        if isinstance(ev, AssistantTurn):
+            full = ev.text
+    assert full == "All done — tests pass."
+    assert "stopped by drydock" not in full