drydock-cli 3.1.36__tar.gz → 3.1.37__tar.gz

{drydock_cli-3.1.36/drydock_cli.egg-info → drydock_cli-3.1.37}/PKG-INFO

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

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock/agent.py

@@ -47,6 +47,7 @@ from drydock.tools import register_all
 register_all()
 from drydock.compaction import (
     maybe_compact, emergency_compact, is_context_length_error, is_image_load_error,
+    is_text_only_model_error,
     extract_server_n_ctx,
 )
 from drydock.loop_detect import LoopTracker, degenerate_argument
@@ -409,6 +410,17 @@ def run(
                     if retries >= 2:
                         raise
                     yield TextChunk("\n[context limit hit — compacting and retrying...]\n")
+                elif is_text_only_model_error(err):
+                    # The model can't take images at all. Stop attaching them for this
+                    # endpoint and retry the step as text — a vision-less model can
+                    # still do the task (read the file with tools), it just can't SEE it.
+                    from drydock.providers import mark_text_only
+                    if not mark_text_only(config):
+                        raise
+                    yield TextChunk(
+                        "\n[This model is text-only — sending image references as plain "
+                        "text from now on and retrying...]\n"
+                    )
                 elif is_image_load_error(err):
                     # Corrupt/truncated/unsupported image the server couldn't decode —
                     # end the turn cleanly rather than dumping the raw 400.

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock/cli.py

@@ -507,6 +507,15 @@ def main():
     # the PRD" content fought the system prompt and risked turning a plain
     # greeting into a runaway build. The TUI reads this from config; CLI modes
     # call load_project_instructions directly (see run_interactive/run_oneshot).
+    # A context_limit above the server's real window overflows it mid-task and the
+    # ctx gauge lies. Unless the user pinned --context-limit, ask the server once and
+    # adopt its window when smaller (never grow past config). Best-effort, short timeout.
+    if not args.context_limit and config.get("base_url"):
+        from drydock.providers import probe_server_context
+        n_ctx = probe_server_context(config["base_url"], timeout=2.0)
+        if n_ctx and n_ctx < int(config.get("context_limit") or 65536):
+            config["context_limit"] = n_ctx
+
     config["project_instructions"] = load_project_instructions()
     # In a git project, drop a discoverable per-project prompt template at
     # <project>/.drydock/system_prompt.md (inert until edited). Then load the

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock/compaction.py

@@ -51,6 +51,19 @@ def extract_server_n_ctx(err: str) -> int | None:
     return None
 
 
+def is_text_only_model_error(err: str) -> bool:
+    """Whether a provider 400 says the MODEL can't take images at all (a text-only
+    model, e.g. vLLM "X is not a multimodal model", llama.cpp "image input is not
+    supported" when no --mmproj is loaded). Distinct from a bad image: the fix is to
+    drop attachments and retry, not to ask the user for a different file."""
+    e = (err or "").lower()
+    return (
+        "not a multimodal model" in e
+        or "image input is not supported" in e
+        or ("does not support" in e and ("image" in e or "multimodal" in e or "vision" in e))
+    )
+
+
 def is_image_load_error(err: str) -> bool:
     """Whether a provider 400 is the server failing to decode an attached image
     (corrupt / truncated / unsupported), so the agent ends the turn with a clean

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock/providers.py

@@ -39,7 +39,9 @@ class RepetitionDetected(StallRetry):
     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
+from drydock.tuning import (
+    extract_thinking, split_think_tags, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming,
+)
 
 # ── Provider registry ─────────────────────────────────────────────────────
 
@@ -430,6 +432,31 @@ def _image_url_block(path: str) -> dict | None:
     return {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{b64}"}}
 
 
+# (base_url, model) pairs whose server rejected image input as text-only. Process-wide
+# so every later request (and turn) sends plain text instead of re-hitting the 400.
+_TEXT_ONLY: set[tuple[str, str]] = set()
+
+
+def _vision_key(config: dict) -> tuple[str, str]:
+    prov = PROVIDERS.get(config.get("provider", "vllm"), PROVIDERS["vllm"])
+    base_url = config.get("base_url") or prov.get("base_url", "http://localhost:8000/v1")
+    return (str(base_url).rstrip("/"), str(config.get("model") or ""))
+
+
+def mark_text_only(config: dict) -> bool:
+    """Record that this endpoint's model can't take images. Returns True if newly marked."""
+    key = _vision_key(config)
+    if key in _TEXT_ONLY:
+        return False
+    _TEXT_ONLY.add(key)
+    return True
+
+
+def vision_enabled(config: dict) -> bool:
+    """False when vision is disabled in config or the server proved text-only."""
+    return config.get("vision", True) is not False and _vision_key(config) not in _TEXT_ONLY
+
+
 def _content_with_images(content):
     """Turn text that references on-disk image paths into a multimodal content
     list ([text, image_url…]); text without resolvable images passes through
@@ -451,15 +478,17 @@ def _content_with_images(content):
 _user_content_with_images = _content_with_images
 
 
-def messages_to_openai(messages: list, system: str) -> list:
-    """Convert neutral messages to OpenAI API format."""
+def messages_to_openai(messages: list, system: str, vision: bool = True) -> list:
+    """Convert neutral messages to OpenAI API format. vision=False sends image
+    references as plain text (text-only model)."""
     # value type is mixed (str content, multimodal list content, tool_calls list)
     result: list[dict] = [{"role": "system", "content": system}]
     for m in messages:
         role = m["role"]
         if role == "user":
             result.append({"role": "user",
-                           "content": _user_content_with_images(m["content"])})
+                           "content": (_user_content_with_images(m["content"])
+                                       if vision else m["content"])})
         elif role == "assistant":
             msg = {"role": "assistant", "content": m.get("content") or None}
             tcs = m.get("tool_calls", [])
