witbitz-code 1.7.0__tar.gz → 1.7.1__tar.gz

{witbitz_code-1.7.0/src/witbitz_code.egg-info → witbitz_code-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.0
+Version: 1.7.1
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.7.0"
+version = "1.7.1"
 description = "Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay."
 readme = "README.md"
 requires-python = ">=3.10"

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/src/witbitz_code/__init__.py

@@ -4,4 +4,4 @@ The Python implementation of tools/witbitz-code.mjs (docs/opencode-relay.md phas
 vectors and cross-implementation tests.
 """
 
-__version__ = "1.7.0"
+__version__ = "1.7.1"

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/src/witbitz_code/auto_runner.py

@@ -22,6 +22,7 @@ import asyncio
 import math
 import os
 import re
+import secrets
 import stat
 import time
 from collections.abc import Awaitable, Callable
@@ -42,6 +43,15 @@ MAX_USER_MESSAGES = 6
 MAX_DETAIL = 300
 PARENT_TTL_MS = 10 * 60_000
 AGENTS_TTL_MS = 60_000
+# THE REVIEWER'S MODEL (the owner, 2026-10-13: "I am not sure if the auto mode classifier is working correctly"). Reviewed as
+# an OpenCode session with the session's own model, a review carried OpenCode's whole agent prompt (~35k chars) ahead of ours
+# and the model's full reasoning: DeepSeek V4.1 Flash went from a 5 s median to 30 s timeouts, and every ask fell to the
+# person. Where the computer runs the model proxy (`model_url`), the policy is now asked DIRECTLY, of a fixed fast confidential
+# model, with a backup. Measured on 8 cases: GPT-OSS 120B 8/8 in 2.5–3.5 s, DeepSeek V4.1 Flash 8/8 in 5–16 s. Any failure is
+# still the person's. Held equal to tools/code-auto-runner.mjs.
+REVIEW_MODELS = ("openai/gpt-oss-120b", "deepseek/deepseek-v4.1-flash")
+REVIEW_TIMEOUT_MS = 45_000  # the whole review, backup included
+FIRST_TRY_MS = 20_000  # the first model's share, so a hung one leaves the backup time to answer
 MAX_DEPTH = 4  # parent links followed looking for the session in Auto
 REFUSAL_SUFFIX = "(Witbitz Auto mode refused this — try a narrower or safer step.)"
 _UNKNOWN = object()  # OpenCode could not say who a session's parent is (not cached)
@@ -107,11 +117,15 @@ def scratch_on_disk(paths: list[str], directory: str = SCRATCH_DIR) -> bool:
 
 class AutoRunner:
     def __init__(self, *, base: str, auth: Callable[[], dict], client: httpx.AsyncClient, state_path: Path | None,
-                 log_path: Path | None, poll_ms: float = 1000, review_timeout_ms: float = 30_000, home: str | None = None,
+                 log_path: Path | None, poll_ms: float = 1000, review_timeout_ms: float = REVIEW_TIMEOUT_MS, home: str | None = None,
                  on_verdict: Callable[[dict], Any] = lambda v: None, log: Callable[[str], Any] = lambda m: None,
                  now: Callable[[], int] = _now_ms, scratch_check: Callable[[list[str]], bool] = scratch_on_disk,
                  list_asks: Callable[[str], Awaitable[list | None]] | None = None,
-                 on_review: Callable[[str, bool], Any] | None = None) -> None:
+                 on_review: Callable[[str, bool], Any] | None = None, model_url: str = "",
+                 review_models: tuple[str, ...] | list[str] = REVIEW_MODELS, first_try_ms: float = FIRST_TRY_MS) -> None:
+        self._model_url = re.sub(r"/+\Z", "", model_url or "")
+        self._review_models = list(review_models)
+        self._first_try_ms = first_try_ms
         self._root = re.sub(r"/+\Z", "", base or "")
         # The review session's model calls are billed to the account that turned Auto on (payers.py): told when the
         # review opens and closes, since nothing from the Spaces app ever posts into it.
@@ -291,8 +305,60 @@ class AutoRunner:
             return []
         return allowed_folders(data.get("permission")) if ok and isinstance(data, dict) else []
 
+    async def _ask_model(self, m: str, prompt: dict, rid: str) -> tuple[dict | None, str]:
+        body = {"model": m, "messages": [{"role": "system", "content": prompt["system"]}, {"role": "user", "content": prompt["text"]}],
+                "max_tokens": 1500, "reasoning_effort": "low", "stream": False}
+        r = await self._client.post(f"{self._model_url}/chat/completions", headers={"content-type": "application/json", "x-session-id": rid},
+                                    content=_js.utf8(_js.stringify(body)))
+        try:
+            data = _js.parse(r.text)
+        except ValueError:
+            data = None
+        choices = data.get("choices") if isinstance(data, dict) and isinstance(data.get("choices"), list) else []
+        msg = choices[0].get("message") if choices and isinstance(choices[0], dict) and isinstance(choices[0].get("message"), dict) else {}
+        text = msg.get("content") if 200 <= r.status_code < 300 and isinstance(msg.get("content"), str) else ""
+        verdict = parse_verdict(text) if text else None
+        if verdict:
+            return verdict, ""
+        return None, f"answered {r.status_code}" if not 200 <= r.status_code < 300 else "no verdict in its answer" if text else "no answer"
+
+    async def _review_direct(self, prompt: dict) -> tuple[dict | None, str, str]:
+        """Ask the policy of the review models in turn, through the computer's model proxy (billed like the session: on_review)."""
+        rid = "ses_review_" + secrets.token_urlsafe(9)
+        until = time.monotonic() + self._review_timeout_ms / 1000
+        notes: list[str] = []
+        if self._on_review:
+            self._on_review(rid, True)
+        try:
+            for i, m in enumerate(self._review_models):
+                left = until - time.monotonic()
+                if left <= 0:
+                    break
+                limit = left if i == len(self._review_models) - 1 else min(left, self._first_try_ms / 1000)
+                try:
+                    verdict, why = await asyncio.wait_for(self._ask_model(m, prompt, rid), limit)
+                except asyncio.TimeoutError:
+                    verdict, why = None, "did not answer in time"
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    verdict, why = None, "could not be reached"
+                if verdict:
+                    return verdict, f"trustedrouter/{m}", ""
+                notes.append(f"{m}: {why}")
+        finally:
+            if self._on_review:
+                self._on_review(rid, False)
+        first = self._review_models[0] if self._review_models else ""
+        secs = math.floor(self._review_timeout_ms / 1000 + 0.5) or 1
+        return None, f"trustedrouter/{first}", f"the reviewer did not answer ({'; '.join(notes) or f'nothing within {secs} s'})"
+
     async def _review(self, req: dict, directory: str, owner: str | None = None, folders: list[str] | None = None) -> tuple[dict | None, str, str]:
         model, user_messages, tools = await self._session_context(owner or req["sessionID"], directory)
+        if self._model_url and self._review_models:
+            call = req.get("tool") if isinstance(req.get("tool"), dict) else {}
+            tool = tools.get(call["callID"], "") if isinstance(call.get("callID"), str) else ""
+            return await self._review_direct(reviewer_prompt(req, directory, user_messages, tool, folders or []))
         if not model:
             return None, "", "the session has no model to review with yet"
         label = f"{_js.js_string(model['providerID'])}/{_js.js_string(model['modelID'])}"

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/src/witbitz_code/cli.py

@@ -261,7 +261,8 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
             return 0
         if child is not None:
             _err("witbitz-code: model calls are paid by each account's own coding keys; confidential models are enforced (min_privacy + verified receipts)")
-        connector = await start_connector(pairings, payers=payers)
+        # Auto mode's reviewer asks the policy of the model proxy directly (auto_runner.REVIEW_MODELS), billed like the session.
+        connector = await start_connector(pairings, payers=payers, model_url=f"http://127.0.0.1:{proxy.port}/v1" if proxy else "")
         live["status"] = asyncio.ensure_future(_check_keys_every(live_keys, keys_http))
         live["connector"] = connector
         if live_out is not None:

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/src/witbitz_code/connector.py

@@ -157,7 +157,8 @@ class PairingServer:
                  max_response_bytes: int = MAX_RESPONSE, auto_dir: Path | None = None, auto_poll_ms: float = 1000,
                  attach_root: Path | None = None, attach_max_file_bytes: int = MAX_FILE_BYTES,
                  asks_reconcile_ms: float = ASKS_RECONCILE_MS, notes_root: str | None = None,
-                 notes_plugin_path: Path | None = None, payers: SessionPayers | None = None) -> None:
+                 notes_plugin_path: Path | None = None, payers: SessionPayers | None = None,
+                 model_url: str = "") -> None:
         self.pairing = pairing
         self._security: seccheck.SecurityCheck | None = None  # read on the first ask (seccheck.py)
         # WHO PAYS (payers.py): this pairing's account owns the turns it starts; the proxy bills each call to its owner.
@@ -212,7 +213,8 @@ class PairingServer:
         self.auto = AutoRunner(base=self.base, auth=self._auth, client=client, poll_ms=auto_poll_ms, log=log,
                                state_path=auto_dir / f"auto-{safe_id}.json", log_path=auto_dir / "auto-log.jsonl",
                                on_verdict=lambda v: self.peer.send({"t": "autoverdict", **v, "ts": int(time.time() * 1000)}),
-                               list_asks=self._pending_asks, on_review=self._own_review)
+                               list_asks=self._pending_asks, on_review=self._own_review,
+                               model_url=model_url)  # the reviewer asks the model proxy directly (auto_runner.REVIEW_MODELS)
 
     # ── lifecycle ─────────────────────────────────────────────────────────────────────────────────────────────────────
     async def start(self) -> None:
@@ -880,7 +882,8 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
                           max_response_bytes: int = MAX_RESPONSE, auto_dir: Path | None = None, auto_poll_ms: float = 1000,
                           attach_root: Path | None = None, attach_max_file_bytes: int = MAX_FILE_BYTES,
                           asks_reconcile_ms: float = ASKS_RECONCILE_MS, notes_root: str | None = None,
-                          notes_plugin_path: Path | None = None, payers: SessionPayers | None = None) -> Connector:
+                          notes_plugin_path: Path | None = None, payers: SessionPayers | None = None,
+                          model_url: str = "") -> Connector:
     """Serve the given pairings until stop()/aclose(). Options exist for tests: flush_ms, log, client, connect,
     request_timeout_ms, max_senders, max_response_bytes, auto_dir, auto_poll_ms."""
     client = client or local_client()
