drydock-cli 3.0.82__tar.gz → 3.0.84__tar.gz

{drydock_cli-3.0.82/drydock_cli.egg-info → drydock_cli-3.0.84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.82
+Version: 3.0.84
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -138,6 +138,46 @@ drydock-cli[pdf]` (pypdf). The index is a single JSON at
 Skills are markdown files in `~/.drydock/skills/` (personal) or
 `<project>/.drydock/skills/` (project); `/skills new` writes one for you.
 
+### Second-model advisor (a stronger model for a second opinion)
+
+Drydock's primary model is a small local one. You can wire in a **second,
+stronger model** — e.g. **Gemini** — to consult when the local model is stuck or
+you want to sanity-check a design. It's just another OpenAI-compatible endpoint,
+so there's **no extra dependency**; it's **opt-in** and off until you configure
+it (the only call is the one you point it at — consistent with the no-phone-home
+stance).
+
+**Configure it** (persists to `~/.drydock/config.toml`):
+```
+/advisor url    http://<other-box>:4000/v1     # any OpenAI-compatible endpoint
+/advisor model  gemini-2.5-pro
+/advisor key    <api-key>                       # if the endpoint needs one
+/advisor test                                   # ping it: reachable? which model? latency?
+/advisor                                         # show current config (key masked)
+```
+
+**Use it** two ways:
+- **You:** `/ask <question>` — consults the advisor and shows its answer.
+- **The agent:** it can call the read-only `Consult` tool on its own when it hits
+  something hard, passing the relevant code/error as context. You act on the advice.
+
+**Pointing it at Gemini** — two options:
+1. **Gemini's official OpenAI-compatible endpoint** (if this box has internet):
+   ```
+   /advisor url   https://generativelanguage.googleapis.com/v1beta/openai
+   /advisor model gemini-2.5-pro
+   /advisor key   <your-gemini-api-key>
+   ```
+2. **A proxy on another box** (e.g. where your key lives). LiteLLM is one line:
+   ```bash
+   pip install 'litellm[proxy]'; export GEMINI_API_KEY=...
+   litellm --model gemini/gemini-2.5-pro --host 0.0.0.0 --port 4000
+   ```
+   then `/advisor url http://<that-box-ip>:4000/v1`.
+
+Any OpenAI-compatible model works here (another local server, a hosted model,
+etc.) — Gemini is just the common case.
+
 ### RMF automation (NIST SP 800-53)
 
 For Risk Management Framework work, Drydock can ingest the NIST SP 800-53 Rev 5

{drydock_cli-3.0.82 → drydock_cli-3.0.84}/README.md

@@ -114,6 +114,46 @@ drydock-cli[pdf]` (pypdf). The index is a single JSON at
 Skills are markdown files in `~/.drydock/skills/` (personal) or
 `<project>/.drydock/skills/` (project); `/skills new` writes one for you.
 
+### Second-model advisor (a stronger model for a second opinion)
+
+Drydock's primary model is a small local one. You can wire in a **second,
+stronger model** — e.g. **Gemini** — to consult when the local model is stuck or
+you want to sanity-check a design. It's just another OpenAI-compatible endpoint,
+so there's **no extra dependency**; it's **opt-in** and off until you configure
+it (the only call is the one you point it at — consistent with the no-phone-home
+stance).
+
+**Configure it** (persists to `~/.drydock/config.toml`):
+```
+/advisor url    http://<other-box>:4000/v1     # any OpenAI-compatible endpoint
+/advisor model  gemini-2.5-pro
+/advisor key    <api-key>                       # if the endpoint needs one
+/advisor test                                   # ping it: reachable? which model? latency?
+/advisor                                         # show current config (key masked)
+```
+
+**Use it** two ways:
+- **You:** `/ask <question>` — consults the advisor and shows its answer.
+- **The agent:** it can call the read-only `Consult` tool on its own when it hits
+  something hard, passing the relevant code/error as context. You act on the advice.
+
+**Pointing it at Gemini** — two options:
+1. **Gemini's official OpenAI-compatible endpoint** (if this box has internet):
+   ```
+   /advisor url   https://generativelanguage.googleapis.com/v1beta/openai
+   /advisor model gemini-2.5-pro
+   /advisor key   <your-gemini-api-key>
+   ```
+2. **A proxy on another box** (e.g. where your key lives). LiteLLM is one line:
+   ```bash
+   pip install 'litellm[proxy]'; export GEMINI_API_KEY=...
+   litellm --model gemini/gemini-2.5-pro --host 0.0.0.0 --port 4000
+   ```
+   then `/advisor url http://<that-box-ip>:4000/v1`.
+
+Any OpenAI-compatible model works here (another local server, a hosted model,
+etc.) — Gemini is just the common case.
+
 ### RMF automation (NIST SP 800-53)
 
 For Risk Management Framework work, Drydock can ingest the NIST SP 800-53 Rev 5

{drydock_cli-3.0.82 → drydock_cli-3.0.84}/drydock/advisor.py

@@ -41,15 +41,10 @@ def not_configured_message() -> str:
     )
 
 
-def consult(question: str, config: dict, *, context: str = "", timeout: float = 120.0) -> str:
-    """Ask the configured advisor model and return its answer (or a clean error).
-    Never raises — a failed consult must not crash the turn."""
-    question = (question or "").strip()
-    if not question:
-        return "Error: nothing to ask the advisor."
-    if not is_configured(config):
-        return not_configured_message()
-
+def _call(question: str, config: dict, *, context: str = "",
+          timeout: float = 120.0, max_tokens: int = 2048) -> str:
+    """Make one advisor call. RAISES on transport/model error (callers decide how
+    to surface it)."""
     import httpx
     from openai import OpenAI
 
@@ -61,13 +56,53 @@ def consult(question: str, config: dict, *, context: str = "", timeout: float =
         messages.append({"role": "user",
                          "content": f"Context from the current task:\n{context.strip()}"})
     messages.append({"role": "user", "content": question})
-    kwargs = {"model": model, "messages": messages, "temperature": 0.3, "max_tokens": 2048}
+    kwargs = {"model": model, "messages": messages, "temperature": 0.3, "max_tokens": max_tokens}
+    client = OpenAI(api_key=key, base_url=base, max_retries=1,
+                    timeout=httpx.Timeout(timeout, connect=10.0))
+    resp = client.chat.completions.create(**kwargs)
+    return (resp.choices[0].message.content or "").strip()
+
+
+def consult(question: str, config: dict, *, context: str = "", timeout: float = 120.0) -> str:
+    """Ask the configured advisor model and return its answer (or a clean error).
+    Never raises — a failed consult must not crash the turn."""
+    question = (question or "").strip()
+    if not question:
+        return "Error: nothing to ask the advisor."
+    if not is_configured(config):
+        return not_configured_message()
     try:
-        client = OpenAI(api_key=key, base_url=base, max_retries=1,
-                        timeout=httpx.Timeout(timeout, connect=10.0))
-        resp = client.chat.completions.create(**kwargs)
-        answer = (resp.choices[0].message.content or "").strip()
-        return answer or "(the advisor model returned an empty response)"
+        return _call(question, config, context=context, timeout=timeout) \
+            or "(the advisor model returned an empty response)"
     except Exception as e:  # noqa: BLE001 — never crash the caller
-        return (f"Could not reach the advisor model ({model}) at {base}: {e}\n"
+        return (f"Could not reach the advisor model ({config.get('advisor_model')}) at "
+                f"{config.get('advisor_base_url')}: {e}\n"
                 "Check /advisor settings and that the endpoint is up.")
+
+
+def test_connection(config: dict) -> str:
+    """Ping the advisor endpoint with a trivial prompt and report reachability +
+    latency — one-shot setup confirmation for `/advisor test`."""
+    import time
+
+    if not is_configured(config):
+        return not_configured_message()
+    model = config.get("advisor_model")
+    base = config.get("advisor_base_url")
+    t0 = time.monotonic()
+    try:
+        # Generous read timeout: a slow/cold LOCAL model can take a while to
+        # return even a few tokens. A truly-down endpoint fails fast on the 10s
+        # connect timeout, so this only waits on a reachable-but-slow server.
+        reply = _call("Reply with exactly: OK", config, timeout=90.0, max_tokens=8)
+    except Exception as e:  # noqa: BLE001
+        emsg = str(e).lower()
+        if "timeout" in emsg or "timed out" in emsg:
+            return (f"✗ advisor timed out (>90s) — {model} at {base} is REACHABLE but slow "
+                    "to respond (a cold or loaded local model?). `/ask` allows much longer, "
+                    "so it may still work; or give the server a moment and retry.")
+        return (f"✗ advisor unreachable — {model} at {base}\n   {e}\n"
+                "   Check the endpoint is up, the URL ends in /v1, and the key/model are right.")
+    dt = time.monotonic() - t0
+    return (f"✓ advisor reachable — {model} at {base} responded in {dt:.1f}s"
+            + (f' (said: "{reply[:40]}").' if reply else "."))

{drydock_cli-3.0.82 → drydock_cli-3.0.84}/drydock/tui/app.py

@@ -864,17 +864,27 @@ class DrydockApp(App):
                 f"  endpoint: {u}\n"
                 f"  api key:  {has_key}\n"
                 "Set up:  /advisor url <base_url/v1>  ·  /advisor model <name>  ·  "
-                "/advisor key <api_key>\n"
+                "/advisor key <api_key>  ·  /advisor test\n"
                 "Then:  /ask <question>  (you)  or the agent calls the Consult tool."
             )
             return
         parts = arg.split(maxsplit=1)
         sub = parts[0].lower()
         val = parts[1].strip() if len(parts) > 1 else ""
+        if sub == "test":
+            from drydock import advisor
+            if not advisor.is_configured(self.config):
+                self._info(advisor.not_configured_message())
+                return
+            self._info(f"Testing the advisor endpoint ({self.config.get('advisor_base_url')})…")
+            self.run_worker(lambda: self.call_from_thread(
+                self._info, advisor.test_connection(self.config)), thread=True)
+            return
         keymap = {"url": "advisor_base_url", "endpoint": "advisor_base_url",
                   "model": "advisor_model", "key": "advisor_api_key", "api_key": "advisor_api_key"}
         if sub not in keymap or not val:
-            self._mount(ErrorMessage("usage: /advisor [url <base_url> | model <name> | key <api_key>]"))
+            self._mount(ErrorMessage(
+                "usage: /advisor [url <base_url> | model <name> | key <api_key> | test]"))
             return
         self.config[keymap[sub]] = val
         self._persist_config()

{drydock_cli-3.0.82 → drydock_cli-3.0.84/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.82
+Version: 3.0.84
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -138,6 +138,46 @@ drydock-cli[pdf]` (pypdf). The index is a single JSON at
 Skills are markdown files in `~/.drydock/skills/` (personal) or
 `<project>/.drydock/skills/` (project); `/skills new` writes one for you.
 
+### Second-model advisor (a stronger model for a second opinion)
+
+Drydock's primary model is a small local one. You can wire in a **second,
+stronger model** — e.g. **Gemini** — to consult when the local model is stuck or
+you want to sanity-check a design. It's just another OpenAI-compatible endpoint,
+so there's **no extra dependency**; it's **opt-in** and off until you configure
+it (the only call is the one you point it at — consistent with the no-phone-home
+stance).
+
+**Configure it** (persists to `~/.drydock/config.toml`):
+```
+/advisor url    http://<other-box>:4000/v1     # any OpenAI-compatible endpoint
+/advisor model  gemini-2.5-pro
+/advisor key    <api-key>                       # if the endpoint needs one
+/advisor test                                   # ping it: reachable? which model? latency?
+/advisor                                         # show current config (key masked)
+```
+
+**Use it** two ways:
+- **You:** `/ask <question>` — consults the advisor and shows its answer.
+- **The agent:** it can call the read-only `Consult` tool on its own when it hits
+  something hard, passing the relevant code/error as context. You act on the advice.
+
+**Pointing it at Gemini** — two options:
+1. **Gemini's official OpenAI-compatible endpoint** (if this box has internet):
+   ```
+   /advisor url   https://generativelanguage.googleapis.com/v1beta/openai
+   /advisor model gemini-2.5-pro
+   /advisor key   <your-gemini-api-key>
+   ```
+2. **A proxy on another box** (e.g. where your key lives). LiteLLM is one line:
+   ```bash
+   pip install 'litellm[proxy]'; export GEMINI_API_KEY=...
+   litellm --model gemini/gemini-2.5-pro --host 0.0.0.0 --port 4000
+   ```
+   then `/advisor url http://<that-box-ip>:4000/v1`.
+
+Any OpenAI-compatible model works here (another local server, a hosted model,
+etc.) — Gemini is just the common case.
+
 ### RMF automation (NIST SP 800-53)
 
 For Risk Management Framework work, Drydock can ingest the NIST SP 800-53 Rev 5

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

{drydock_cli-3.0.82 → drydock_cli-3.0.84}/tests/test_advisor.py

@@ -64,3 +64,27 @@ def test_consult_tool_unconfigured():
 
 def test_consult_tool_is_read_only():
     assert reg.get("Consult").read_only is True
+
+
+def test_test_connection_success(monkeypatch):
+    monkeypatch.setattr(advisor, "_call", lambda *a, **k: "OK")
+    out = advisor.test_connection({"advisor_base_url": "http://b/v1", "advisor_model": "m"})
+    assert out.startswith("✓") and "m" in out and "responded" in out
+
+
+def test_test_connection_failure(monkeypatch):
+    def boom(*a, **k): raise OSError("connection refused")
+    monkeypatch.setattr(advisor, "_call", boom)
+    out = advisor.test_connection({"advisor_base_url": "http://b/v1", "advisor_model": "m"})
+    assert out.startswith("✗") and "unreachable" in out and "connection refused" in out
+
+
+def test_test_connection_unconfigured():
+    assert "No advisor" in advisor.test_connection({})
+
+
+def test_test_connection_timeout_says_reachable_but_slow(monkeypatch):
+    def slow(*a, **k): raise TimeoutError("Request timed out.")
+    monkeypatch.setattr(advisor, "_call", slow)
+    out = advisor.test_connection({"advisor_base_url": "http://b/v1", "advisor_model": "m"})
+    assert out.startswith("✗") and "REACHABLE but slow" in out and "/ask" in out