@pure01fx/dsh-openai-codex-auth 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+## Unreleased
+
+## 0.6.0
+
+### Native Codex transport
+
+- Adds package-owned ChatGPT Codex Responses HTTP/SSE and WebSocket v2 transports for DSH 0.1.0-rc.6.
+- Supports text, tools, images, reasoning effort, usage, cancellation, bounded retries, replay state, stable routing identity, prewarm, incremental suffixes, reconnect, and safe pre-output HTTP fallback.
+- Exposes capability-gated `<base>-fast` aliases while sending the base wire model with `service_tier: priority`; unsupported Fast requests fail without downgrade.
+- Centralizes the tracked OpenAI Codex repository revision, release, and Catalog client version in one source; updates Catalog requests to the tracked release.
+- Matches current Codex reasoning wire semantics by mapping Persistent to `disabled` and Ultra through model-aware fallbacks.
+
+### Reliability and replay
+
+- Keeps DSH subagent settlement histories usable by dropping relayed non-assistant reasoning and child-owned tool calls at the native adapter boundary while preserving surrounding text, strict validation for ordinary user messages, and assistant native replay.
+- Waits through pure HTTP/WebSocket connection outages without consuming the five stream retries, using cancellable 5-second exponential delays capped at 60 seconds until the network recovers.
+- Matches Codex's default five dropped-stream retries: WebSocket reconnects use bounded exponential backoff and provider delays, while retryable failures after visible output recover at DSH's durable failed-step boundary without promoting failed chunks into assistant history or duplicating the pre-output retry budget.
+
+### Route migration
+
+- Makes the native adapter the default owner of `openai-codex`; auth-only integrations may explicitly set `nativeAdapter: false`, while the legacy `openai-codex-native` route remains opt-in.
+- Keeps profile-specific provider removal and migration out of this package; integration bundles must release any existing `openai-codex` route before mounting it.
+- Existing rc.6 pi-ai replay degrades to durable visible history when a production session first continues on the native adapter.
+- Reverse rollback to pi-ai does not guarantee continuation of sessions that already contain native replay; start a new session or continue with a native-enabled integration.
+- Shows the Host-observed `openai-codex` route state in the settings UI, including Native transport mode, external ownership, compatibility-route activity, and unregistered failures without guessing an external adapter identity.
+
+### Usage and Web UI
+
+- Preserves exact `response.completed.usage_metadata.amount` strings across HTTP/SSE and WebSocket and exposes the latest account-scoped observation in status.
+- Parses bounded subscription quota updates directly from WebSocket `codex.rate_limits` events and HTTP/wrapped-WebSocket `x-codex-*` headers, updates the settings card immediately, and skips the redundant turn-end `wham/usage` request while retaining explicit and missing-update fallback refreshes.
+- Hides incomplete weekly quota placeholders when they report 0% usage without a reset timestamp, in both the conversation quota panel and settings card.
+- Shows the conversation quota panel on hover or keyboard focus and reserves clicking the quota ring for an explicit refresh.
+- Adds browser-local Codex model visibility checkboxes that immediately filter the model selector without changing Host routing or existing sessions.
+
+### Security and packaging
+
+- Rejects redirects for credential-bearing OAuth, Catalog, Responses, and subscription-usage requests.
+- Keeps OAuth credentials and account authority host-side, validates credential-bearing endpoint authorities, bounds request/response/replay/WebSocket state, and refuses managed/external credential mismatches.
+- Pins Host/runtime contracts to DSH rc.6 and includes synchronized JavaScript/declaration artifacts plus the complete native transport modules.
+- Keeps the package name `@pure01fx/dsh-openai-codex-auth`; a rename is intentionally deferred.

package/README.md

@@ -3,8 +3,8 @@
 </p>
 
 <p align="center">
-  <strong>把 ChatGPT 订阅登录接入 DeepSeek Harness。</strong><br>
-  设备码优先、浏览器 OAuth 备用；在 DSH 设置页完成登录、查看 Codex 用量，并自动向 <code>openai-codex</code> 模型提供方提供有效凭据。
+  <strong>把 ChatGPT 订阅的 Native Codex Provider 接入 DeepSeek Harness。</strong><br>
+  设备码优先、浏览器 OAuth 备用；默认注册 <code>openai-codex</code>，在 DSH 设置页完成登录、查看用量并直接运行 Codex Responses。
 </p>
 
 <p align="center">
@@ -23,6 +23,8 @@
 dsh plugin --profile web add @pure01fx/dsh-openai-codex-auth
 ```
 
+Native Adapter 默认持有 `openai-codex`。如果现有整合包仍把该 route 配给 `llm-pi-ai` 或其他 Adapter，应由整合包先释放该 route；不要同时挂载两个 owner。只需要本插件的 OAuth/UI 时可显式设置 `nativeAdapter: false`。
+
 开发 checkout 也可直接使用本地路径：
 
 ```sh
@@ -78,8 +80,10 @@ http://localhost:1455/auth/callback
 | --- | --- |
 | 设备码登录 | 无本机 callback，支持远程/headless 使用 |
 | 浏览器 OAuth fallback | PKCE + state、端到端 1455 探测、手动 code 回填和临时 callback listener |
-| Codex 用量面板 | 展示短周期与周用量、剩余额度和重置时间 |
-| 输入框额度圈 | 登录后显示在输入框右下角；Codex turn 结束或点击圆圈时刷新，不做常驻额度轮询 |
+| Codex 用量面板 | 展示短周期与周用量、剩余额度和重置时间；Native 模式直接接收 Codex 返回的套餐额度，`wham/usage` 仅作初始读取和 fallback |
+| 当前路由状态 | 设置页显示 `openai-codex` 当前由本插件 Native Adapter、外部 Adapter 或无人持有；Native 模式同时显示 WebSocket v2 或 HTTP/SSE |
+| 输入框额度圈 | 登录后显示在输入框右下角；悬停或键盘聚焦显示用量，点击圆圈强制刷新，不做常驻额度轮询 |
+| 模型列表隐藏 | 在 Codex 设置页勾选不想看到的模型；只保存在当前浏览器并立即过滤模型选择器，不影响已有会话或 Host 路由 |
 | 自动凭据续期 | 在令牌接近过期时刷新，并更新 DSH credentials |
 | DSH 模型接入 | 将有效令牌提供给 `openai-codex` 模型提供方 |
 | 登录生命周期管理 | 支持取消、15 分钟设备码超时、10 分钟浏览器超时和安全退出 |
@@ -96,7 +100,7 @@ http://localhost:1455/auth/callback
 1. 凭据以 owner-only 权限原子写入 `$DSH_HOME/openai-codex-auth.json`。
 2. access token 通过 DSH credentials 注入 `DSH_OPENAI_CODEX_TOKEN`。
 3. `openai-codex` 模型提供方在请求时读取该凭据。
-4. 输入框右下角显示 Codex 额度圈；插件在 Codex turn 结束或用户点击圆圈时读取用量，不运行常驻额度轮询。
+4. 输入框右下角显示 Codex 额度圈；悬停或键盘聚焦显示当前用量，点击才强制刷新。Native transport 优先消费 WebSocket `codex.rate_limits` 事件或 HTTP `x-codex-*` headers，未收到直接更新时才在 turn 结束后读取 `wham/usage`。
 5. 设置页与额度圈只读取登录状态、账号 ID、过期时间和用量摘要，不接触 token。
 
 ## 同源路由
@@ -173,6 +177,29 @@ $DSH_HOME/openai-codex-auth.json
 
 `path` 的优先级高于 `dshHome`。
 
+### 原生 Codex transport 与组合边界
+
+本包跟踪的上游 Codex repository、commit、release 与 Catalog client version 只在 `src/upstream.ts` 维护；升级上游时先更新该文件，再刷新 fixtures、生成产物和兼容测试，避免多个散落 hash 漂移。
+
+从 0.6 开始，Native Adapter 是插件默认 Provider，并持有生产 route `openai-codex`。旧预览会话确实需要时，可显式设置 `nativeCompatibilityRoute: true`，让同一个 adapter 同时注册 `openai-codex-native` 兼容 route；启用兼容 route 时两者仍原子注册，任一 route 已被占用都会整体失败。默认只暴露生产 route。
+
+本包只定义 Codex Provider，不发布或改写任何具体 Profile。整合包必须在挂载本插件前释放已有的 `openai-codex` route，例如从自己的 `llm-pi-ai` provider map 中移除该项；本包不会清空未知的 sibling providers。只想复用 OAuth/UI 并继续使用外部 Provider 的组合可以显式设置 `nativeAdapter: false`。从 pi-ai 切到 Native 时，旧 foreign replay 会降级为可见持久历史；反向切回 pi-ai 后，已产生 Native replay 的进行中 session 不保证可续跑，应新建 session。
+
+原生 route 默认使用 Responses WebSocket v2，在会话首个请求上执行 `generate: false` prewarm，并仅在请求历史严格延伸时发送 `previous_response_id` 与增量后缀。连接重建会清除增量链；纯 WebSocket/HTTP 连接建立失败不消耗普通 stream retry 预算，而是按 Codex 的网络恢复策略从 5 秒指数退避到 60 秒并持续等待成功或取消，因此可跨越半分钟断网。连接已经建立后的首个 DSH chunk 前错误仍使用默认 5 次 stream retry 与 200ms 起步的有界指数退避，安全重试耗尽或握手返回 HTTP 426 后，该 DSH 会话会确定性地回退到 HTTP/SSE。transport 层在任何 DSH chunk 已输出后仍不会直接重放原始 stream；它会把瞬态中断重新分类为只允许 durable failed-step 恢复的错误，标准 Agent Profile 中的 `dsh-llm-retry` 再按默认 5 次策略重建请求。该外层策略不会再次匹配 transport 已在首个 chunk 前耗尽的有限 stream 错误，避免两层预算相乘；失败 attempt 的原始事件可以留作非 surface 诊断，但不会组装成模型可见的持久 assistant message。未加载该恢复插件的直接 `ctx.llm.stream()` 调用在首个 chunk 后仍保持 single-attempt，避免重复输出。WebSocket `codex.rate_limits` 事件、握手/错误 metadata 以及 HTTP/SSE response headers 中的 `x-codex-*` quota 会被边界校验后直接写入 Host 用量缓存；额外 metered limit 不会覆盖默认 `codex` 套餐卡片。`response.completed.usage_metadata.amount` 会按原始高精度字符串保留，并作为当前账号的最近响应观测出现在 status JSON 中。
+
+`<base>-fast` 只是公开选择别名：wire model 仍是 `<base>`，请求携带 `service_tier: priority`。若账号目录不声明 priority 能力，或请求前账号 authority 已改变，Fast 会直接失败，不会静默降级。Reasoning 选择在 adapter 边界按上游规则转换：`persistent` 在线上请求中写为 `disabled`；`ultra` 优先使用 Catalog 的 `multi_agent_reasoning_effort`，否则回退到 `max`、最高非 Ultra 档或 `medium`。
+
+```yaml
+- insert:
+    - id: openai-codex-auth
+      name: '@pure01fx/dsh-openai-codex-auth'
+      config:
+        nativeAdapter: true # 默认值；只使用外部 Provider 时显式设为 false
+        nativeCompatibilityRoute: false # 默认值；仅续跑旧预览 session 时设为 true
+        nativeWebSocket: true # 默认值；设为 false 可强制使用 HTTP/SSE
+```
+
+
 ## 凭据处理边界
 
 以下内容说明插件如何处理本地凭据与管理接口，不代表或承诺任何 OpenAI 账号风控结果。
@@ -181,6 +208,7 @@ $DSH_HOME/openai-codex-auth.json
 - 设备码由 Host 轮询；Web 页面只看到用户码、验证网址和过期时间。
 - 凭据目录与文件分别以 owner-only 权限创建，并通过文件锁和原子写入更新。
 - access token 与 refresh token 只保存在 Host 侧；Web 页面不会读取或保存它们。
+- OAuth、Catalog、Responses 与用量请求均拒绝 HTTP redirect，避免 credential-bearing 请求进入重定向链。
 - 管理路由复用 DSH `trustedHosts`，并检查 Host、Origin、Fetch Metadata 和 CSRF。
 - 临时 callback Server 只绑定 IPv4/IPv6 loopback 的 1455，并只接受注册 URI 对应的 `Host: localhost:1455`、`/auth/callback` 路径和匹配的 state。
 - 浏览器连通性探测使用 flow 专属随机 URL，只向 HTTP `127.0.0.1`/`localhost` Origin 返回 CORS 结果；手动 code 提交受同源管理检查和 CSRF 保护，粘贴完整 URL 时还会校验 state。

package/client.js

@@ -10,9 +10,45 @@ window.__ModuleLoader__.load({
     const BASE = '/openai-codex'
     const PLUGIN_ID = '@pure01fx/dsh-openai-codex-auth'
     const statusSubscribers = new Set()
+    const HIDDEN_MODELS_KEY = 'dsh.openai-codex.hidden-models.v1'
+    const AVAILABLE_MODELS_KEY = 'dsh.openai-codex.available-models.v1'
+    const MODEL_VISIBILITY_EVENT = 'dsh:openai-codex-model-visibility'
+    const MODEL_CATALOG_EVENT = 'dsh:openai-codex-model-catalog'
     let sharedStatus = null
     let statusRequestGeneration = 0
 
+    function storedJson(key, fallback) {
+      try {
+        const value = JSON.parse(window.localStorage.getItem(key) || 'null')
+        return value === null ? fallback : value
+      } catch {
+        return fallback
+      }
+    }
+
+    function readModelVisibility() {
+      const availableValue = storedJson(AVAILABLE_MODELS_KEY, [])
+      const hiddenValue = storedJson(HIDDEN_MODELS_KEY, [])
+      const available = Array.isArray(availableValue)
+        ? availableValue.slice(0, 512).filter((model) => model && typeof model.id === 'string'
+          && model.id.length > 0 && typeof model.name === 'string' && model.name.length > 0)
+        : []
+      const hidden = Array.isArray(hiddenValue)
+        ? [...new Set(hiddenValue.slice(0, 512).filter((id) => typeof id === 'string' && id.length > 0))]
+        : []
+      return { available, hidden }
+    }
+
+    function writeHiddenModels(hidden) {
+      try {
+        window.localStorage.setItem(HIDDEN_MODELS_KEY, JSON.stringify(hidden))
+        window.dispatchEvent(new CustomEvent(MODEL_VISIBILITY_EVENT, { detail: hidden }))
+        return true
+      } catch {
+        return false
+      }
+    }
+
     const css = `
       .codexSection{box-sizing:border-box;max-width:720px;color:var(--dsw-alias-label-primary);display:flex;flex-direction:column;gap:12px}
       .codexSection *{box-sizing:border-box}.codexTitle{color:var(--dsw-alias-label-primary);margin:0;font-size:16px;font-weight:500;line-height:24px}
@@ -35,6 +71,8 @@ window.__ModuleLoader__.load({
       .codexBar{height:6px;margin:10px 0 8px;overflow:hidden;border-radius:999px;background:var(--dsw-alias-bg-layer-1)}.codexBarFill{height:100%;border-radius:inherit;background:var(--dsw-alias-state-success-primary);transition:width .25s ease}.codexBarFill.high{background:var(--dsw-alias-state-warn-label)}
       .codexReset{font-size:12px;color:var(--dsw-alias-label-tertiary)}
       .codexPlan{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:2px}.codexPlan strong{font-size:14px;font-weight:500}.codexPlan span{font-size:12px;color:var(--dsw-alias-label-tertiary)}
+      .codexRoute{margin-bottom:14px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;padding:11px 12px;background:var(--dsw-alias-bg-layer-2)}.codexRouteHead{display:flex;align-items:center;justify-content:space-between;gap:12px}.codexRouteHead strong{font-size:13px;font-weight:500}.codexRouteValue{margin-top:5px;color:var(--dsw-alias-label-primary);font:12px/18px ui-monospace,SFMono-Regular,Consolas,monospace;overflow-wrap:anywhere}.codexRouteDetail{margin:3px 0 0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
+      .codexModelVisibility{margin-top:14px;border-top:1px solid var(--dsw-alias-border-l2);padding-top:14px}.codexModelVisibilityHead{display:flex;align-items:center;justify-content:space-between;gap:12px}.codexModelVisibilityHead strong{font-size:13px;font-weight:500}.codexModelVisibilityHint{margin:4px 0 8px;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}.codexModelVisibilityList{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;max-height:220px;overflow:auto}.codexModelVisibilityOption{display:flex;align-items:flex-start;gap:8px;min-width:0;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:7px 8px;background:var(--dsw-alias-bg-layer-2);font-size:12px;line-height:18px;cursor:pointer}.codexModelVisibilityOption input{margin:2px 0 0;flex:none}.codexModelVisibilityOption span{min-width:0;overflow-wrap:anywhere}.codexModelVisibilityReset{border:0;background:transparent;color:var(--dsw-alias-label-secondary);padding:0;font:12px/18px inherit;cursor:pointer}.codexModelVisibilityReset:disabled{color:var(--dsw-alias-label-dimmed);cursor:default}
       .codexNotice,.codexWarning,.codexError{margin:14px 0 0;border-radius:8px;padding:8px 10px;background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}
       .codexWarning{color:var(--dsw-alias-state-warn-label)}.codexError{color:var(--dsw-alias-state-error-primary);overflow-wrap:anywhere}
       .codexDevice{margin-top:14px;border:1px solid var(--dsw-alias-brand-primary);border-radius:10px;padding:14px;background:var(--dsw-alias-interactive-bg-hover)}
@@ -47,10 +85,10 @@ window.__ModuleLoader__.load({
       .codexField{display:block;margin-top:14px}.codexFieldLabel{display:block;margin-bottom:6px;color:var(--dsw-alias-label-secondary);font-size:12px}.codexInput{display:block;width:100%;min-height:36px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:7px 10px;background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-primary);font:13px/20px ui-monospace,SFMono-Regular,Consolas,monospace}.codexInput:focus{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}.codexInput::placeholder{color:var(--dsw-alias-label-dimmed)}
       .codexEmpty{padding:4px 0;color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:20px}.codexSkeleton{height:8px;margin:10px 0;border-radius:99px;background:linear-gradient(90deg,var(--dsw-alias-bg-layer-2),var(--dsw-alias-interactive-bg-hover-solid),var(--dsw-alias-bg-layer-2));background-size:200% 100%;animation:codexPulse 1.2s infinite}
       .codexQuotaRoot{display:inline-flex;position:relative}.codexQuotaTrigger{width:28px;height:28px;color:var(--dsw-alias-label-secondary);cursor:pointer;background:transparent;border:none;border-radius:999px;flex:none;place-items:center;display:grid}.codexQuotaTrigger:hover{background:var(--dsw-alias-interactive-bg-hover)}.codexQuotaTrigger:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}
-      .codexQuotaTrack{fill:none;stroke:var(--dsw-alias-border-l3);stroke-width:2px}.codexQuotaAvailable{fill:none;stroke:var(--dsw-alias-state-success-primary);stroke-width:2px;transition:stroke .25s ease}.codexQuotaAvailable.high{stroke:var(--dsw-alias-state-warn-label)}.codexQuotaAvailable.critical{stroke:var(--dsw-alias-state-error-primary)}.codexQuotaConsumed{fill:none;stroke:var(--dsw-alias-border-l3);stroke-width:2px;stroke-linecap:round;transition:stroke-dasharray .25s ease}.codexQuotaLoading{animation:codexQuotaPulse .8s ease-in-out infinite alternate}
+      .codexQuotaTrack{fill:none;stroke:var(--dsw-alias-border-l3);stroke-width:2px}.codexQuotaAvailable{fill:none;stroke:var(--dsw-alias-state-success-primary);stroke-width:2px;stroke-linecap:round;transition:stroke .25s ease,stroke-dasharray .25s ease,stroke-dashoffset .25s ease}.codexQuotaAvailable.high{stroke:var(--dsw-alias-state-warn-label)}.codexQuotaAvailable.critical{stroke:var(--dsw-alias-state-error-primary)}.codexQuotaLoading{animation:codexQuotaPulse .8s ease-in-out infinite alternate}
       .codexQuotaPanel{z-index:100;box-sizing:border-box;width:272px;border:1px solid var(--dsw-alias-border-inverted);border-radius:12px;padding:12px;background:var(--dsw-specific-menu);box-shadow:var(--dsw-shadow-lv3);color:var(--dsw-alias-label-secondary);cursor:default;font-size:12px;line-height:20px;position:absolute;right:0;bottom:calc(100% + 8px)}.codexQuotaPanelHead{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:8px}.codexQuotaPanelHead strong{color:var(--dsw-alias-label-primary);font-size:13px;font-weight:500}.codexQuotaPanelHead span{color:var(--dsw-alias-label-tertiary)}
       .codexQuotaWindow{padding:7px 0}.codexQuotaWindow+.codexQuotaWindow{border-top:1px solid var(--dsw-alias-border-l2)}.codexQuotaWindowHead{display:flex;align-items:center;justify-content:space-between;gap:10px}.codexQuotaWindowHead strong{font-weight:500;color:var(--dsw-alias-label-secondary)}.codexQuotaWindowHead span{font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-primary)}.codexQuotaBar{height:4px;margin:6px 0;border-radius:999px;overflow:hidden;background:var(--dsw-alias-interactive-bg-hover)}.codexQuotaBarFill{height:100%;border-radius:inherit;background:var(--dsw-alias-state-success-primary)}.codexQuotaBarFill.high{background:var(--dsw-alias-state-warn-label)}.codexQuotaBarFill.critical{background:var(--dsw-alias-state-error-primary)}.codexQuotaReset{color:var(--dsw-alias-label-tertiary)}.codexQuotaMessage{margin:4px 0;color:var(--dsw-alias-label-tertiary)}.codexQuotaMessage.error{color:var(--dsw-alias-state-error-primary)}
-      @keyframes codexPulse{to{background-position:-200% 0}}@keyframes codexQuotaPulse{to{opacity:.35}}@media(prefers-reduced-motion:reduce){.codexSkeleton,.codexQuotaLoading{animation:none}}@media(max-width:620px){.codexHero{padding:14px;flex-direction:column}.codexBody{padding:14px}.codexGrid{grid-template-columns:1fr}.codexCode{font-size:20px}}
+      @keyframes codexPulse{to{background-position:-200% 0}}@keyframes codexQuotaPulse{to{opacity:.35}}@media(prefers-reduced-motion:reduce){.codexSkeleton,.codexQuotaLoading{animation:none}}@media(max-width:620px){.codexHero{padding:14px;flex-direction:column}.codexBody{padding:14px}.codexGrid,.codexModelVisibilityList{grid-template-columns:1fr}.codexCode{font-size:20px}}
     `
     if (typeof document !== 'undefined' && document.querySelector('style[data-plugin="' + PLUGIN_ID + '"]') === null) {
       const style = document.createElement('style')
@@ -102,6 +140,11 @@ window.__ModuleLoader__.load({
       return relative + ' · ' + date.toLocaleString([], { month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit' })
     }
 
+    function displayQuotaWindow(window) {
+      if (!window) return false
+      return !(Number(window.usedPercent) === 0 && !Number.isFinite(window.resetAt))
+    }
+
     function formatCountdown(expiresAt, now) {
       const seconds = Math.max(0, Math.ceil((Number(expiresAt) - now) / 1000))
       return Math.floor(seconds / 60) + ':' + String(seconds % 60).padStart(2, '0')
@@ -119,6 +162,41 @@ window.__ModuleLoader__.load({
       }
     }
 
+    function routePresentation(route) {
+      if (!route) return null
+      const provider = route.provider || 'openai-codex'
+      const registeredName = route.registeredName && route.registeredName !== provider ? ' · ' + route.registeredName : ''
+      if (route.owner === 'native') {
+        const transport = route.transport === 'http-sse' ? 'HTTP/SSE' : 'WebSocket v2'
+        const compatibility = route.compatibilityRoute && route.compatibilityRoute.active ? '；兼容路由已启用' : ''
+        return {
+          title: '原生 Codex Adapter',
+          value: provider + ' · ' + transport,
+          detail: route.active
+            ? '当前由本插件直接处理模型请求' + compatibility + '。'
+            : '已配置 Native Adapter，但生产路由尚未注册。',
+          tone: route.active ? 'connected' : 'pending',
+          state: route.active ? '已激活' : '未激活',
+        }
+      }
+      if (route.owner === 'external') {
+        return {
+          title: '外部 Adapter',
+          value: provider + registeredName,
+          detail: '本插件当前只提供登录与凭据；模型请求由其他 Adapter 处理。DSH rc.6 不公开其具体 owner 身份。',
+          tone: 'connected',
+          state: '已激活',
+        }
+      }
+      return {
+        title: '未注册模型路由',
+        value: provider,
+        detail: '当前没有 Adapter 持有生产 Codex 路由，模型请求将不可用。',
+        tone: 'pending',
+        state: '不可用',
+      }
+    }
+
     async function copyText(text) {
       if (navigator.clipboard && navigator.clipboard.writeText) {
         await navigator.clipboard.writeText(text)
@@ -222,17 +300,25 @@ window.__ModuleLoader__.load({
       if (!status || !status.loggedIn) return null
       const usage = status.usage
       const primary = usage && usage.primary
-      const secondary = usage && usage.secondary
+      const secondary = usage && displayQuotaWindow(usage.secondary) ? usage.secondary : null
       const meter = primary || secondary
       const used = meter ? Math.max(0, Math.min(100, Number(meter.usedPercent) || 0)) : 0
-      const reading = meter ? Math.max(0, Math.round(100 - used)) + '%' : '待更新'
-      const title = loading ? '正在刷新 Codex 额度' : 'Codex 额度剩余 ' + reading
+      const remaining = Math.max(0, 100 - used)
+      const reading = meter ? Math.round(remaining) + '%' : '待更新'
+      const title = loading ? '正在刷新 Codex 额度' : 'Codex 额度剩余 ' + reading + '；点击刷新'
       const circumference = 2 * Math.PI * 5.5
+      const usedLength = circumference * used / 100
+      const remainingLength = circumference - usedLength
       const windows = []
       if (primary) windows.push({ name: quotaWindowName(primary, false), window: primary })
       if (secondary) windows.push({ name: quotaWindowName(secondary, true), window: secondary })
 
-      return h('span', { ref: rootRef, className: 'codexQuotaRoot' },
+      return h('span', {
+        ref: rootRef,
+        className: 'codexQuotaRoot',
+        onMouseEnter: () => { setOpen(true) },
+        onMouseLeave: () => { setOpen(false) },
+      },
         h('button', {
           type: 'button',
           className: 'codexQuotaTrigger' + (loading ? ' codexQuotaLoading' : ''),
@@ -240,21 +326,22 @@ window.__ModuleLoader__.load({
           'aria-label': title,
           'aria-haspopup': 'dialog',
           'aria-expanded': open,
+          onFocus: () => { setOpen(true) },
+          onBlur: (event) => {
+            if (!rootRef.current || !rootRef.current.contains(event.relatedTarget)) setOpen(false)
+          },
           onClick: () => {
-            setOpen((value) => !value)
+            setOpen(true)
             void load(true)
           },
         },
         h('svg', { viewBox: '0 0 14 14', width: '14', height: '14', 'aria-hidden': true },
           h('circle', { className: 'codexQuotaTrack', cx: '7', cy: '7', r: '5.5' }),
-          meter ? h('circle', {
+          meter && remaining > 0 ? h('circle', {
             className: 'codexQuotaAvailable' + quotaTone(used),
             cx: '7', cy: '7', r: '5.5',
-          }) : null,
-          meter && used > 0 ? h('circle', {
-            className: 'codexQuotaConsumed',
-            cx: '7', cy: '7', r: '5.5',
-            strokeDasharray: (circumference * used / 100) + ' ' + circumference,
+            strokeDasharray: remainingLength + ' ' + usedLength,
+            strokeDashoffset: -usedLength,
             transform: 'rotate(-90 7 7)',
           }) : null,
         )),
@@ -265,7 +352,7 @@ window.__ModuleLoader__.load({
           ),
           windows.length > 0
             ? windows.map((row) => h(QuotaWindow, { key: row.name, name: row.name, window: row.window }))
-            : h('p', { className: 'codexQuotaMessage' }, '点击圆圈读取最新额度。'),
+            : h('p', { className: 'codexQuotaMessage' }, '点击圆圈刷新最新额度。'),
           status.usageError ? h('p', { className: 'codexQuotaMessage error', role: 'status' }, '额度读取失败：' + status.usageError) : null,
           error ? h('p', { className: 'codexQuotaMessage error', role: 'status' }, '无法连接额度接口：' + error) : null,
         ) : null,
@@ -281,8 +368,46 @@ window.__ModuleLoader__.load({
       const [probe, setProbe] = useState({ state: 'idle', message: '' })
       const [manualInput, setManualInput] = useState('')
       const [now, setNow] = useState(Date.now())
+      const [modelVisibility, setModelVisibility] = useState(readModelVisibility)
       const probeGeneration = useRef(0)
 
+      useEffect(() => {
+        const reload = () => { setModelVisibility(readModelVisibility()) }
+        const storage = (event) => {
+          if (event.key === HIDDEN_MODELS_KEY || event.key === AVAILABLE_MODELS_KEY) reload()
+        }
+        window.addEventListener(MODEL_CATALOG_EVENT, reload)
+        window.addEventListener('storage', storage)
+        return () => {
+          window.removeEventListener(MODEL_CATALOG_EVENT, reload)
+          window.removeEventListener('storage', storage)
+        }
+      }, [])
+
+      const updateHiddenModel = useCallback((modelId, hidden) => {
+        setModelVisibility((current) => {
+          const ids = new Set(current.hidden)
+          if (hidden) ids.add(modelId)
+          else ids.delete(modelId)
+          const next = [...ids]
+          if (!writeHiddenModels(next)) {
+            setError('浏览器无法保存模型隐藏设置。')
+            return current
+          }
+          setError('')
+          return { ...current, hidden: next }
+        })
+      }, [])
+
+      const resetHiddenModels = useCallback(() => {
+        if (!writeHiddenModels([])) {
+          setError('浏览器无法保存模型隐藏设置。')
+          return
+        }
+        setError('')
+        setModelVisibility((current) => ({ ...current, hidden: [] }))
+      }, [])
+
       const load = useCallback(async (refresh) => {
         try {
           const value = await requestStatus(refresh)
@@ -466,11 +591,19 @@ window.__ModuleLoader__.load({
       const browserPending = Boolean(status && status.loginMethod === 'browser' && status.browser)
       const browserAvailable = Boolean(status && browserLoginAvailable(status.browserCallbackUrl))
       const plan = usage && usage.planType ? String(usage.planType).toUpperCase() : 'ChatGPT 订阅'
+      const usageSource = usage && usage.source === 'response' ? 'Codex 返回' : '额度接口'
+      const creditNotice = usage && usage.credits
+        ? usage.credits.unlimited ? 'Codex Credits：无限'
+          : usage.credits.hasCredits
+            ? 'Codex Credits' + (usage.credits.balance ? ' 余额：' + usage.credits.balance : '：可用')
+            : 'Codex Credits：不可用'
+        : null
+      const route = routePresentation(status && status.route)
       const windows = useMemo(() => {
         if (!usage) return []
         const rows = []
         if (usage.primary) rows.push({ name: usage.primary.windowSeconds === 18000 ? '5 小时额度' : '短周期额度', window: usage.primary })
-        if (usage.secondary) rows.push({ name: '周额度', window: usage.secondary })
+        if (displayQuotaWindow(usage.secondary)) rows.push({ name: '周额度', window: usage.secondary })
         return rows
       }, [usage])
 
@@ -491,15 +624,52 @@ window.__ModuleLoader__.load({
             ),
           ),
           h('div', { className: 'codexBody' },
+            route
+              ? h('div', { className: 'codexRoute' },
+                  h('div', { className: 'codexRouteHead' },
+                    h('strong', null, '当前模型路由'),
+                    h('span', { className: 'codexBadge ' + route.tone },
+                      h('span', { className: 'codexDot', 'aria-hidden': true }), route.state,
+                    ),
+                  ),
+                  h('div', { className: 'codexRouteValue' }, route.title + ' · ' + route.value),
+                  h('p', { className: 'codexRouteDetail' }, route.detail),
+                )
+              : null,
             loading
               ? h('div', { 'aria-label': '加载中' }, h('div', { className: 'codexSkeleton' }), h('div', { className: 'codexSkeleton', style: { width: '72%' } }))
               : connected
                 ? h(React.Fragment, null,
-                    h('div', { className: 'codexPlan' }, h('strong', null, plan), h('span', null, usage && usage.fetchedAt ? '更新于 ' + new Date(usage.fetchedAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : '额度信息待更新')),
+                    h('div', { className: 'codexPlan' }, h('strong', null, plan), h('span', null, usage && usage.fetchedAt ? '更新于 ' + new Date(usage.fetchedAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) + ' · ' + usageSource : '额度信息待更新')),
                     windows.length > 0
                       ? h('div', { className: 'codexGrid' }, windows.map((row) => h(UsageCard, { key: row.name, name: row.name, window: row.window })))
                       : h('p', { className: 'codexEmpty' }, '账号已连接，暂时没有返回可展示的额度窗口。'),
                     usage && Number.isFinite(usage.resetCredits) ? h('p', { className: 'codexNotice' }, '可用额度重置次数：' + usage.resetCredits) : null,
+                    creditNotice ? h('p', { className: 'codexNotice' }, creditNotice) : null,
+                    h('div', { className: 'codexModelVisibility' },
+                      h('div', { className: 'codexModelVisibilityHead' },
+                        h('strong', null, '模型列表显示'),
+                        h('button', {
+                          type: 'button',
+                          className: 'codexModelVisibilityReset',
+                          disabled: modelVisibility.hidden.length === 0,
+                          onClick: resetHiddenModels,
+                        }, '全部显示'),
+                      ),
+                      h('p', { className: 'codexModelVisibilityHint' }, '勾选要隐藏的模型；只影响当前浏览器中的模型选择列表，不会禁用模型或改变已有会话。'),
+                      modelVisibility.available.length > 0
+                        ? h('div', { className: 'codexModelVisibilityList' }, modelVisibility.available.map((model) =>
+                            h('label', { className: 'codexModelVisibilityOption', key: model.id },
+                              h('input', {
+                                type: 'checkbox',
+                                checked: modelVisibility.hidden.includes(model.id),
+                                onChange: (event) => { updateHiddenModel(model.id, event.target.checked) },
+                              }),
+                              h('span', null, model.name === model.id ? model.id : model.name + ' · ' + model.id),
+                            ),
+                          ))
+                        : h('p', { className: 'codexEmpty' }, '打开一个会话的模型列表后，这里会显示可隐藏的 Codex 模型。'),
+                    ),
                     status.usageError ? h('p', { className: 'codexError', role: 'status' }, '额度读取失败：' + status.usageError) : null,
                   )
                 : h('p', { className: 'codexEmpty' }, '设备码登录可在任意设备完成授权，令牌只由 Host 保存和刷新，Web 页面不会读取令牌。'),

package/cordis.patch.yml

@@ -1,9 +1,5 @@
-- id: llm-pi-ai
-  config:
-    providers:
-      openai-codex:
-        apiKeyEnv: DSH_OPENAI_CODEX_TOKEN
-
+# Native Codex is the package default. Integration bundles own any removal or
+# replacement of an existing openai-codex route before mounting this plugin.
 - insert:
     - id: openai-codex-auth
       name: '@pure01fx/dsh-openai-codex-auth'

package/lib/catalog.d.ts

@@ -0,0 +1,77 @@
+export { CODEX_CLIENT_VERSION } from './upstream.js';
+export declare const CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models";
+export declare const CODEX_CATALOG_CACHE_TTL_MS: number;
+/** One request-scoped credential for native Codex backend calls. */
+export interface NativeCodexCredential {
+    accessToken: string;
+    accountId: string;
+}
+/** Resolve current native Codex authority without retaining it across operations. */
+export type NativeCodexCredentialResolver = (signal?: AbortSignal) => Promise<NativeCodexCredential>;
+export interface NativeCodexReasoningLevel {
+    effort: string;
+    description?: string;
+}
+export interface NativeCodexServiceTier {
+    id: string;
+    name?: string;
+    description?: string;
+}
+/** Validated subset of codex-rs ModelInfo used by DSH metadata and later transport milestones. */
+export interface NativeCodexModel {
+    slug: string;
+    displayName: string;
+    description?: string;
+    defaultReasoningLevel?: string;
+    supportedReasoningLevels: readonly NativeCodexReasoningLevel[];
+    multiAgentReasoningEffort?: string;
+    visibility: string;
+    supportedInApi: boolean;
+    priority: number;
+    additionalSpeedTiers: readonly string[];
+    serviceTiers: readonly NativeCodexServiceTier[];
+    defaultServiceTier?: string;
+    contextWindow?: number;
+    inputModalities: readonly string[];
+}
+export interface NativeCodexCatalogView {
+    models: readonly NativeCodexModel[];
+    authorityHash?: string;
+}
+/** Narrow catalog seam consumed by the adapter and injectable in tests. */
+export interface NativeCodexModelCatalog {
+    list(signal?: AbortSignal): Promise<readonly NativeCodexModel[]>;
+    listWithAuthority?(signal?: AbortSignal): Promise<NativeCodexCatalogView>;
+    etag(): string | undefined;
+}
+export interface NativeCodexCatalogOptions {
+    resolveCredential: NativeCodexCredentialResolver;
+    endpoint?: string;
+    clientVersion?: string;
+    cacheTtlMs?: number;
+    maxStaleMs?: number;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    now?: () => number;
+    warn?: (message: string) => void;
+}
+export declare function nativeCodexAuthorityHash(accountId: string): string;
+/** Codex-compatible live catalog with bounded stale fallback and no credential retention. */
+export declare class NativeCodexCatalog implements NativeCodexModelCatalog {
+    private readonly options;
+    private readonly endpoint;
+    private readonly clientVersion;
+    private readonly cacheTtlMs;
+    private readonly maxStaleMs;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    private readonly now;
+    private snapshot;
+    private readonly refreshes;
+    private currentEtag;
+    constructor(options: NativeCodexCatalogOptions);
+    etag(): string | undefined;
+    list(signal?: AbortSignal): Promise<readonly NativeCodexModel[]>;
+    listWithAuthority(signal?: AbortSignal): Promise<NativeCodexCatalogView>;
+    private fetchCatalog;
+}