drydock-cli 3.0.81__tar.gz → 3.0.83__tar.gz

{drydock_cli-3.0.81/drydock_cli.egg-info → drydock_cli-3.0.83}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.81
+Version: 3.0.83
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -72,6 +72,10 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
   read-only `Knowledge` tool.
 - **Multi-agent** — `Dispatch` runs several read-only sub-agents in parallel;
   `task` runs one — each in a fresh context, for focused investigation.
+- **Second-model advisor** — point `/advisor` at a stronger model on any
+  OpenAI-compatible endpoint (e.g. Gemini, or a proxy on another box); the agent
+  calls the `Consult` tool for a second opinion when stuck, and you can `/ask
+  <question>` directly. Opt-in, user-configured — no extra dependency.
 - **MCP** — connect to Model Context Protocol servers (`~/.drydock/mcp.json`);
   their tools appear as `mcp__<server>__<tool>`. List them with `/mcp`.
 - **Skills** — reusable `/<name>` commands authored as markdown in
@@ -103,6 +107,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/model` · `/cwd` | Show/set model & endpoint · working directory |
 | `/undo` · `/back` | Revert the last write · rewind the last turn |
 | `/compact` · `/context [n]` | Shrink context now · view/set the context-window budget |
+| `/advisor` · `/ask <q>` | Set up a 2nd 'advisor' model (Gemini etc.) · consult it |
 | `/status` · `/clear` · `/help` · `/quit` | Session stats · reset · help · exit |
 
 ### Knowledge base (GraphRAG) — ingesting your documents
@@ -133,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.81 → drydock_cli-3.0.83}/README.md

@@ -48,6 +48,10 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
   read-only `Knowledge` tool.
 - **Multi-agent** — `Dispatch` runs several read-only sub-agents in parallel;
   `task` runs one — each in a fresh context, for focused investigation.
+- **Second-model advisor** — point `/advisor` at a stronger model on any
+  OpenAI-compatible endpoint (e.g. Gemini, or a proxy on another box); the agent
+  calls the `Consult` tool for a second opinion when stuck, and you can `/ask
+  <question>` directly. Opt-in, user-configured — no extra dependency.
 - **MCP** — connect to Model Context Protocol servers (`~/.drydock/mcp.json`);
   their tools appear as `mcp__<server>__<tool>`. List them with `/mcp`.
 - **Skills** — reusable `/<name>` commands authored as markdown in
@@ -79,6 +83,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/model` · `/cwd` | Show/set model & endpoint · working directory |
 | `/undo` · `/back` | Revert the last write · rewind the last turn |
 | `/compact` · `/context [n]` | Shrink context now · view/set the context-window budget |
+| `/advisor` · `/ask <q>` | Set up a 2nd 'advisor' model (Gemini etc.) · consult it |
 | `/status` · `/clear` · `/help` · `/quit` | Session stats · reset · help · exit |
 
 ### Knowledge base (GraphRAG) — ingesting your documents
@@ -109,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.83/drydock/advisor.py

@@ -0,0 +1,100 @@
+"""Second-model "advisor" — consult a stronger model for a second opinion.
+
+Drydock's primary model is a small local one. Sometimes you want a heavier model
+(e.g. Gemini) to sanity-check a design, unstick a hard bug, or review an
+approach. The advisor is just ANOTHER OpenAI-compatible endpoint — Gemini exposes
+one (`.../v1beta/openai/`), and any proxy on another box works too — so this
+reuses the existing `openai` client with no new dependency.
+
+It's opt-in and user-configured (empty by default): the only network call is the
+one YOU point it at, consistent with drydock's no-phone-home stance. Exposed as
+the `Consult` tool (the agent asks when stuck) and the `/ask` command (you ask).
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+_ADVISOR_SYSTEM = (
+    "You are a senior engineering advisor consulted by another AI coding agent "
+    "(Drydock) running a smaller local model. Give concise, direct, expert advice "
+    "— the specific fix, the design trade-off, or the likely root cause. Prefer "
+    "concrete steps and short code over prose. If the question is under-specified, "
+    "state the key assumption and answer anyway. You cannot run tools; the calling "
+    "agent will act on your answer."
+)
+
+
+def is_configured(config: dict) -> bool:
+    """True when an advisor endpoint + model are set."""
+    return bool((config.get("advisor_base_url") or "").strip()
+                and (config.get("advisor_model") or "").strip())
+
+
+def not_configured_message() -> str:
+    return (
+        "No advisor (second) model is configured. Point it at any OpenAI-compatible "
+        "endpoint — e.g. Gemini's, or a proxy on another box:\n"
+        "  /advisor url  http://<other-box>:<port>/v1\n"
+        "  /advisor model  gemini-2.5-pro\n"
+        "  /advisor key  <api-key>            (if the endpoint needs one)\n"
+        "Then use  /ask <question>  or let the agent call the Consult tool."
+    )
+
+
+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
+
+    base = config["advisor_base_url"].strip()
+    model = config["advisor_model"].strip()
+    key = (config.get("advisor_api_key") or "").strip() or "dummy"
+    messages: list[dict] = [{"role": "system", "content": _ADVISOR_SYSTEM}]
+    if context.strip():
+        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": 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:
+        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 ({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:
+        reply = _call("Reply with exactly: OK", config, timeout=30.0, max_tokens=8)
+    except Exception as e:  # noqa: BLE001
+        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.81 → drydock_cli-3.0.83}/drydock/config.py

@@ -35,6 +35,13 @@ DEFAULTS: dict[str, object] = {
     # value. Default 65536 matches the bundled gemma4 server (-c 65536).
     "context_limit": 65536,
     "theme": "harbor",
+    # Optional SECOND model ("advisor") for a stronger second opinion — e.g. a
+    # Gemini OpenAI-compatible endpoint on another box. Empty = disabled. The
+    # agent can call the `Consult` tool and you can use `/ask`; configure with
+    # `/advisor`. It's just another OpenAI-compatible endpoint (no extra deps).
+    "advisor_model": "",
+    "advisor_base_url": "",
+    "advisor_api_key": "",
 }
 
 

{drydock_cli-3.0.81 → drydock_cli-3.0.83}/drydock/tools/__init__.py

@@ -178,6 +178,24 @@ SCHEMAS = [
             "required": ["tasks"],
         },
     },
+    {
+        "name": "Consult",
+        "description": (
+            "Ask a SECOND, more powerful advisor model (if the user configured "
+            "one, e.g. Gemini) for a second opinion — use when you're stuck, want "
+            "to sanity-check a design/approach, or need an expert take on a tricky "
+            "bug. It only advises (no tools); YOU act on the answer. Pass the "
+            "relevant code/error in `context` so the advisor has what it needs."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "question": {"type": "string", "description": "The specific question to ask the advisor."},
+                "context": {"type": "string", "description": "Relevant code, error output, or background the advisor needs."},
+            },
+            "required": ["question"],
+        },
+    },
     {
         "name": "task",
         "description": (
@@ -1066,6 +1084,16 @@ _SUBAGENT_SYSTEM = (
 )
 
 
+def tool_consult(params: dict, config: dict) -> str:
+    """Ask the configured second/advisor model (e.g. Gemini) for a second opinion."""
+    from drydock import advisor
+
+    question = (params.get("question") or params.get("prompt") or "").strip()
+    if not question:
+        return "Error: Consult needs a `question`."
+    return advisor.consult(question, config, context=params.get("context", "") or "")
+
+
 # A sub-agent's whole job is to keep its investigation OUT of the main agent's
 # context and hand back only a partition. The system prompt asks for a concise
 # summary, but a runaway model could still return a wall of text — so cap what
@@ -1474,7 +1502,7 @@ def register_all():
             "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
             "todo": tool_todo, "task": tool_task, "Dispatch": tool_dispatch,
-            "Knowledge": tool_knowledge,
+            "Consult": tool_consult, "Knowledge": tool_knowledge,
             "GraphQuery": tool_graphquery, "GraphAdd": tool_graphadd,
             "StigRules": tool_stigrules, "StigRule": tool_stigrule, "StigSet": tool_stigset,
             "WebSearch": tool_websearch, "WebFetch": tool_webfetch,
@@ -1484,8 +1512,8 @@ def register_all():
         # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
         # GitCommit + GraphAdd write).
         read_only = name in (
-            "Read", "ViewImage", "Glob", "Grep", "task", "Dispatch", "Knowledge",
-            "GraphQuery", "StigRules", "StigRule",
+            "Read", "ViewImage", "Glob", "Grep", "task", "Dispatch", "Consult",
+            "Knowledge", "GraphQuery", "StigRules", "StigRule",
             "WebSearch", "WebFetch", "GitStatus", "GitDiff", "GitLog",
         )
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))

{drydock_cli-3.0.81 → drydock_cli-3.0.83}/drydock/tui/app.py

@@ -487,6 +487,10 @@ class DrydockApp(App):
             self._cmd_compact()
         elif cmd == "/context":
             self._cmd_context(arg)
+        elif cmd == "/advisor":
+            self._cmd_advisor(arg)
+        elif cmd == "/ask":
+            self._cmd_ask(arg)
         elif cmd == "/graphrag":
             self._cmd_graphrag(arg)
         elif cmd == "/status":
@@ -509,6 +513,7 @@ class DrydockApp(App):
                 "  /status          session model, cwd, turns, tokens\n"
                 "  /compact         shrink old context to free up the window\n"
                 "  /context         view/set the context-window budget (e.g. /context 65536)\n"
+                "  /advisor         set up a 2nd 'advisor' model (e.g. Gemini) · /ask <q> to consult it\n"
                 "  /graphrag        ingest docs into a knowledge base the agent can use\n"
                 "                   build <path> · add <path> · query <q> · status · clear\n"
                 "  /skills          list skills · /skills new <name> <prompt> to create one\n"
@@ -843,6 +848,67 @@ class DrydockApp(App):
                    "so drydock's budget is the effective limit — no server-side cap.")
         self.call_from_thread(self._info, msg)
 
+    def _cmd_advisor(self, arg: str) -> None:
+        """View/set the optional second 'advisor' model (a stronger model, e.g.
+        Gemini, on any OpenAI-compatible endpoint). Persists to config.toml."""
+        arg = (arg or "").strip()
+        if not arg:
+            from drydock import advisor
+            m = self.config.get("advisor_model") or "(unset)"
+            u = self.config.get("advisor_base_url") or "(unset)"
+            has_key = "yes" if (self.config.get("advisor_api_key") or "").strip() else "no"
+            state = "configured ✓" if advisor.is_configured(self.config) else "not configured"
+            self._info(
+                f"advisor ({state}):\n"
+                f"  model:    {m}\n"
+                f"  endpoint: {u}\n"
+                f"  api key:  {has_key}\n"
+                "Set up:  /advisor url <base_url/v1>  ·  /advisor model <name>  ·  "
+                "/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> | test]"))
+            return
+        self.config[keymap[sub]] = val
+        self._persist_config()
+        shown = "•••••" if keymap[sub] == "advisor_api_key" else val
+        self._info(f"✓ advisor {sub} set to {shown} (saved to config.toml).")
+
+    def _cmd_ask(self, arg: str) -> None:
+        """Ask the second/advisor model directly and show its answer."""
+        from drydock import advisor
+        q = (arg or "").strip()
+        if not q:
+            self._info("usage: /ask <question>   — consult your configured advisor (second) model")
+            return
+        if not advisor.is_configured(self.config):
+            self._info(advisor.not_configured_message())
+            return
+        self._info(f"Asking the advisor ({self.config.get('advisor_model')})…")
+        self.run_worker(lambda: self._ask_worker(q), thread=True)
+
+    def _ask_worker(self, question: str) -> None:
+        from drydock import advisor
+        answer = advisor.consult(question, self.config)
+        self.call_from_thread(self._info, f"💡 advisor:\n{answer}")
+
     def _cmd_compact(self) -> None:
         """Manually compact the conversation to reclaim context NOW, without
         waiting for the automatic 60%-of-window threshold (agent.maybe_compact).

{drydock_cli-3.0.81 → drydock_cli-3.0.83}/drydock/tui/widgets.py

@@ -153,7 +153,8 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/context", "/graphrag", "/skills", "/loop", "/mcp", "/rmf", "/stig",
+    "/compact", "/context", "/advisor", "/ask", "/graphrag", "/skills", "/loop",
+    "/mcp", "/rmf", "/stig",
     "/clear", "/quit",
 ]
 

{drydock_cli-3.0.81 → drydock_cli-3.0.83}/drydock/tuning.py

@@ -236,6 +236,9 @@ _DRYDOCK_COMMANDS_HELP = (
     "- Images / vision: the user just references an image file path in their "
     "message (a .png/.jpg screenshot, mockup, or diagram on disk) and it is "
     "attached for you to SEE — no command needed.\n"
+    "- Second opinion: if the user set up an advisor model (`/advisor`), you can "
+    "call the `Consult` tool to ask a stronger model when you're stuck; the user "
+    "can also `/ask <question>` themselves.\n"
     "- Other: `/model` (model/endpoint), `/cwd`, `/undo` (revert last write), "
     "`/back` (rewind a turn), `/compact` (shrink context), `/context` (view/set "
     "the context-window budget), `/loop <n> <prompt>` (repeat a prompt), `/mcp` "

{drydock_cli-3.0.81 → drydock_cli-3.0.83/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.81
+Version: 3.0.83
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -72,6 +72,10 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
   read-only `Knowledge` tool.
 - **Multi-agent** — `Dispatch` runs several read-only sub-agents in parallel;
   `task` runs one — each in a fresh context, for focused investigation.
+- **Second-model advisor** — point `/advisor` at a stronger model on any
+  OpenAI-compatible endpoint (e.g. Gemini, or a proxy on another box); the agent
+  calls the `Consult` tool for a second opinion when stuck, and you can `/ask
+  <question>` directly. Opt-in, user-configured — no extra dependency.
 - **MCP** — connect to Model Context Protocol servers (`~/.drydock/mcp.json`);
   their tools appear as `mcp__<server>__<tool>`. List them with `/mcp`.
 - **Skills** — reusable `/<name>` commands authored as markdown in
@@ -103,6 +107,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/model` · `/cwd` | Show/set model & endpoint · working directory |
 | `/undo` · `/back` | Revert the last write · rewind the last turn |
 | `/compact` · `/context [n]` | Shrink context now · view/set the context-window budget |
+| `/advisor` · `/ask <q>` | Set up a 2nd 'advisor' model (Gemini etc.) · consult it |
 | `/status` · `/clear` · `/help` · `/quit` | Session stats · reset · help · exit |
 
 ### Knowledge base (GraphRAG) — ingesting your documents
@@ -133,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.81 → drydock_cli-3.0.83}/drydock_cli.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 pyproject.toml
 drydock/__init__.py
 drydock/__main__.py
+drydock/advisor.py
 drydock/agent.py
 drydock/bash_safety.py
 drydock/cci.py
@@ -45,6 +46,7 @@ drydock_cli.egg-info/dependency_links.txt
 drydock_cli.egg-info/entry_points.txt
 drydock_cli.egg-info/requires.txt
 drydock_cli.egg-info/top_level.txt
+tests/test_advisor.py
 tests/test_approval.py
 tests/test_back_command.py
 tests/test_bash_output_bounding.py

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

drydock_cli-3.0.83/tests/test_advisor.py

@@ -0,0 +1,83 @@
+"""Second-model advisor: consult() + the Consult tool + config."""
+from __future__ import annotations
+
+import drydock.tools  # noqa: F401 — registers tools
+from drydock import advisor
+from drydock import tool_registry as reg
+
+
+def test_is_configured():
+    assert not advisor.is_configured({})
+    assert not advisor.is_configured({"advisor_base_url": "http://x/v1"})   # no model
+    assert advisor.is_configured({"advisor_base_url": "http://x/v1", "advisor_model": "g"})
+
+
+def test_consult_unconfigured_gives_setup_help():
+    out = advisor.consult("anything", {})
+    assert "No advisor" in out and "/advisor" in out
+
+
+def test_consult_empty_question():
+    assert "nothing to ask" in advisor.consult("  ", {"advisor_base_url": "http://x/v1", "advisor_model": "g"})
+
+
+def test_consult_calls_endpoint_and_returns_answer(monkeypatch):
+    captured = {}
+
+    class _Msg:  # noqa: D401
+        content = "Use a mutex."
+
+    class _Choice:
+        message = _Msg()
+
+    class _Resp:
+        choices = [_Choice()]
+
+    class _FakeClient:
+        def __init__(self, **kw): captured["client"] = kw
+        class chat:  # noqa: N801
+            class completions:  # noqa: N801
+                @staticmethod
+                def create(**kw):
+                    captured["call"] = kw
+                    return _Resp()
+
+    monkeypatch.setattr(advisor, "OpenAI", _FakeClient, raising=False)
+    # advisor imports OpenAI lazily; patch the module symbol it will bind
+    import openai
+    monkeypatch.setattr(openai, "OpenAI", _FakeClient)
+    cfg = {"advisor_base_url": "http://box:9/v1", "advisor_model": "gemini-x", "advisor_api_key": "k"}
+    out = advisor.consult("How to fix this race?", cfg, context="def f(): ...")
+    assert out == "Use a mutex."
+    assert captured["client"]["base_url"] == "http://box:9/v1"
+    assert captured["call"]["model"] == "gemini-x"
+    # system + context + question all present
+    roles = [m["role"] for m in captured["call"]["messages"]]
+    assert roles == ["system", "user", "user"]
+
+
+def test_consult_tool_unconfigured():
+    out = reg.execute("Consult", {"question": "hi"}, {})
+    assert "No advisor" in out
+    assert "needs a `question`" in reg.execute("Consult", {}, {})
+
+
+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({})