drydock-cli 3.0.114__tar.gz → 3.0.115__tar.gz

{drydock_cli-3.0.114/drydock_cli.egg-info → drydock_cli-3.0.115}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.114
+Version: 3.0.115
 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.114 → drydock_cli-3.0.115}/drydock/agent.py

@@ -33,7 +33,7 @@ def _plan_has_unfinished(config: dict) -> bool:
     todo = config.get("_todo")
     return bool(todo) and any(status != "done" for _, status in todo)
 
-from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry, RepetitionDetected
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -194,24 +194,28 @@ def run(
                     elif isinstance(event, AssistantTurn):
                         assistant_turn = event
                 break  # success
-            except StallRetry:
-                # The call stalled or over-thought past stall_retry_secs. First
-                # retry re-issues as-is (handles a transient server hang cheaply);
-                # if it KEEPS happening it's over-thinking, so escalate to decisive
-                # mode — a forcing suffix + a hard token cap that make a long
-                # reasoning turn impossible. Bounded; on exhaustion end cleanly.
+            except StallRetry as _sr:
+                # Stalled/over-thought past stall_retry_secs (wall-time), OR collapsed
+                # into a pure-repetition loop (RepetitionDetected, content-based). A
+                # first wall-time retry re-issues as-is (a transient hang clears); a
+                # persistent stall OR any repetition loop goes straight to decisive
+                # mode — a forcing suffix + hard token cap that make a long reasoning
+                # turn impossible. Repetition escalates immediately (re-issuing a loop
+                # just loops again). Bounded; on exhaustion end cleanly.
+                is_rep = isinstance(_sr, RepetitionDetected)
                 stall_retries += 1
                 if stall_retries > 3:
-                    yield TextChunk("\n[model kept stalling/over-thinking — giving up on this step.]\n")
+                    yield TextChunk("\n[model kept stalling/looping — giving up on this step.]\n")
                     assistant_turn = None
                     break
-                if stall_retries >= 2 and not decisive:
+                if (is_rep or stall_retries >= 2) and not decisive:
                     decisive = True
                     turn_config = dict(turn_config)
                     cur = int(turn_config.get("max_tokens", 8192) or 8192)
                     turn_config["max_tokens"] = min(cur, _DECISIVE_MAX_TOKENS)
                     turn_config["reasoning_effort"] = "low"
-                    yield TextChunk("\n[taking too long — forcing a decisive, single-action step...]\n")
+                    why = "output looping" if is_rep else "taking too long"
+                    yield TextChunk(f"\n[{why} — forcing a decisive, single-action step...]\n")
                 else:
                     yield TextChunk("\n[model server stalled — retrying...]\n")
                 continue

{drydock_cli-3.0.114 → drydock_cli-3.0.115}/drydock/providers.py

@@ -30,6 +30,14 @@ class StallRetry(Exception):
     abandons the wedged request and re-issues it; a fresh generation usually
     doesn't stall. Opt-in via config `stall_retry_secs` (0 = off)."""
 
+
+class RepetitionDetected(StallRetry):
+    """CONTENT trigger for the over-think interrupt: the model collapsed into a
+    pure-repetition loop (same short unit ×6+, 600+ chars) and produced no usable
+    action. Unlike the wall-time StallRetry this fires on the *content*, so it
+    never trips on productive-but-long reasoning — only genuine spinning. A plain
+    re-issue would just loop again, so the agent goes straight to decisive mode."""
+
 from drydock.loop_detect import runaway_repetition_len
 from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
@@ -540,6 +548,11 @@ def stream(
                     _rep_checked_at = len(text)
                     run = runaway_repetition_len(text)
                     if run:
+                        # With the over-think interrupt on, a genuine loop escalates
+                        # to a decisive retry (recover) instead of returning a
+                        # truncated turn. Otherwise keep the advisory trim+stop.
+                        if stall_secs:
+                            raise RepetitionDetected(0)
                         text = (
                             text[: len(text) - run]
                             + "\n[… output began repeating — stopped by drydock]"
@@ -599,10 +612,6 @@ def _complete_nonstreaming(
     # the generic special-token pass would eat the tool_call markers.
     text, had_leak = strip_leaked_tool_calls(msg.content or "")
     thinking, text = extract_thinking(text)
-    if thinking:
-        yield ReasoningChunk(thinking)
-    if text.strip():
-        yield TextChunk(text)
 
     tool_calls = []
     for i, tc in enumerate(getattr(msg, "tool_calls", None) or []):
@@ -613,6 +622,21 @@ def _complete_nonstreaming(
             "input": inp,
         })
 
+    # Repetition trigger for the over-think interrupt (gated by the same
+    # stall_secs feature). Non-streaming gemma turns are where the over-think
+    # lives; if the turn collapsed into a pure loop and produced NO usable action,
+    # go decisive rather than feeding the garbage turn into the conversation. Only
+    # fires on genuine repetition, so productive-but-long reasoning is never hit.
+    if stall_secs and not tool_calls and (
+        runaway_repetition_len(thinking or "") or runaway_repetition_len(text or "")
+    ):
+        raise RepetitionDetected(0)
+
+    if thinking:
+        yield ReasoningChunk(thinking)
+    if text.strip():
+        yield TextChunk(text)
+
     usage = getattr(resp, "usage", None)
     in_tok = usage.prompt_tokens if usage else 0
     out_tok = usage.completion_tokens if usage else 0

{drydock_cli-3.0.114 → drydock_cli-3.0.115/drydock_cli.egg-info}/PKG-INFO

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

@@ -93,6 +93,7 @@ tests/test_plan_autocontinue.py
 tests/test_poam.py
 tests/test_providers_unreachable.py
 tests/test_read_index.py
+tests/test_repetition_interrupt.py
 tests/test_rmf.py
 tests/test_rmf_graph.py
 tests/test_rmf_stig_graph.py

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

drydock_cli-3.0.115/tests/test_repetition_interrupt.py

@@ -0,0 +1,68 @@
+"""Content-based repetition trigger for the over-think interrupt: a non-streaming
+turn that collapses into a pure loop AND produces no action escalates straight to
+decisive mode. It must NOT fire on varied reasoning, on a turn with a tool call,
+or when the interrupt is disabled (stall_secs=0)."""
+from __future__ import annotations
+
+import pytest
+
+from drydock import agent, providers
+from drydock.providers import AssistantTurn, RepetitionDetected, _complete_nonstreaming
+
+
+class _Fn:
+    def __init__(self, name, args): self.name = name; self.arguments = args
+class _TC:
+    def __init__(self, name, args): self.id = "c1"; self.function = _Fn(name, args)
+class _Msg:
+    def __init__(self, content, tcs=None): self.content = content; self.tool_calls = tcs or []
+class _Choice:
+    def __init__(self, msg): self.message = msg
+class _Resp:
+    def __init__(self, content, tcs=None): self.choices = [_Choice(_Msg(content, tcs))]; self.usage = None
+
+
+def _patch(monkeypatch, content, tcs=None):
+    monkeypatch.setattr(providers, "_create_abortable", lambda *a, **k: _Resp(content, tcs))
+
+
+def test_pure_loop_no_action_raises(monkeypatch):
+    _patch(monkeypatch, "loop " * 300)   # 1500 chars of one unit
+    with pytest.raises(RepetitionDetected):
+        list(_complete_nonstreaming(None, {}, stall_secs=300))
+
+
+def test_varied_reasoning_does_not_raise(monkeypatch):
+    _patch(monkeypatch, "First check the file, then run grep, then write the result and verify it.")
+    out = list(_complete_nonstreaming(None, {}, stall_secs=300))
+    assert any(isinstance(o, AssistantTurn) for o in out)  # completed normally
+
+
+def test_loop_but_has_toolcall_does_not_raise(monkeypatch):
+    _patch(monkeypatch, "loop " * 300, [_TC("Bash", '{"command":"ls"}')])
+    out = list(_complete_nonstreaming(None, {}, stall_secs=300))
+    turn = [o for o in out if isinstance(o, AssistantTurn)][0]
+    assert turn.tool_calls and turn.tool_calls[0]["name"] == "Bash"  # action preserved
+
+
+def test_disabled_when_stall_secs_zero(monkeypatch):
+    _patch(monkeypatch, "loop " * 300)
+    out = list(_complete_nonstreaming(None, {}, stall_secs=0))  # feature off
+    assert any(isinstance(o, AssistantTurn) for o in out)
+
+
+def test_agent_goes_decisive_immediately_on_repetition(monkeypatch):
+    calls = []
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append({"system": system, "max_tokens": config.get("max_tokens")})
+        if len(calls) == 1:
+            raise RepetitionDetected(0)
+        yield AssistantTurn("done", [], 10, 5)
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    st = agent.AgentState()
+    cfg = {"model": "gemma4", "max_tokens": 8192, "stall_retry_secs": 300, "context_limit": 65536}
+    list(agent.run("go", st, cfg, "SYS"))
+    # first call raised repetition → SECOND call is already decisive (no plain retry)
+    assert len(calls) == 2
+    assert agent._DECISIVE_SUFFIX in calls[1]["system"]
+    assert calls[1]["max_tokens"] <= agent._DECISIVE_MAX_TOKENS