@agentsdock/server 1.0.7-beta.5 → 1.0.8

package/server/codex_provider.py

@@ -12,6 +12,8 @@ import stat
 import tempfile
 import threading
 import uuid
+import time
+import httpx
 from urllib.parse import urlsplit, urlunsplit
 from urllib.error import HTTPError, URLError
 from urllib.request import HTTPRedirectHandler, ProxyHandler, Request as URLRequest, build_opener
@@ -21,7 +23,7 @@ from fastapi.responses import JSONResponse
 
 from codex_auth import validate_api_key
 from codex_app_server import CodexAppServerManager, decline_server_request
-from codex_side_question import isolated_config, _verify_protocol
+from codex_side_question import isolated_config, _verify_isolated_protocol as _verify_protocol
 from side_questions import isolated_environment, run_isolated_command
 
 
@@ -267,7 +269,7 @@ class ProviderStore:
             try:
                 metadata = self._read("settings.json") or {}
                 identifier = revision or metadata.get("credential_id")
-                if not identifier and not metadata:
+                if not identifier:
                     return None
                 if not isinstance(identifier, str) or not re.fullmatch(r"[0-9a-f]{32}", identifier):
                     raise ValueError("invalid credential identity")
@@ -282,6 +284,12 @@ class ProviderStore:
                 if not credential.get("binding") or credential.get("binding") not in (binding(selected), legacy_binding(selected)):
                     raise ValueError("credential binding mismatch")
                 key = validate_api_key({"api_key": credential.get("api_key")})
+                if self._epoch(credential) < self._epoch(metadata, settings=True):
+                    current_id = metadata.get("credential_id")
+                    current = self._read("credential-" + current_id + ".json") if isinstance(current_id, str) and re.fullmatch(r"[0-9a-f]{32}", current_id) else None
+                    if not (current and metadata.get("connection_verified") is True
+                            and selected["base_url"] == metadata.get("base_url") and key == current.get("api_key")):
+                        raise HTTPException(409, "This chat's API connection is disconnected. Reconnect its original endpoint and API key in My Agents, then retry.")
                 self._public_selections[identifier] = {**selected, "credential_id": identifier}
                 self._revision_catalog_keys[identifier] = catalog_key({**selected, "api_key": key})
                 if include_key:
@@ -291,16 +299,32 @@ class ProviderStore:
                 if not include_revision and revision is None:
                     selected.pop("legacy_model", None)
                 return selected
+            except HTTPException as exc:
+                if exc.status_code == 409:
+                    raise
+                raise HTTPException(503, "Saved provider settings or credentials are unavailable.") from None
             except Exception:
                 raise HTTPException(503, "Saved provider settings or credentials are unavailable.") from None
 
+    @staticmethod
+    def _epoch(record: dict, *, settings=False) -> int:
+        # Empty legacy settings mean Forget already happened. Existing legacy
+        # credential files belong to epoch zero and cannot be resurrected.
+        value = record.get("connection_epoch", 1 if settings and not record.get("credential_id") else 0)
+        if type(value) is not int or not 0 <= value < 2**53 - 1:
+            raise ValueError("invalid connection epoch")
+        return value
+
     def status(self, *, available=True) -> dict:
-        selected = self.selection(include_revision=True)
+        with self.lock:
+            selected = self.selection(include_revision=True)
+            metadata = self._read("settings.json") or {}
+        evidence = {"connection_verified": True} if selected and metadata.get("credential_id") == selected.get("credential_id") and metadata.get("connection_verified") is True else {}
         return {"available": available, "configured": selected is not None,
             "base_url": selected["base_url"] if selected else None,
             "model": selected.get("model") if selected else None,
             "credential_id": selected.get("credential_id") if selected else None,
-            "has_api_key": selected is not None, "wire_api": "responses"}
+            "has_api_key": selected is not None, "wire_api": "responses", **evidence}
 
     def for_session(self, session: dict, *, include_key=False) -> dict | None:
         if session_choice(session.get("codex_provider")) == "default":
@@ -312,6 +336,11 @@ class ProviderStore:
         if session.get("codex_provider_binding") not in (None, binding(selected), legacy_binding(selected)):
             raise HTTPException(409, "This conversation belongs to another Codex endpoint. Start a new Codex chat, or restore its original endpoint.")
         model = session.get("model") or selected.get("model") or self.cached_catalog(selected).get("default_model")
