drydock-cli 3.0.105__tar.gz → 3.0.107__tar.gz

{drydock_cli-3.0.105/drydock_cli.egg-info → drydock_cli-3.0.107}/PKG-INFO

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

@@ -13,13 +13,27 @@ from typing import Generator
 # stall-loop while letting a long, productive plan run as far as it needs.
 PLAN_CONTINUE_CAP = 3
 
+# Over-think interrupt: when a call keeps stalling/over-thinking (repeated
+# StallRetry), re-issue in "decisive mode" — a forcing suffix + a hard token cap
+# so the model physically cannot burn thousands of reasoning tokens without
+# acting. The model that produced this loop (gemma) generates 5-15 min / 5k+
+# token "thinking" turns that stall_retry alone can't break (tokens flow); this
+# forces a short, single-action turn instead.
+_DECISIVE_MAX_TOKENS = 1500
+_DECISIVE_SUFFIX = (
+    "\n\nURGENT — you have spent too long reasoning without acting. STOP "
+    "analyzing. Your reply must be SHORT and take exactly ONE concrete action "
+    "right now: emit a single tool call (run a command or write a file) with "
+    "little or no explanation. Do NOT lay out a plan; act."
+)
+
 
 def _plan_has_unfinished(config: dict) -> bool:
     """True if the model laid out a `todo` plan that still has non-done items."""
     todo = config.get("_todo")
     return bool(todo) and any(status != "done" for _, status in todo)
 
