@agentsdock/server 1.0.7 → 1.0.8-beta.2

package/server/codex_app_server.py

@@ -354,6 +354,12 @@ class CodexAppServerTurn:
     # Native turn identities are retained only for this owner's lifetime.
     # Delayed duplicate starts must not resurrect one of its finished turns.
     _completed_turn_ids: set[str] = field(default_factory=set)
+    # Unlike turn_id, this identity does not follow native goal/child turns.
+    # History repair needs the turn that accepted the original user input.
+    initial_turn_id: str = field(init=False, default="")
+
+    def __post_init__(self) -> None:
+        self.initial_turn_id = self.turn_id
 
     async def next_notification(self, timeout: float | None = None) -> dict[str, Any]:
         return await self._subscription.next_notification(timeout)
@@ -498,6 +504,8 @@ class CodexAppServerTurn:
                 f"provisional turn already bound to {self.turn_id}, not {resolved}"
             )
         self.turn_id = resolved
+        if not self.initial_turn_id:
+            self.initial_turn_id = resolved
         if not self._retain_thread_stream:
             self._subscription.turn_id = resolved
 
@@ -1451,6 +1459,8 @@ class CodexAppServerClient:
             # keeping this id current is required for both event routing and
             # turn/interrupt to target the work that is actually running.
             if not active_turn.turn_id or method == "turn/started":
+                if not active_turn.initial_turn_id:
+                    active_turn.initial_turn_id = turn_id
                 active_turn.turn_id = turn_id
                 if method == "turn/started":
                     active_turn._completed = False
@@ -2674,6 +2684,7 @@ class CodexAppServerClient:
                     # continue before its delayed start response is read.
                     # Acceptance of that exact completed ID is proven; leave
                     # the handle bound to the newer live turn, not the reply.
+                    provisional.initial_turn_id = turn_id
                     return provisional
                 raise CodexAppServerProtocolError(
                     "turn/start response did not match its early notifications",
@@ -2681,6 +2692,7 @@ class CodexAppServerClient:
                     safe_to_retry=False,
                 )
             provisional.turn_id = turn_id
+            provisional.initial_turn_id = turn_id
             if not retain_thread_stream:
                 provisional._subscription.turn_id = turn_id
             return provisional

package/server/codex_history_repair.py