@@ -895,7 +898,7 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
         s = PairingServer(p, client=client, flush_ms=flush_ms, log=log, connect=connect, request_timeout_ms=request_timeout_ms,
                           max_senders=max_senders, max_response_bytes=max_response_bytes, auto_dir=auto_dir, auto_poll_ms=auto_poll_ms,
                           attach_root=attach_root, attach_max_file_bytes=attach_max_file_bytes, asks_reconcile_ms=asks_reconcile_ms,
-                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers)
+                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers, model_url=model_url)
         await s.start()
         servers.append(s)
     return Connector(servers, client, payers)

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/src/witbitz_code/uninstall.py

@@ -302,7 +302,7 @@ def remove_opencode_program(info: dict) -> dict:
     return {"ok": False, "why": f"{info['path']} is still there", "said": said} if os.path.exists(info["path"]) else {"ok": True, "said": said}
 
 
-WINDOWS_REINSTALL = "irm https://app.witbitz.chat/code.ps1 | iex"
+WINDOWS_REINSTALL = "the install lines at https://witbitz.chat/code (or Code in your Spaces app)"  # app-neutral: each app serves its own code.ps1
 
 
 def windows_installer_root() -> str:

{witbitz_code-1.7.0 → witbitz_code-1.7.1/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.0
+Version: 1.7.1
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/tests/test_auto.py

@@ -700,3 +700,114 @@ def test_auto_switches_on_for_a_network_share(tmp_path):
     async def body(oc, runner, verdicts, make, client):
         assert runner.set_auto("ses_main", _UNC, True)
     with_runner(tmp_path, body)
+
+
+# ── THE DIRECT REVIEWER (2026-10-13; = tools/code-auto-runner.test.mjs): with the computer's model proxy, the policy is asked
+#    of a fixed confidential model, then a backup — never through an OpenCode session.
+ALLOW = '{"decision":"allow","severity":10,"rule":"allow:tests","reason":"the user asked for tests"}'
+
+
+class FakeProxy:
+    def __init__(self, answers: dict) -> None:
+        self.seen: list[dict] = []
+        outer = self
+
+        class H(BaseHTTPRequestHandler):
+            def log_message(self, *a: Any) -> None:
+                pass
+
+            def do_POST(self) -> None:
+                b = json.loads(self.rfile.read(int(self.headers.get("content-length") or 0)))
+                outer.seen.append({"path": self.path, "sid": self.headers.get("x-session-id"), "body": b})
+                a = answers.get(b["model"], {"status": 404})
+                if a.get("delay"):
+                    time.sleep(a["delay"])
+                data = json.dumps({"choices": [{"message": {"role": "assistant", "content": a["text"]}}]} if "text" in a
+                                  else {"error": {"message": "provider error"}}).encode()
+                try:
+                    self.send_response(a.get("status", 200))
+                    self.send_header("content-type", "application/json")
+                    self.send_header("content-length", str(len(data)))
+                    self.end_headers()
+                    self.wfile.write(data)
+                except OSError:
+                    pass
+
+        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), H)
+        self.httpd.daemon_threads = True
+        threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
+        self.url = f"http://127.0.0.1:{self.httpd.server_address[1]}/v1"
+
+    def close(self) -> None:
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+
+def direct_world(tmp_path: Path, answers: dict, check, **extra: Any) -> None:
+    px = FakeProxy(answers)
+    oc = LoopOpenCode()
+    verdicts: list[dict] = []
+    billed: list = []
+
+    async def go():
+        async with httpx.AsyncClient(trust_env=False) as client:
+            runner = AutoRunner(base=oc.url, auth=lambda: {"authorization": "Basic x"}, client=client, state_path=tmp_path / "auto.json",
+                                log_path=tmp_path / "auto-log.jsonl", poll_ms=30, home="/home/u", on_verdict=verdicts.append,
+                                on_review=lambda rid, start: billed.append((rid, start)), model_url=px.url, **extra)
+            runner.start()
+            try:
+                runner.set_auto("ses_main", DIR, True)
+                oc.ask(permission="bash", patterns=["npm test"], metadata={"command": "npm test"})
+                await check(oc, px, verdicts, billed)
+            finally:
+                runner.stop()
+
+    try:
+        run(go(), timeout=60)
+    finally:
+        oc.close()
+        px.close()
+
+
+def test_direct_gpt_oss_is_asked_directly_no_opencode_session_low_effort_billed_like_the_session(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: oc.replies(), 6)
+        assert oc.replies()[0]["body"] == {"reply": "once"}
+        assert oc.calls("POST", "/session") == [], "no review session"
+        c = px.seen[0]
+        assert c["path"] == "/v1/chat/completions"
+        assert (c["body"]["model"], c["body"]["reasoning_effort"], c["body"]["stream"]) == ("openai/gpt-oss-120b", "low", False)
+        assert "HARD DENY" in c["body"]["messages"][0]["content"]
+        assert "npm test" in c["body"]["messages"][1]["content"] and "please run the test suite" in c["body"]["messages"][1]["content"]
+        assert c["sid"].startswith("ses_review_")
+        assert billed == [(c["sid"], True), (c["sid"], False)]
+        assert await until(lambda: verdicts, 2)
+        assert verdicts[0]["stage"] == "reviewer"
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"text": ALLOW}}, check)
+
+
+def test_direct_the_backup_answers_when_gpt_oss_fails_and_the_log_names_it(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: oc.replies(), 6)
+        assert [s["body"]["model"] for s in px.seen] == ["openai/gpt-oss-120b", "deepseek/deepseek-v4.1-flash"]
+        assert await until(lambda: log_lines(tmp_path), 2)
+        assert log_lines(tmp_path)[0]["model"] == "trustedrouter/deepseek/deepseek-v4.1-flash"
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"status": 502}, "deepseek/deepseek-v4.1-flash": {"text": ALLOW}}, check)
+
+
+def test_direct_a_first_model_that_hangs_leaves_the_backup_its_time(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: oc.replies(), 6)
+        assert oc.replies()[0]["body"] == {"reply": "once"} and len(px.seen) == 2
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"text": ALLOW, "delay": 2}, "deepseek/deepseek-v4.1-flash": {"text": ALLOW}}, check,
+                 first_try_ms=150, review_timeout_ms=1500)
+
+
+def test_direct_both_failing_leaves_it_for_the_person_saying_why(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: verdicts, 6)
+        assert verdicts[0]["action"] == "ask"
+        assert "gpt-oss-120b: answered 502; deepseek/deepseek-v4.1-flash: no verdict in its answer" in verdicts[0]["reason"]
+        await asyncio.sleep(0.2)
+        assert oc.replies() == []
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"status": 502}, "deepseek/deepseek-v4.1-flash": {"text": "sure, fine"}}, check)

{witbitz_code-1.7.0 → witbitz_code-1.7.1}/tests/test_uninstall.py

@@ -223,7 +223,7 @@ def test_under_the_windows_installer_the_summary_says_what_that_uninstaller_does
     assert r["done"]
     for wrong in ("pip uninstall", "pipx", "OpenCode is still installed", "still running in a terminal window"):
         assert wrong not in said, f"{wrong!r} does not apply to the Windows installer:\n{said}"
-    assert "irm https://app.witbitz.chat/code.ps1 | iex" in said, said
+    assert "https://witbitz.chat/code" in said and "app.witbitz.chat" not in said, said
     assert ("package",) not in f.done, "the Windows uninstaller removes the program itself"