witbitz-code 1.9.2__tar.gz → 1.9.3__tar.gz

{witbitz_code-1.9.2/src/witbitz_code.egg-info → witbitz_code-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.9.2
+Version: 1.9.3
 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.9.2 → witbitz_code-1.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.9.2"
+version = "1.9.3"
 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.9.2 → witbitz_code-1.9.3}/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.9.2"
+__version__ = "1.9.3"

{witbitz_code-1.9.2 → witbitz_code-1.9.3}/src/witbitz_code/confidential.py

@@ -261,6 +261,28 @@ def without_words(frame: str) -> str:
     return f"data: {dumps({**ev, 'choices': [{**ch, 'delta': rest}, *ev['choices'][1:]]})}\n\n"
 
 
+# The confidential default (⇄ tools/code-confidential.mjs CONFIDENTIAL_DEFAULT): what answers when a pick has no verified-enclave
+# route right now. The note says so once per session — a Code task makes many calls.
+CONFIDENTIAL_DEFAULT = "deepseek/deepseek-v4.1-flash"
+_NOTED: dict = {}
+
+
+def fallback_note(frm: str, by: str, session_id: str = "") -> str:
+    if not frm:
+        return ""
+    k = session_id + "\0" + frm
+    if k in _NOTED:
+        return ""
+    _NOTED[k] = True
+    if len(_NOTED) > 500:
+        _NOTED.pop(next(iter(_NOTED)))
+    return f"\n\n_Answered by {by} — {frm} isn't available confidentially right now._"
+
+
+def note_frame(note: str, model: str) -> str:
+    return "data: " + dumps({"id": "witbitz-note", "object": "chat.completion.chunk", "model": model, "choices": [{"index": 0, "delta": {"content": note}}]}) + "\n\n"
+
+
 def completion_of(events: list, model: str) -> dict:
     """The streamed events as one chat.completion — for a caller that asked without `stream`."""
     content = reasoning = ""
@@ -652,7 +674,10 @@ class ConfidentialProxy:
             except Exception:  # noqa: BLE001 — progress must never fail a call
                 pass
 
+        fell = {"from": ""}  # the pick's label when TrustedRouter had no verified-enclave route for it and the default answered
+
         async def once(words_shown: bool = False) -> None:
+            nonlocal body, conf, label
             ends = self._proof_ends.get(body["model"])
             hold = attempt["n"] > 1 or (ends is not None and self._now() / 1000 >= ends - HOLD_BEFORE_LAPSE_SEC)
             n = self._nonce()
@@ -670,6 +695,16 @@ class ConfidentialProxy:
                     used = allowance_used(up.status_code, text)
                     if used:
                         raise used
+                    # No verified-enclave route for the pick (2026-10-20, ⇄ tools/code-confidential.mjs): refused BEFORE any upstream
+                    # saw the request — the same request goes again as the confidential default, attested and checked, once.
+                    if (up.status_code == 400 and "no route candidates" in text.lower() and not fell["from"] and body.get("model") != CONFIDENTIAL_DEFAULT
+                            and CONFIDENTIAL_DEFAULT in self.models and not res.headers_sent):
+                        fell["from"] = conf["label"]
+                        self.log(f"code-confidential: {body['model']} has no verified-enclave route now → {CONFIDENTIAL_DEFAULT} answers")
+                        body = {**body, "model": CONFIDENTIAL_DEFAULT}
+                        conf = self.models[CONFIDENTIAL_DEFAULT]
+                        label = f"{conf['label']} (confidential)"
+                        return await once(words_shown)
                     if res.headers_sent:
                         raise Refusal(502, f"{label}: TrustedRouter answered {up.status_code} when asked again ({text[:160]})", "upstream_error")
                     await res.head(up.status_code, {"content-type": up.headers.get("content-type", "application/json")})
@@ -710,15 +745,25 @@ class ConfidentialProxy:
             exp = ((v.get("claims") or {}).get("upstream") or {}).get("verification_expires_at")
             if isinstance(exp, (int, float)):
                 self._proof_ends[body["model"]] = exp
+            note = fallback_note(fell["from"], conf["label"], session_id)
             if wants_stream:
+                noted = not note
                 for f in answer.held():
+                    if not noted and re.search(r'"finish_reason":"|^data: \[DONE\]', f, re.M):
+                        await res.write(note_frame(note, body["model"]))  # the note goes in before the answer ends
+                        noted = True
                     out = without_words(f) if words_shown else f
                     if out:
                         await res.write(out)
+                if not noted:
+                    await res.write(note_frame(note, body["model"]))
                 await res.end()
                 return
             await res.head(200, {"content-type": "application/json"})
-            await res.end(dumps(completion_of(answer.events(), body["model"])))
+            done = completion_of(answer.events(), body["model"])
+            if note and done.get("choices") and done["choices"][0].get("message") is not None:
+                done["choices"][0]["message"]["content"] = (done["choices"][0]["message"].get("content") or "") + note
+            await res.end(dumps(done))
 
         try:
             if not conf.get("vision"):

{witbitz_code-1.9.2 → witbitz_code-1.9.3/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.9.2
+Version: 1.9.3
 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.9.2 → witbitz_code-1.9.3}/tests/test_confidential.py

@@ -410,3 +410,35 @@ def test_the_months_allowance_used_is_a_402_that_says_so_never_a_429_opencode_wo
         with_proxy(t, net=LimitNet(meta, stream.decode("utf-8")), models=models)
     assert cf.allowance_used(429, '{"error":{"message":"rate limited"}}') is None, "a real rate limit stays a rate limit"
     assert cf.allowance_used(400, json.dumps(SPEND_LIMIT)) is None
+
+
+class NoRouteThenReplay(FakeNet):
+    """TrustedRouter refuses any model but the default ("No route candidates" — before any upstream sees it); the default
+    answers with the captured stream."""
+
+    def handler(self, req: httpx.Request):
+        if "googleapis.com/service_accounts" not in str(req.url) and json.loads(req.content.decode("utf-8")).get("model") != cf.CONFIDENTIAL_DEFAULT:
+            self.calls.append({"url": str(req.url), "headers": dict(req.headers), "raw": list(req.headers.raw), "body": req.content.decode("utf-8")})
+            return httpx.Response(400, json={"error": {"message": "No route candidates match the requested provider filters"}})
+        return super().handler(req)
+
+
+@needs_fixture
+def test_a_pick_with_no_verified_enclave_route_is_answered_by_the_default_with_one_note_per_session():
+    meta, stream, request = fixture()
+    net = NoRouteThenReplay(meta, stream.decode("utf-8"))
+    logs = []
+    glm = {**SAY_OK, "model": "z-ai/glm-5.3"}
+
+    async def t(post, net_, _p):
+        r = await post(glm, {"x-session-id": "ses_fb"})
+        text = r.text
+        assert [json.loads(c["body"])["model"] for c in net.calls] == ["z-ai/glm-5.3", "deepseek/deepseek-v4.1-flash"], "the pick, then the default — once"
+        assert net.calls[1]["body"].encode() == request, "the same request, only the model changed — the receipt signs it"
+        assert '"content":"OK"' in text
+        assert "Answered by DeepSeek V4.1 Flash — GLM 5.3 isn't available confidentially right now." in text
+        assert text.index("Answered by") < text.index("[DONE]")
+        again = (await post(glm, {"x-session-id": "ses_fb"})).text
+        assert "Answered by" not in again and '"content":"OK"' in again, "said once per session"
+        assert any("has no verified-enclave route now" in line for line in logs)
+    with_proxy(t, net=net, log=logs.append)