-from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -159,6 +173,8 @@ def run(
 
         # Stream from LLM — with retry on context-length 400 error
         retries = 0
+        stall_retries = 0
+        decisive = False  # over-think interrupt: force a short, single-action turn
         while retries < 2:
             try:
                 available = schemas()
@@ -166,7 +182,7 @@ def run(
                     available = [s for s in available if s.get("name") in allow]
                 for event in stream(
                     model=turn_config["model"],
-                    system=system_prompt,
+                    system=(system_prompt + _DECISIVE_SUFFIX) if decisive else system_prompt,
                     messages=state.messages,
                     tool_schemas=filter_tool_schemas(available, turn_config.get("model")),
                     config=turn_config,
@@ -178,6 +194,27 @@ 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.
+                stall_retries += 1
+                if stall_retries > 3:
+                    yield TextChunk("\n[model kept stalling/over-thinking — giving up on this step.]\n")
+                    assistant_turn = None
+                    break
+                if 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")
+                else:
+                    yield TextChunk("\n[model server stalled — retrying...]\n")
+                continue
             except Exception as e:
                 err = str(e)
                 if is_context_length_error(err):

{drydock_cli-3.0.105 → drydock_cli-3.0.107}/drydock/config.py

@@ -34,6 +34,11 @@ DEFAULTS: dict[str, object] = {
     # real window BEFORE compacting (the server 400s) — set this to your -c
     # value. Default 65536 matches the bundled gemma4 server (-c 65536).
     "context_limit": 65536,
+    # Auto-retry a hung model call: if the server produces NOTHING for this many
+    # seconds, drydock abandons the wedged request and re-issues it (a fresh
+    # generation usually isn't stalled — a known gemma/llama.cpp hang). 0 = off.
+    # Set to e.g. 600 on a stall-prone local server. Bounded to a few retries.
+    "stall_retry_secs": 0,
     "theme": "harbor",
     # Optional SECOND model ("advisor") for a stronger second opinion — e.g. a
     # Gemini OpenAI-compatible endpoint on another box. Empty = disabled. The

{drydock_cli-3.0.105 → drydock_cli-3.0.107}/drydock/providers.py

@@ -23,6 +23,13 @@ _LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_pre
 class _StopRequested(Exception):
     """Internal: STOP was pressed during a blocking LLM call."""
 
+
+class StallRetry(Exception):
+    """The model server produced no progress for `stall_retry_secs` — the local
+    server has hung mid-generation (a known gemma/llama.cpp failure). The agent
+    abandons the wedged request and re-issues it; a fresh generation usually
+    doesn't stall. Opt-in via config `stall_retry_secs` (0 = off)."""
+
 from drydock.loop_detect import runaway_repetition_len
 from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
@@ -138,19 +145,26 @@ def _safe_create(client, kwargs: dict, base_url: str, provider: str, timeout_s:
 
 
 def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel,
-                      timeout_s: float = 600.0):
+                      timeout_s: float = 600.0, stall_secs: float = 0.0):
     """Like _safe_create, but runs off-thread and polls a cancel Event so STOP
     can abandon a blocked decode (raising _StopRequested). The orphaned request
-    runs to completion in the pool thread and its result is dropped."""
+    runs to completion in the pool thread and its result is dropped.
+
+    If stall_secs > 0 and the request produces nothing in that long, raise
+    StallRetry so the caller can abandon a hung server and re-issue."""
     import openai
+    import time as _time
 
     fut = _LLM_POOL.submit(client.chat.completions.create, **kwargs)
+    start = _time.monotonic()
     while True:
         try:
             return fut.result(timeout=0.2)
         except concurrent.futures.TimeoutError:
             if cancel is not None and cancel.is_set():
                 raise _StopRequested
+            if stall_secs and (_time.monotonic() - start) > stall_secs:
+                raise StallRetry(stall_secs)  # orphan the wedged request; caller retries
         # APITimeoutError subclasses APIConnectionError — catch it FIRST.
         except openai.APITimeoutError as e:
             raise LLMUnreachable(_friendly_timeout(base_url, timeout_s)) from e
@@ -158,12 +172,17 @@ def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel
             raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
 
 
-def _stream_chunks(response, cancel):
+def _stream_chunks(response, cancel, stall_secs: float = 0.0):
     """Yield streamed chunks, but pull them via a background thread + queue so a
     STOP can abandon a read that's blocked waiting for the first token (the
     thinking phase). On cancel we just stop reading; the orphaned producer
-    drains in the background."""
+    drains in the background.
+
+    If stall_secs > 0 and no chunk arrives for that long, raise StallRetry — a
+    hung server. (A slow-but-alive stream still emits chunks, which reset the
+    timer, so this fires only on a true stall.)"""
     import queue as _queue
+    import time as _time
 
     q: _queue.Queue = _queue.Queue()
     _DONE = object()
@@ -178,13 +197,17 @@ def _stream_chunks(response, cancel):
             q.put(_DONE)
 
     _LLM_POOL.submit(_produce)
+    last = _time.monotonic()
     while True:
         if cancel is not None and cancel.is_set():
             return
         try:
             item = q.get(timeout=0.2)
         except _queue.Empty:
+            if stall_secs and (_time.monotonic() - last) > stall_secs:
+                raise StallRetry(stall_secs)
             continue
+        last = _time.monotonic()
         if item is _DONE:
             return
         if isinstance(item, Exception):
@@ -410,6 +433,10 @@ def stream(
         read_timeout = float(config.get("request_timeout") or 1800.0)
     except (TypeError, ValueError):
         read_timeout = 1800.0
+    try:
+        stall_secs = float(config.get("stall_retry_secs") or 0)  # 0 = disabled
+    except (TypeError, ValueError):
+        stall_secs = 0.0
     client = OpenAI(
         api_key=api_key,
         base_url=base_url,
@@ -461,7 +488,7 @@ def stream(
         # streaming. If STOP closes the client mid-call the blocking request
         # raises — swallow that as a clean cancel rather than an error.
         try:
-            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel, read_timeout)
+            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel, read_timeout, stall_secs)
         except _StopRequested:
             return  # STOP — abandon the in-flight request, clean stop
         except Exception:
@@ -482,11 +509,11 @@ def stream(
     _rep_checked_at = 0
 
     try:
-        response = _create_abortable(client, kwargs, base_url, provider, cancel, read_timeout)
+        response = _create_abortable(client, kwargs, base_url, provider, cancel, read_timeout, stall_secs)
     except _StopRequested:
         config.get("_abort", {}).pop("client", None)
         return
-    for chunk in _stream_chunks(response, cancel):
+    for chunk in _stream_chunks(response, cancel, stall_secs):
         if not chunk.choices:
             if hasattr(chunk, "usage") and chunk.usage:
                 in_tok = chunk.usage.prompt_tokens or in_tok
@@ -557,13 +584,13 @@ def stream(
 
 def _complete_nonstreaming(
     client, kwargs: dict, base_url: str = "", provider: str = "", cancel=None,
-    timeout_s: float = 600.0,
+    timeout_s: float = 600.0, stall_secs: float = 0.0,
 ) -> Generator:
     """Single non-streaming completion. Yields one TextChunk (if any text)
     then the AssistantTurn. Used when streaming would corrupt tool-call JSON.
     Runs off-thread so STOP can abandon a blocked decode.
     """
-    resp = _create_abortable(client, kwargs, base_url, provider, cancel, timeout_s)
+    resp = _create_abortable(client, kwargs, base_url, provider, cancel, timeout_s, stall_secs)
     choice = resp.choices[0]
     msg = choice.message
 

{drydock_cli-3.0.105 → drydock_cli-3.0.107}/drydock/tuning.py

@@ -91,6 +91,16 @@ _DEFAULT_SYSTEM_PROMPT = (
     "NOT stop to ask whether to proceed. Call `todo` again to flip a step to "
     "done and the next to in-progress as you finish each, and only stop when "
     "every step is done. Don't write a TODO.md file for this.\n"
+    "Before you finish, RE-READ the task and confirm EVERY requirement is met — "
+    "exact filenames, paths, formats, and values matter, so check them literally. "
+    "If the task ships a test/eval/check script (eval.py, test.sh, a make target), "
+    "RUN it and fix failures until it passes before you stop. Prefer acting — write "
+    "files and run commands — over long planning; don't produce a big plan without "
+    "taking a concrete step.\n"
+    "A script you write must run with ONLY what is already installed — prefer "
+    "the standard library or shelling out to the task's own tools (openssl, git, "
+    "sqlite3); do NOT depend on a package you just pip-installed unless the task "
+    "explicitly says to (the grader runs in a clean environment).\n"
     "You have VISION: when the user references an image file path (.png/.jpg/"
     ".jpeg/.gif/.webp/.bmp on disk — a screenshot, mockup, diagram, or photo), it "
     "is attached and you can SEE it; you can also call the `ViewImage` tool to "
@@ -121,6 +131,16 @@ _GEMMA_SYSTEM_PROMPT = (
     "steps — do NOT stop to ask whether to proceed. Call `todo` again to update "
     "it as you finish each step, and only stop when every step is done. Do not "
     "write a TODO.md file for this.\n"
+    "Before you finish, RE-READ the task and confirm EVERY requirement is met — "
+    "exact filenames, paths, formats, and values matter, so check them literally. "
+    "If the task ships a test/eval/check script (eval.py, test.sh, a make target), "
+    "RUN it and fix failures until it passes before you stop. Prefer acting — write "
+    "files and run commands — over long planning; don't produce a big plan without "
+    "taking a concrete step.\n"
+    "A script you write must run with ONLY what is already installed — prefer "
+    "the standard library or shelling out to the task's own tools (openssl, git, "
+    "sqlite3); do NOT depend on a package you just pip-installed unless the task "
+    "explicitly says to (the grader runs in a clean environment).\n"
     "You have VISION: when the user's message references an image file path "
     "(.png/.jpg/.jpeg/.gif/.webp/.bmp that exists on disk — a screenshot, mockup, "
     "diagram, or photo), that image is attached and you can SEE it. You can also "

{drydock_cli-3.0.105 → drydock_cli-3.0.107/drydock_cli.egg-info}/PKG-INFO

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

@@ -87,6 +87,7 @@ tests/test_leaked_tool_call.py
 tests/test_loop_detect.py
 tests/test_mcp.py
 tests/test_oneshot_unreachable.py
+tests/test_overthink_interrupt.py
 tests/test_plan_autocontinue.py
 tests/test_poam.py
 tests/test_providers_unreachable.py
@@ -97,6 +98,7 @@ tests/test_rmf_stig_graph.py
 tests/test_runaway_repetition.py
 tests/test_server_probe.py
 tests/test_skills.py
+tests/test_stall_retry.py
 tests/test_stig.py
 tests/test_stop.py
 tests/test_streaming_newlines.py

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

drydock_cli-3.0.107/tests/test_overthink_interrupt.py

@@ -0,0 +1,47 @@
+"""Over-think interrupt: when a call keeps stalling/over-thinking (repeated
+StallRetry), the agent escalates to 'decisive mode' — a forcing suffix on the
+system prompt + a hard max_tokens cap — so the model can't burn a 5k-token
+reasoning turn without acting. First retry re-issues as-is; 2nd+ goes decisive."""
+from __future__ import annotations
+
+from drydock import agent
+from drydock.agent import AgentState, _DECISIVE_SUFFIX, _DECISIVE_MAX_TOKENS
+from drydock.providers import StallRetry, AssistantTurn
+
+
+def _drive(monkeypatch, stalls):
+    calls = []
+
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append({"system": system, "max_tokens": config.get("max_tokens"),
+                      "effort": config.get("reasoning_effort")})
+        if len(calls) <= stalls:
+            raise StallRetry(1)
+        yield AssistantTurn(text="done", tool_calls=[], input_tokens=10, output_tokens=5)
+
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    state = AgentState()
+    cfg = {"model": "gemma4", "max_tokens": 8192, "stall_retry_secs": 1, "context_limit": 65536}
+    list(agent.run("do it", state, cfg, "SYS"))
+    return calls
+
+
+def test_first_retry_not_decisive_second_is(monkeypatch):
+    calls = _drive(monkeypatch, stalls=2)   # stall twice, succeed on 3rd
+    assert len(calls) == 3
+    assert _DECISIVE_SUFFIX not in calls[0]["system"]      # attempt 1: as-is
+    assert _DECISIVE_SUFFIX not in calls[1]["system"]      # attempt 2 (retry 1): as-is
+    assert _DECISIVE_SUFFIX in calls[2]["system"]          # attempt 3 (retry 2): decisive
+    assert calls[2]["max_tokens"] <= _DECISIVE_MAX_TOKENS   # hard token cap
+    assert calls[2]["effort"] == "low"
+
+
+def test_gives_up_after_bounded_retries(monkeypatch):
+    # stalls forever → bounded (>3) → ends cleanly, doesn't loop forever
+    calls = _drive(monkeypatch, stalls=99)
+    assert len(calls) <= 5   # 1 initial + up to ~3 retries then give up
+
+
+def test_no_stall_no_decisive(monkeypatch):
+    calls = _drive(monkeypatch, stalls=0)   # succeeds first try
+    assert len(calls) == 1 and _DECISIVE_SUFFIX not in calls[0]["system"]

drydock_cli-3.0.107/tests/test_stall_retry.py

@@ -0,0 +1,53 @@
+"""Auto-retry on server stall (config stall_retry_secs, default 0=off): a hung
+model call (server produces nothing for stall_secs) raises StallRetry so the
+agent abandons the wedged request and re-issues it. Plus the self-verify /
+run-test-script / act prompt guidance."""
+from __future__ import annotations
+
+import time
+
+from drydock.providers import StallRetry, _create_abortable
+from drydock import config
+from drydock.tuning import system_prompt_for_model
+
+
+class _HangingClient:
+    class chat:
+        class completions:
+            @staticmethod
+            def create(**kw):
+                time.sleep(60)  # simulate a wedged server
+
+
+def test_stall_retry_raised_on_hang():
+    t0 = time.monotonic()
+    raised = False
+    try:
+        _create_abortable(_HangingClient(), {}, "url", "vllm", None,
+                          timeout_s=600, stall_secs=1)
+    except StallRetry:
+        raised = True
+    assert raised and (time.monotonic() - t0) < 4
+
+
+def test_stall_retry_disabled_by_default():
+    assert config.DEFAULTS.get("stall_retry_secs") == 0
+
+
+def test_no_stall_when_secs_zero_returns_quickly():
+    # stall_secs=0 → never raises StallRetry; a fast create returns normally
+    class Fast:
+        class chat:
+            class completions:
+                @staticmethod
+                def create(**kw):
+                    return "ok"
+    assert _create_abortable(Fast(), {}, "u", "vllm", None, stall_secs=0) == "ok"
+
+
+def test_prompts_have_verify_and_act_guidance():
+    for m in ("gemma4", "some-other-model"):
+        p = system_prompt_for_model(m)
+        assert "RE-READ the task" in p
+        assert "eval.py" in p and "test.sh" in p        # run-the-test-script
+        assert "Prefer acting" in p                      # act, don't over-plan