@@ -482,7 +511,7 @@ def messages_to_openai(messages: list, system: str) -> list:
             # to look at — attach it so the model SEES it (servers read images
             # from tool messages too, verified). Only ViewImage, so an unrelated
             # tool mentioning a .png path never balloons the request.
-            if m.get("name") == "ViewImage" and isinstance(content, str):
+            if vision and m.get("name") == "ViewImage" and isinstance(content, str):
                 content = _content_with_images(content)
             result.append({
                 "role": "tool",
@@ -559,7 +588,7 @@ def stream(
     # dict(config) shallow-copy) so the TUI's STOP can reach this exact client.
     config.setdefault("_abort", {})["client"] = client
 
-    oai_messages = messages_to_openai(messages, system)
+    oai_messages = messages_to_openai(messages, system, vision=vision_enabled(config))
 
     has_tools = bool(tool_schemas)
     # Gemma (and any local server whose model name we can't trust) corrupts
@@ -647,6 +676,9 @@ def stream(
         if delta.content:
             # Strip any leaked thinking-token markers (best-effort per chunk).
             chunk_text = strip_thinking_tokens(delta.content)
+            # <think>/</think> tags usually arrive as whole tokens; keep them in the
+            # buffer (split off at the end) but don't display the bare markers.
+            shown = chunk_text.replace("<think>", "").replace("</think>", "")
             # 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
@@ -654,7 +686,8 @@ def stream(
             # skips chunks that stripping emptied (e.g. a lone thinking marker).
             if chunk_text:
                 text += chunk_text
-                yield TextChunk(chunk_text)
+                if shown:
+                    yield TextChunk(shown)
                 # 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:
@@ -705,6 +738,9 @@ def stream(
             "input": inp,
         })
 
+    # A template-opened <think> leaves "reasoning…</think>answer" in the content —
+    # keep only the answer in the recorded turn (it was already shown while streaming).
+    _, text = split_think_tags(text)
     yield AssistantTurn(text, tool_calls, in_tok, out_tok)
 
 

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock/tui/app.py

@@ -515,7 +515,7 @@ class DrydockApp(App):
         # actual attach happens at the API boundary in providers).
         from drydock import providers
         imgs = providers.detect_image_paths(text)
-        if imgs:
+        if imgs and providers.vision_enabled(self.config):
             import os as _os
             names = ", ".join(_os.path.basename(p) for p in imgs)
             self._info(f"📎 attached {len(imgs)} image(s) for the model to see: {names}")

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock/tuning.py

@@ -157,13 +157,31 @@ def is_gemma(model: str | None) -> bool:
     return bool(model) and "gemma" in model.lower()
 
 
+def split_think_tags(text: str) -> tuple[str, str]:
+    """Split <think>…</think> reasoning (Qwen/Nemotron/DeepSeek style) off the answer.
+
+    Chat templates often open <think> in the PROMPT, so the completion carries only
+    the closing tag: everything before the last </think> is reasoning. Returns
+    ("", text) when there is no closing tag."""
+    if not text or "</think>" not in text:
+        return "", text
+    thinking, answer = text.rsplit("</think>", 1)
+    thinking = thinking.replace("<think>", "").strip()
+    return thinking, answer.lstrip()
+
+
 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.
+    Extracts the content of Gemma's <|channel>…<channel|> blocks (or a
+    <think>…</think> span) 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 text and "</think>" in text:
+        thinking, answer = split_think_tags(text)
+        inner, answer = extract_thinking(answer)
+        return "\n\n".join(t for t in (thinking, inner) if t), answer
     if not text or "<|channel>" not in text:
         return "", text
     spans = _THINKING_RE.findall(text)

{drydock_cli-3.1.36 → drydock_cli-3.1.37/drydock_cli.egg-info}/PKG-INFO

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

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/drydock_cli.egg-info/SOURCES.txt

@@ -193,6 +193,7 @@ tests/test_suggest.py
 tests/test_swarm.py
 tests/test_system_prompt_help.py
 tests/test_task_state.py
+tests/test_text_only_model.py
 tests/test_timeline.py
 tests/test_todo.py
 tests/test_tool_arg_coercion.py

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

drydock_cli-3.1.37/tests/test_text_only_model.py

@@ -0,0 +1,78 @@
+"""Text-only model fallback: when the server rejects image input because the model
+isn't multimodal (vLLM "X is not a multimodal model", llama.cpp "image input is not
+supported"), the agent stops attaching images for that endpoint and retries the step
+as plain text instead of dead-ending the turn on a raw 400."""
+from __future__ import annotations
+
+from drydock import agent, providers
+from drydock.agent import AgentState
+from drydock.compaction import is_image_load_error, is_text_only_model_error
+from drydock.providers import AssistantTurn, messages_to_openai
+
+from tests.test_vision_input import _write_png
+
+VLLM_ERR = ("Error code: 400 - {'error': {'message': 'nemotron is not a multimodal model', "
+            "'type': 'BadRequestError', 'param': None, 'code': 400}}")
+LLAMA_ERR = ("Error code: 400 - {'error': {'code': 400, 'message': 'image input is not supported "
+             "- hint: if this is unexpected, you may need to provide the mmproj', "
+             "'type': 'invalid_request_error'}}")
+
+
+def test_classifies_text_only_errors():
+    assert is_text_only_model_error(VLLM_ERR)
+    assert is_text_only_model_error(LLAMA_ERR)
+    assert not is_text_only_model_error("Failed to load image or audio file")
+    assert not is_text_only_model_error("context_length_exceeded")
+    # a corrupt image is still an image-load error, not a text-only model
+    assert is_image_load_error("Failed to load image or audio file")
+
+
+def test_vision_false_keeps_image_reference_as_text(tmp_path):
+    p = _write_png(tmp_path / "board.png")
+    msgs = messages_to_openai([{"role": "user", "content": f"see {p}"}], "sys", vision=False)
+    assert msgs[1]["content"] == f"see {p}"
+    tool = messages_to_openai([{"role": "tool", "tool_call_id": "c", "name": "ViewImage",
+                                "content": f"viewing {p}"}], "sys", vision=False)
+    assert tool[1]["content"] == f"viewing {p}"
+
+
+def test_agent_drops_images_and_retries(monkeypatch, tmp_path):
+    p = _write_png(tmp_path / "board.png")
+    cfg = {"model": "textonly-test", "base_url": "http://tx.invalid:9/v1",
+           "max_tokens": 1024, "context_limit": 65536}
+    calls = []
+
+    def fake_stream(model, system, messages, tool_schemas, config):
+        vision = providers.vision_enabled(config)
+        calls.append(vision)
+        if vision:
+            raise RuntimeError(VLLM_ERR)
+        yield AssistantTurn(text="done", tool_calls=[], input_tokens=10, output_tokens=5)
+
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    monkeypatch.setattr(providers, "_TEXT_ONLY", set())
+    events = list(agent.run(f"what is in {p}", AgentState(), cfg, "SYS"))
+    assert calls == [True, False]
+    assert any("text-only" in getattr(e, "text", "") for e in events)
+    assert not providers.vision_enabled(cfg)
+    # a different endpoint is unaffected
+    assert providers.vision_enabled({**cfg, "base_url": "http://other.invalid:9/v1"})
+
+
+def test_second_text_only_error_raises_not_loops(monkeypatch):
+    cfg = {"model": "textonly-test2", "base_url": "http://tx2.invalid:9/v1",
+           "max_tokens": 1024, "context_limit": 65536}
+    calls = []
+
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append(1)
+        raise RuntimeError(VLLM_ERR)
+        yield  # pragma: no cover
+
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    monkeypatch.setattr(providers, "_TEXT_ONLY", set())
+    try:
+        list(agent.run("hi", AgentState(), cfg, "SYS"))
+    except RuntimeError:
+        pass
+    assert len(calls) == 2

{drydock_cli-3.1.36 → drydock_cli-3.1.37}/tests/test_tuning.py

@@ -150,3 +150,14 @@ def test_extract_thinking_noop_when_no_marker():
     thinking, text = extract_thinking(raw)
     assert thinking == ""
     assert text == raw
+
+
+def test_split_think_tags_template_opened():
+    from drydock.tuning import split_think_tags
+    assert split_think_tags("plan it\n</think>\n74 done") == ("plan it", "74 done")
+    assert split_think_tags("<think>x</think>ok") == ("x", "ok")
+    assert split_think_tags("no tags") == ("", "no tags")
+
+
+def test_extract_thinking_handles_think_tags():
+    assert extract_thinking("reason</think>answer") == ("reason", "answer")