@@ -157,7 +157,7 @@ def _native_stamp(path: Path) -> tuple[int, int, int, int]:
 
 
 def _native_records(path: Path, expected: tuple[int, int, int, int], budget: _NativeReadBudget,
-                    *, end: int | None = None):
+                    *, end: int | None = None, provider_source: bool = False):
     """Stream one fixed prefix; tool volume does not consume retained-key budget.
 
     A source proof needs only the prefix ending at its newest checkpoint. Never
@@ -181,7 +181,14 @@ def _native_records(path: Path, expected: tuple[int, int, int, int], budget: _Na
             if not line or len(line) > NATIVE_PROOF_LINE_BYTES or not line.endswith(b"\n"):
                 raise _Unproven()
             offset += len(line)
-            record = json.loads(line)
+            try:
+                record = json.loads(line)
+            except (ValueError, UnicodeDecodeError):
+                if not provider_source:
+                    raise
+                # The provider importer skips malformed records. Their exact
+                # bytes still participate in the checkpoint digest below.
+                record = {}
             if not isinstance(record, dict):
                 raise _Unproven()
             yield record, offset, line
@@ -229,6 +236,20 @@ def _public_assistant_item_id(event: dict) -> str | None:
     return item_id if public and isinstance(item_id, str) and 0 < len(item_id) <= 256 else None
 
 
+def _native_owned_turn_ids(event: dict) -> set[str]:
+    """One logical run can retain its initial input across native continuations."""
+    return {value for field in ("provider_turn_id", "provider_initial_turn_id")
+            if isinstance(value := event.get(field), str) and 0 < len(value) <= 256}
+
+
+def _native_assistant_item_owners(assistant_items: dict, completed_runs: set[str]) -> dict:
+    owners: dict = {}
+    for run, item_id, body_key in assistant_items:
+        if run in completed_runs:
+            owners.setdefault((item_id, body_key), set()).add(run)
+    return owners
+
+
 @dataclass
 class _SourceBudget:
     bytes_remaining: int
@@ -783,11 +804,12 @@ def _prove_native_replays(session_id: str, provider_id: str, events: Path, sourc
                     candidates.append(target)
         elif event.get("imported") is not True and event.get("backend") in (None, "codex"):
             if event.get("type") == "turn_finished" and event.get("backend") == "codex" and event.get("transport") == "app-server":
-                thread, turn = event.get("provider_thread_id"), event.get("provider_turn_id")
-                if isinstance(thread, str) and _PROVIDER_ID.fullmatch(thread) and isinstance(turn, str) and 0 < len(turn) <= 256:
-                    owned = owners.setdefault((thread, turn), set())
-                    retained += run not in owned
-                    owned.add(run)
+                thread = event.get("provider_thread_id")
+                if isinstance(thread, str) and _PROVIDER_ID.fullmatch(thread):
+                    for turn in _native_owned_turn_ids(event):
+                        owned = owners.setdefault((thread, turn), set())
+                        retained += run not in owned
+                        owned.add(run)
             kind = "user" if event.get("type") == "turn_started" else "assistant" if event.get("type") in ("assistant_text", "reasoning_summary", "turn_finished") else None
             body = event.get("prompt") if kind == "user" else event.get("result_text") if event.get("type") == "turn_finished" else event.get("text")
             if kind and isinstance(body, str) and body and len(body) <= 4 * 1024 * 1024:
@@ -868,10 +890,19 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
     compactions, candidate_assistants = {}, set()
     compaction_tracker = CodexCompactionSummaryTracker(thread)
     delivery_bodies, delivery_source_ids = {}, {}
+    completed_runs = {run for (owner_thread, _turn), runs in owners.items()
+                      if owner_thread == thread for run in runs}
+    assistant_item_owners = _native_assistant_item_owners({
+        (run, item_id, body_key): event
+        for (run, kind, body_key), events in native.items() if kind == "assistant"
+        for event in events if (item_id := _public_assistant_item_id(event)) is not None
+    }, completed_runs)
+    assistant_owner_evidence: dict = {}
+    assistant_source_turns: dict = {}
     allowed_header_owners, header_parents = {thread}, {}
     context_turn = None
     retained = 0
-    for record, offset, line in _native_records(source, stamp, budget, end=max(wanted)):
+    for record, offset, line in _native_records(source, stamp, budget, end=max(wanted), provider_source=True):
         payload = record.get("payload")
         if offset == len(line) or record.get("type") == "session_meta":
             if record.get("type") != "session_meta" or not isinstance(payload, dict):
@@ -922,6 +953,14 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
                 or not isinstance(timestamp, str) or not 0 < len(timestamp) <= 64):
             continue
         key = (turn, item["kind"], _text_key(item["text"]), item.get("source_text_sha256"))
+        if origin and item["kind"] == "assistant" and item.get("source_text_sha256") is None:
+            item_key = (origin["event_id"], _text_key(_native_assistant_text(item["text"])))
+            if item_key in assistant_item_owners:
+                assistant_source_turns.setdefault(item_key, set()).add(turn)
+                assistant_owner_evidence.setdefault(turn, []).append((offset, item_key))
+                retained += 1
+                if retained > MAX_KEYS:
+                    raise _Unproven()
         if origin and item["kind"] == "user" and any(run in deliveries.starts for run in owners.get((thread, turn), ())):
             ids = delivery_source_ids.setdefault(turn, set())
             if len(ids) < 2:
@@ -968,7 +1007,14 @@ def _prove_native_source(thread: str, source: Path, root: Path, batches: dict, c
         if len(matches) != 1:
             continue
         key = next(iter(matches))
-        source_ids, owned_runs = canonical.get(key, {}), owners.get((thread, key[0]), set())
+        source_ids = canonical.get(key, {})
+        owned_runs = set(owners.get((thread, key[0]), set()))
+        # Older ledgers retained only the final continuation's turn ID. An
+        # exact public assistant item proves the earlier turn belongs to the
+        # same completed native run, without classifying any user wording.
+        for offset, item_key in assistant_owner_evidence.get(key[0], ()):
+            if offset <= end and len(assistant_source_turns[item_key]) == 1:
+                owned_runs.update(assistant_item_owners[item_key])
         # Compaction owns a particular source item and timestamp. Another
         # genuine answer with the same body in this turn is a distinct item.
         timestamp_origins = [origin for origin in source_ids.values() if origin["timestamp"] == timestamp]
@@ -1177,11 +1223,11 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
                 or not 0 < len(run) <= 256 or run.startswith("import_")):
                 continue
             if (event.get("type") == "turn_finished" and event.get("backend") == "codex"
-                and event.get("transport") == "app-server" and event.get("provider_thread_id") == provider_id
-                and isinstance(event.get("provider_turn_id"), str) and 0 < len(event["provider_turn_id"]) <= 256):
-                owned = owners.setdefault(event["provider_turn_id"], set())
-                owner_count += run not in owned
-                owned.add(run)
+                and event.get("transport") == "app-server" and event.get("provider_thread_id") == provider_id):
+                for turn_id in _native_owned_turn_ids(event):
+                    owned = owners.setdefault(turn_id, set())
+                    owner_count += run not in owned
+                    owned.add(run)
             kind = "user" if event.get("type") == "turn_started" else "assistant" if event.get("type") in ("assistant_text", "reasoning_summary", "turn_finished") else None
             body = event.get("prompt") if kind == "user" else event.get("result_text") if event.get("type") == "turn_finished" else event.get("text")
             wake_hash = _native_mailbox_wake_hash(event) if kind == "user" else None
@@ -1198,6 +1244,25 @@ def filter_native_codex_history_items(session_id: str, provider_id: str, events:
                         assistant_items[(run, item_id, key[1])] = event["id"]
             if native_count + owner_count + len(assistant_items) + deliveries.count > MAX_KEYS:
                 raise _Unproven()
+        assistant_item_owners = _native_assistant_item_owners(
+            assistant_items, {run for runs in owners.values() for run in runs},
+        )
+        assistant_source_turns: dict = {}
+        for item in items:
+            budget.check()
+            origin = item.get("provider_origin")
+            if (item.get("kind") != "assistant" or not isinstance(item.get("text"), str)
+                or item.get("source_text_sha256") is not None or not isinstance(origin, dict)
+                or origin.get("provider") != "codex" or origin.get("kind") != "assistant"
+                or origin.get("session_id", provider_id) != provider_id
+                or not isinstance(origin.get("turn_id"), str) or not 0 < len(origin["turn_id"]) <= 256):
+                continue
+            item_key = (origin.get("event_id"), _text_key(_native_assistant_text(item["text"])))
+            if item_key in assistant_item_owners:
+                assistant_source_turns.setdefault(item_key, set()).add(origin["turn_id"])
+        for item_key, turns in assistant_source_turns.items():
+            if len(turns) == 1:
+                owners.setdefault(next(iter(turns)), set()).update(assistant_item_owners[item_key])
         delivery_proofs = _prove_pending_async_deliveries(
             session_id, provider_id, items, source_path, root, sync_checkpoint, parse_item,
             previous_seq, owners, deliveries, budget,

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
@@ -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: