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

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

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

@@ -19,7 +19,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
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -159,6 +159,7 @@ def run(
 
         # Stream from LLM — with retry on context-length 400 error
         retries = 0
+        stall_retries = 0
         while retries < 2:
             try:
                 available = schemas()
@@ -178,6 +179,19 @@ def run(
                     elif isinstance(event, AssistantTurn):
                         assistant_turn = event
                 break  # success
+            except StallRetry:
+                # The local server hung mid-generation (config stall_retry_secs).
+                # Re-issue the same request — a fresh generation usually isn't
+                # stalled. Bounded so a truly-dead server can't loop forever; on
+                # exhaustion end the turn cleanly. Stalls have their OWN budget,
+                # separate from the context-error `retries`.
+                stall_retries += 1
+                if stall_retries > 3:
+                    yield TextChunk("\n[model server kept stalling — giving up on this step.]\n")
+                    assistant_turn = None
+                    break
+                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.106}/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.106}/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.106}/drydock/tuning.py

@@ -91,6 +91,12 @@ _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"
     "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 +127,12 @@ _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"
     "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.106/drydock_cli.egg-info}/PKG-INFO

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

@@ -97,6 +97,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.106}/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.106"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.106/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