+        if not model and (session.get("codex_thread_id") or session.get("session_id")):
+            # Preserve the old inferred choice for an already-started thread;
+            # never offer that arbitrary first-row default to new chats.
+            previous = self._saved_model_catalog(selected)
+            model = previous.get("legacy_default_model") or previous.get("default_model")
         if model:
             selected["model"] = validate_model(model)
         return selected
@@ -330,6 +359,9 @@ class ProviderStore:
             # metadata without reopening credential files for every event.
             selected = self._public_selections.get(session.get("codex_provider_revision")) if session else None
             selected = selected or (self.for_session(session) if session is not None else self.registration())
+            if selected and session and not selected.get("model") and (session.get("codex_thread_id") or session.get("session_id")):
+                previous = self._saved_model_catalog(selected)
+                selected = {**selected, "model": session.get("model") or previous.get("legacy_default_model") or previous.get("default_model")}
         except HTTPException:
             selected = None
         result = {"configured": selected is not None, "available": available and selected is not None,
@@ -367,15 +399,17 @@ class ProviderStore:
                 "model_efforts": {model: [option for option in EFFORT_OPTIONS if option["value"] in capability["reasoning_efforts"]]
                     for model, capability in capabilities.items()},
                 "model_capabilities": capabilities,
-                "default_model": cached.get("default_model") or (selected or {}).get("model") or "",
+                "default_model": (selected or {}).get("model") or "",
                 "default_effort": ""}
 
     def cache_catalog(self, selected: dict, catalog: dict):
         with self.lock:
+            previous = self._saved_model_catalog(selected)
+            legacy_default = previous.get("legacy_default_model") or (previous.get("default_model") if not selected.get("model") else None)
             models = catalog.get("models", [])
             self._catalogs[catalog_key(selected)] = {"models": models,
                 "model_capabilities": {model["value"]: model_capability(catalog.get("model_capabilities", {}).get(model["value"])) for model in models},
-                "default_model": catalog.get("default_model", "")}
+                "default_model": catalog.get("default_model", ""), "legacy_default_model": legacy_default}
             self._save_model_catalog(selected, self._catalogs[catalog_key(selected)])
             # Apply fresh explicit denials when discovery completes, rather
             # than letting old metadata veto a later successful model check.
@@ -430,7 +464,7 @@ class ProviderStore:
                     or not isinstance(catalog, dict) or not isinstance(catalog.get("models"), list)
                     or len(catalog["models"]) > 512 or not isinstance(catalog.get("model_capabilities"), dict)):
                 raise ValueError("Invalid saved model catalog")
-            models = [{"value": validate_model(model.get("value")), "label": validate_model(model.get("value"))}
+            models = [{"value": validate_model(model.get("value")), "label": safe_model_label(model.get("label"), validate_model(model.get("value")))}
                 for model in catalog["models"]]
             if len({model["value"] for model in models}) != len(models):
                 raise ValueError("Duplicate saved model identities")
@@ -438,9 +472,11 @@ class ProviderStore:
                 **catalog["model_capabilities"].get(model["value"], {}),
                 "compatibility": "unverified", "reasoning_summary_supported": None}) for model in models}
             default_model = catalog.get("default_model") or ""
-            if default_model and default_model not in capabilities:
-                raise ValueError("Invalid saved default model")
-            result = {"models": models, "model_capabilities": capabilities, "default_model": default_model}
+            if default_model:
+                default_model = validate_model(default_model)
+            legacy = catalog.get("legacy_default_model")
+            result = {"models": models, "model_capabilities": capabilities, "default_model": default_model,
+                      "legacy_default_model": validate_model(legacy) if legacy else None}
             self._saved_catalogs[identifier] = result
             return result
         except Exception:
@@ -557,8 +593,9 @@ class ProviderStore:
         """Make the current generation independently readable before replacement."""
         selected = self.selection(include_key=True, include_revision=True)
         if selected:
+            previous = self._read("credential-" + selected["credential_id"] + ".json") or {}
             self._atomic("credential-" + selected["credential_id"] + ".json",
-                {**selected, "binding": binding(selected)})
+                {**selected, "binding": binding(selected), "connection_epoch": self._epoch(previous)})
             for path in self.root.glob("thread-*.json"):
                 previous = self._read(path.name) or {}
                 if not previous.get("credential_id") and previous.get("binding") and previous["binding"] in (binding(selected), legacy_binding(selected)):
@@ -575,10 +612,14 @@ class ProviderStore:
                 pass
             identifier = uuid.uuid4().hex
             credential_name = "credential-" + identifier + ".json"
-            self._atomic(credential_name, {**selected, "binding": binding(selected)})
+            epoch = self._epoch(self._read("settings.json") or {}, settings=True)
+            self._atomic(credential_name, {**selected, "binding": binding(selected), "connection_epoch": epoch})
             try:
                 self._atomic("settings.json", {name: value for name, value in
-                    {**selected, "credential_id": identifier}.items() if name != "api_key"})
+                    {**selected, "credential_id": identifier, "connection_epoch": epoch}.items() if name != "api_key"})
+                # Restored old revisions are authorized by the current verified
+                # identity; a later replacement must not reuse cached readiness.
+                self._public_selections.clear()
             except BaseException:
                 with suppress(OSError):
                     os.unlink(self.root / credential_name)
@@ -590,7 +631,9 @@ class ProviderStore:
                 self.retain_current()
             except (HTTPException, ValueError, UnicodeError):
                 pass
-            self._atomic("settings.json", {})
+            epoch = self._epoch(self._read("settings.json") or {}, settings=True)
+            self._atomic("settings.json", {"connection_epoch": epoch + 1})
+            self._public_selections.clear()
 
 
 def native_config(selected: dict) -> dict:
@@ -717,56 +760,80 @@ class _NoModelRedirects(HTTPRedirectHandler):
         return None
 
 
-def discover_models(selected: dict, native_models: dict | None = None) -> dict:
-    """One bounded operator-requested listing; never forward a key on redirect."""
-    request = URLRequest(selected["base_url"] + "/models", headers={
-        "Authorization": "Bearer " + selected["api_key"], "Accept": "application/json"})
+def safe_model_label(label, model):
+    return label.strip() if isinstance(label, str) and label.strip() and len(label) <= 160 and all(ord(c) >= 32 and ord(c) != 127 for c in label) else model
+
+
+def endpoint_model_catalog(selected: dict, *, protocol="responses") -> dict:
+    """Read only this endpoint's inventory. Never use CLI models or infer a default.
+
+    Pagination stays on the original URL; arbitrary next links are never followed.
+    Discovery is not an inference/credential verification or a compatibility test.
+    """
+    base = selected["base_url"].rstrip("/")
+    parsed = urlsplit(base)
+    router = parsed.scheme == "https" and parsed.netloc in {"openrouter.ai", "eu.openrouter.ai"} and parsed.path in {"/api", "/api/v1"}
+    target = (base.removesuffix("/v1") + "/v1/models/user") if router else base + (
+        "/v1/models" if protocol == "anthropic" and not base.endswith("/v1") else "/models")
+    headers = {"Accept": "application/json", "anthropic-version": "2023-06-01"}
+    header = selected.get("auth_header", "bearer")
+    headers["x-api-key" if header == "x-api-key" else "Authorization"] = selected["api_key"] if header == "x-api-key" else "Bearer " + selected["api_key"]
+    options, capabilities, seen_cursors = [], {}, set()
+    total_bytes, deadline, after = 0, time.monotonic() + 10, None
+    def result(status):
+        return {"models": options, "model_capabilities": capabilities, "discovery_status": status,
+                "default_model": selected.get("model") or "", "efforts": [], "default_effort": ""}
     try:
-        with build_opener(ProxyHandler({}), _NoModelRedirects()).open(request, timeout=15) as response:
-            raw = response.read(1024 * 1024 + 1)
-            if len(raw) > 1024 * 1024:
-                raise ValueError("model response too large")
-            payload = json.loads(raw)
-        entries = payload.get("data") if isinstance(payload, dict) else None
-        if not isinstance(entries, list):
-            raise ValueError("invalid model list")
-        models = []
-        capabilities = {}
-        seen = set()
-        for entry in entries[:2000]:
-            if not isinstance(entry, dict):
-                continue
-            try:
-                value = validate_model(entry.get("id"))
-            except HTTPException:
-                continue
-            capability = discovered_model_capability(entry, value, native_models)
-            if capability is None:
-                continue
-            if value not in seen:
-                seen.add(value)
-                models.append({"value": value, "label": value})
-                capabilities[value] = capability
-            if len(models) == 512:
-                break
-        return {"ok": True, "status": "ready",
-            "message": "The endpoint returned its model list. Model compatibility remains unverified until tested.",
-            "models": models, "efforts": [],
+        with httpx.Client(timeout=3, follow_redirects=False, trust_env=False) as client:
+            for page in range(5):
+                remaining = deadline - time.monotonic()
+                if remaining <= 0: return result("partial")
+                params = {"limit": 1000} if protocol == "anthropic" and not router else {}
+                if after: params["after_id" if protocol == "anthropic" and not router else "after"] = after
+                with client.stream("GET", target, headers=headers, params=params, timeout=min(3, remaining)) as response:
+                    if response.status_code != 200:
+                        if response.status_code in {401, 403}:
+                            options.clear(); capabilities.clear()
+                            return result("authentication_failed")
+                        return result("partial" if options else "unavailable")
+                    raw = bytearray()
+                    for chunk in response.iter_bytes():
+                        total_bytes += len(chunk)
+                        if total_bytes > 8 * 1024 * 1024 or time.monotonic() > deadline: return result("partial" if options else "unavailable")
+                        raw.extend(chunk)
+                payload = json.loads(raw)
+                entries = payload.get("data") if isinstance(payload, dict) else None
+                if not isinstance(entries, list): return result("partial" if options else "unavailable")
+                for item in entries[:2000]:
+                    if not isinstance(item, dict): continue
+                    try: model = validate_model(item.get("id"))
+                    except HTTPException: continue
+                    capability = discovered_model_capability(item, model)
+                    if capability is None or model in capabilities: continue
+                    declared = item.get("capabilities") if isinstance(item.get("capabilities"), dict) else {}
+                    if declared.get("tools") is False or item.get("supports_tools") is False: continue
+                    params_supported = item.get("supported_parameters")
+                    if isinstance(params_supported, list) and params_supported and "tools" not in params_supported: continue
+                    label = safe_model_label(item.get("display_name") or item.get("name"), model)
+                    options.append({"value": model, "label": label})
+                    capabilities[model] = capability
+                    if len(options) >= 512: return result("partial")
+                if payload.get("has_more") is not True: return result("ready" if options else "empty")
+                cursor = payload.get("last_id") or (entries[-1].get("id") if entries and isinstance(entries[-1], dict) else None)
+                if not isinstance(cursor, str) or not 1 <= len(cursor) <= 256 or cursor in seen_cursors: return result("partial")
+                seen_cursors.add(cursor); after = cursor
+        return result("partial")
+    except (httpx.HTTPError, ValueError, TypeError, RecursionError):
+        return result("partial" if options else "unavailable")
+
+
+def discover_models(selected: dict, native_models: dict | None = None) -> dict:
+    result = endpoint_model_catalog(selected)
+    ready = result["discovery_status"] in {"ready", "partial", "empty"}
+    return {**result, "ok": ready, "status": "ready" if ready else "authentication_failed" if result["discovery_status"] == "authentication_failed" else "failed",
+            "message": "Endpoint model inventory; model compatibility remains unverified until tested.",
             "model_efforts": {model: [option for option in EFFORT_OPTIONS if option["value"] in capability["reasoning_efforts"]]
-                for model, capability in capabilities.items()},
-            "model_capabilities": capabilities,
-            "default_model": models[0]["value"] if models else "", "default_effort": ""}
-    except HTTPError as exc:
-        if exc.code in (401, 403):
-            return test_result("authentication_failed")
-        if exc.code in (404, 405):
-            return {**test_result("unsupported"),
-                "message": "The endpoint does not provide model discovery. Save it and enter a model ID in the chat."}
-        return test_result("failed")
-    except (URLError, TimeoutError, ConnectionError):
-        return test_result("connection_failed")
-    except Exception:
-        return test_result("failed")
+                for model, capability in result["model_capabilities"].items()}}
 
 
 def test_result(status: str) -> dict:
