drydock-cli 3.1.28__tar.gz → 3.1.29__tar.gz

{drydock_cli-3.1.28/drydock_cli.egg-info → drydock_cli-3.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.28
+Version: 3.1.29
 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.28 → drydock_cli-3.1.29}/drydock/capacity.py

@@ -6,14 +6,15 @@ agents just queue — more tokens, no more wall-clock. So "hammer the 8-GPU vLLM
 down the -np 2 laptop" reduces to: estimate the server's concurrency C, then size the swarm
 to min(C, task-demand, budget). This module estimates C.
 
-Detection order (first hit wins), all swallow-error / never-raise:
-  1. explicit — `config['swarm_concurrency']` or $DRYDOCK_SWARM_CONCURRENCY (the operator
-     knows their hardware; always the most reliable);
-  2. llama.cpp — GET /slots (its `-np` parallel slots);
-  3. empirical probe — fire a burst of tiny concurrent requests and infer parallelism from
-     wall-time vs single-request latency (server-agnostic; the honest signal for vLLM, whose
-     max_num_seqs isn't exposed over the OpenAI API);
-  4. fallback — a conservative default.
+Detection is FULLY AUTOMATIC — the user configures nothing. Order (first hit wins), all
+swallow-error / never-raise:
+  1. llama.cpp — GET /slots (its `-np` parallel slots), a free exact read;
+  2. empirical ramp probe — double a burst of tiny concurrent requests until the server
+     saturates (server-agnostic; the honest signal for vLLM, whose max_num_seqs isn't exposed
+     over the OpenAI API — an 8-GPU box reads big, a -np 2 laptop reads small, with no config);
+  3. fallback — a conservative default.
+An OPTIONAL escape hatch, checked first and needed by no one: `config['swarm_concurrency']`
+or $DRYDOCK_SWARM_CONCURRENCY, for an operator who wants to pin it or skip probing entirely.
 
 Stdlib-only; the probe funcs are injectable so this is testable without a live server.
 """
@@ -71,37 +72,66 @@ def _default_requester(base_url: str, model: str) -> Callable[[], None]:
     return req
 
 
-def probe_concurrency(base_url: str, model: str, *, burst: int = 16,
-                      requester: Callable[[], None] | None = None) -> int:
-    """Empirically estimate useful parallelism: one warm request costs t1; `burst` concurrent
-    requests finish in wall time W. Total work ≈ burst·t1 done in W ⇒ parallelism ≈ burst·t1/W
-    (≈burst if fully batched, ≈1 if serialized). Server-agnostic. Returns 1..burst."""
-    req = requester or _default_requester(base_url, model)
+_PROBE_CACHE: dict[str, int] = {}
+
+
+def clear_probe_cache() -> None:
+    """Forget cached probe results (mainly for tests / a changed server)."""
+    _PROBE_CACHE.clear()
+
+
+def _safe_call(req: Callable[[], None]) -> None:
     try:
-        t0 = time.monotonic()
         req()
-        t1 = time.monotonic() - t0
     except Exception:  # noqa: BLE001
-        return 1
-    if t1 <= 0:
-        return burst
+        pass
+
+
+def _burst_wall(req: Callable[[], None], b: int) -> float:
     start = time.monotonic()
     try:
-        with concurrent.futures.ThreadPoolExecutor(max_workers=burst) as ex:
-            list(ex.map(lambda _: _safe_call(req), range(burst)))
+        with concurrent.futures.ThreadPoolExecutor(max_workers=b) as ex:
+            list(ex.map(lambda _: _safe_call(req), range(b)))
     except Exception:  # noqa: BLE001
-        return 1
-    wall = time.monotonic() - start
-    if wall <= 0:
-        return burst
-    return max(1, min(burst, round(burst * t1 / wall)))
-
-
-def _safe_call(req: Callable[[], None]) -> None:
+        return -1.0
+    return time.monotonic() - start
+
+
+def probe_concurrency(base_url: str, model: str, *, max_probe: int = 64,
+                      requester: Callable[[], None] | None = None, cache: bool = True) -> int:
+    """Empirically estimate useful parallelism with ZERO configuration, by RAMPING the burst
+    until the server saturates — so an 8-GPU vLLM box is detected as big and a -np 2 laptop
+    as small, without anyone declaring anything.
+
+    One warm request costs t1; a burst of B concurrent requests finishes in wall W, so
+    parallelism P ≈ B·t1/W (≈B if fully batched, ≈1 if serialized). Ramp B = 4, 8, 16, …:
+    while the server keeps the whole burst parallel (P ≈ B) it can take more, so double B;
+    the first time it can't (P < B) is its ceiling. Cached per server (the probe costs a
+    handful of max_tokens=1 requests, run once)."""
+    if cache and base_url in _PROBE_CACHE:
+        return _PROBE_CACHE[base_url]
+    req = requester or _default_requester(base_url, model)
     try:
+        t0 = time.monotonic()
         req()
-    except Exception:  # noqa: BLE001
-        pass
+        t1 = time.monotonic() - t0
+    except Exception:  # noqa: BLE001 — server unreachable
+        return 1
+    if t1 <= 0:
+        result = max_probe
+    else:
+        best, burst = 1, 4
+        while burst <= max_probe:
+            wall = _burst_wall(req, burst)
+            p = burst if wall <= 0 else max(1, min(burst, round(burst * t1 / wall)))
+            best = max(best, p)
+            if p < burst * 0.75:          # couldn't keep the whole burst parallel → ceiling
+                break
+            burst *= 2
+        result = best
+    if cache:
+        _PROBE_CACHE[base_url] = result
+    return result
 
 
 def detect_concurrency(base_url: str, *, provider: str = "vllm", model: str = "",

{drydock_cli-3.1.28 → drydock_cli-3.1.29}/drydock/config.py

@@ -102,10 +102,11 @@ DEFAULTS: dict[str, object] = {
     # (docs/multi_agent_swarm_prd.md). On by default; set false to keep every request single-
     # agent unless the user runs /swarm explicitly.
     "swarm_auto_escalate": True,
-    # Swarm sizing: the harness caps agents at the inference server's real concurrency
-    # (drydock/capacity.py) — hammer an 8-GPU vLLM box, tone down a -np 2 laptop. Set
-    # swarm_concurrency to your server's parallel capacity to skip auto-detection (most
-    # reliable); 0 = auto-detect (llama.cpp /slots, else an empirical burst probe).
+    # Swarm sizing is FULLY AUTOMATIC: the harness detects the inference server's real
+    # concurrency (drydock/capacity.py — llama.cpp /slots, else an empirical ramp probe) and
+    # caps agents at it, so an 8-GPU vLLM box gets hammered and a -np 2 laptop toned down with
+    # NO configuration. swarm_concurrency is an optional pin (0 = auto-detect, the default);
+    # nobody needs to set it.
     "swarm_concurrency": 0,
     "swarm_concurrency_default": 4,
     # URL substrings the web tools refuse: WebSearch drops matching results,

{drydock_cli-3.1.28 → drydock_cli-3.1.29/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.28
+Version: 3.1.29
 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.28 → drydock_cli-3.1.29}/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.28"
+version = "3.1.29"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.1.28 → drydock_cli-3.1.29}/tests/test_capacity.py

@@ -59,20 +59,40 @@ def test_detect_order_slots_then_probe_then_default(monkeypatch):
     assert capacity.detect_concurrency("http://x/v1", model="", config={"swarm_concurrency_default": 9}) == 9
 
 
-def test_probe_detects_parallel_vs_serial():
-    # parallel server: burst finishes in ~one request's time → P near burst
+def test_probe_ramps_to_detect_a_big_parallel_server():
+    # a fully-batched server keeps every burst parallel → the ramp climbs past the old cap,
+    # so an 8-GPU vLLM box reads BIG with zero config
     def parallel_req():
-        time.sleep(0.03)
+        time.sleep(0.02)
 
-    p = capacity.probe_concurrency("http://x/v1", "m", burst=8, requester=parallel_req)
-    assert p >= 4  # detected substantial parallelism
+    p = capacity.probe_concurrency("http://big/v1", "m", max_probe=32,
+                                   requester=parallel_req, cache=False)
+    assert p >= 16
 
-    # serialized server: a lock forces one-at-a-time → P collapses toward 1
+
+def test_probe_detects_a_small_serial_server():
+    # a lock forces one-at-a-time → the ramp stops immediately at ~1 (auto tone-down)
     lock = threading.Lock()
 
     def serial_req():
         with lock:
-            time.sleep(0.03)
+            time.sleep(0.02)
+
+    s = capacity.probe_concurrency("http://small/v1", "m", max_probe=32,
+                                   requester=serial_req, cache=False)
+    assert s <= 3
+
+
+def test_probe_result_is_cached_per_server():
+    calls = {"n": 0}
+
+    def req():
+        calls["n"] += 1
+        time.sleep(0.005)
 
-    s = capacity.probe_concurrency("http://x/v1", "m", burst=8, requester=serial_req)
-    assert s <= 3  # detected near-serial
+    capacity.clear_probe_cache()
+    a = capacity.probe_concurrency("http://cache/v1", "m", max_probe=8, requester=req)
+    n_after_first = calls["n"]
+    assert n_after_first > 1                       # it actually probed (warm + bursts)
+    b = capacity.probe_concurrency("http://cache/v1", "m", max_probe=8, requester=req)
+    assert a == b and calls["n"] == n_after_first  # cached: no new requests