@@ -982,7 +1049,7 @@ async def test_connection(selected: dict, *, executable: str, environment: dict,
                 raise asyncio.CancelledError
 
 
-def create_router(*, authorize, store: ProviderStore, mutate, probe, available, discover=discover_models, session_lookup=None, native_models=None) -> APIRouter:
+def create_router(*, authorize, store: ProviderStore, mutate, probe, available, discover=discover_models, session_lookup=None, native_models=None, check_credentials=None) -> APIRouter:
     router = APIRouter()
 
     async def body(request, *, saved=False):
@@ -993,6 +1060,9 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
                 raise HTTPException(413, "Provider request is too large.")
         try:
             parsed = json.loads(raw)
+            verify = isinstance(parsed, dict) and request.method == "PUT" and parsed.pop("verify_connection", False)
+            if verify is not False and verify is not True:
+                raise HTTPException(400, "Invalid connection check.")
             if saved and isinstance(parsed, dict) and "base_url" not in parsed and "api_key" not in parsed:
                 if set(parsed) - {"model", "session_id", "credential_id"}:
                     raise HTTPException(400, "Provide a model and the saved endpoint identity.")
@@ -1015,7 +1085,10 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
                     selected.clear()
                     raise HTTPException(409, "The saved endpoint changed. Refresh before checking this model.")
                 return {**selected, "model": selected_model}
-            return validate_selection(parsed)
+            selected = validate_selection(parsed)
+            if verify:
+                selected["verify_connection"] = True
+            return selected
         except (ValueError, UnicodeError, RecursionError):
             raise HTTPException(400, "Provide a valid provider request.") from None
         finally:
@@ -1027,16 +1100,8 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
             raise HTTPException(503, "Custom providers require native Codex app-server transport.")
 
     async def catalog(selected):
-        # Native metadata is local and credential-free; endpoint discovery stays
-        # explicit and supplies the identity/ownership fence for any fallback.
-        if native_models is not None:
-            try:
-                native = await native_models()
-            except (HTTPException, OSError, ValueError):
-                native = None
-            result = await asyncio.to_thread(discover, selected, native_models=native)
-        else:
-            result = await asyncio.to_thread(discover, selected)
+        # Custom inventories must not depend on CLI login or its native catalog.
+        result = await asyncio.to_thread(discover, selected)
         if result.get("ok") is True:
             store.cache_catalog(selected, result)
             return {**result, **store.cached_catalog(selected)}
@@ -1045,7 +1110,10 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
     @router.get("/api/admin/codex/provider")
     async def status(request: Request):
         authorize(request)
-        return JSONResponse(await asyncio.to_thread(store.status, available=available()), headers={"Cache-Control": "no-store"})
+        configuration = await asyncio.to_thread(store.status, available=available())
+        if check_credentials is not None:
+            configuration["connection_check_available"] = True
+        return JSONResponse(configuration, headers={"Cache-Control": "no-store"})
 
     @router.post("/api/admin/codex/provider/test")
     async def test(request: Request):
@@ -1097,8 +1165,20 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
         access(request)
         selected = await body(request)
         try:
+            if selected.pop("verify_connection", False):
+                if check_credentials is None:
+                    raise HTTPException(501, "Update the server to verify an API connection.")
+                result = await check_credentials(selected)
+                if result != "verified":
+                    raise HTTPException(400, "API connection check failed. Check the URL and key.")
+                # Only this server-attested result may be persisted. It is not
+                # an accepted field in client-supplied provider selections.
+                selected["connection_verified"] = True
             await mutate(selected)
-            return JSONResponse(await asyncio.to_thread(store.status), headers={"Cache-Control": "no-store"})
+            configuration = await asyncio.to_thread(store.status)
+            if check_credentials is not None:
+                configuration["connection_check_available"] = True
+            return JSONResponse(configuration, headers={"Cache-Control": "no-store"})
         except HTTPException:
             raise
         except Exception:
@@ -1111,7 +1191,10 @@ def create_router(*, authorize, store: ProviderStore, mutate, probe, available,
         access(request)
         try:
             await mutate(None)
-            return JSONResponse(await asyncio.to_thread(store.status), headers={"Cache-Control": "no-store"})
+            configuration = await asyncio.to_thread(store.status)
+            if check_credentials is not None:
+                configuration["connection_check_available"] = True
+            return JSONResponse(configuration, headers={"Cache-Control": "no-store"})
         except HTTPException:
             raise
         except Exception: