@pure01fx/dsh-openai-codex-auth 0.11.0 → 0.11.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.11.2
+
+- Requests the live model catalog as Codex 0.155.0 so version-gated GPT-6 Sol can be advertised; preserves dynamic account-specific discovery and routes exact Sol requests through Responses Lite when catalog metadata is unavailable. Fast remains catalog-authorized.
+- Classifies `slow_down` as a rate limit with bounded provider wait hints, recognizes credit/organization/project quota exhaustion, and distinguishes `INVALID_PROMPT` across HTTP, SSE, and WebSocket errors without retrying permanent failures or switching transports.
+- Preserves validated image request IDs and HTTP status on rejected responses and malformed JSON/UTF-8, without exposing credential echoes or retrying ambiguous image POSTs.
+
+## 0.11.1
+
+- Adds live network status and process-wide request, retry, and received-payload statistics to the quota panel, distinguishing network activity from model output.
+- Shows a breathing quota indicator during unbounded connection recovery, including while the panel is closed; respects reduced-motion preferences and clears the indicator after recovery, cancellation, or stale status updates.
+- Exposes bounded, content-free telemetry through the protected local network endpoint without additional upstream quota requests or changes to timeout and retry behavior.
+
 ## 0.11.0
 
 - Removes plugin payload byte ceilings for native and cloud requests, SSE events, WebSocket messages and queues, response accumulation, encrypted replay state, model catalogs, and image data; removes the corresponding transport options, including `maxRequestBodyBytes`. WebSocket disables the underlying `ws` message-size ceiling explicitly.

package/CODEX-COMPATIBILITY.md

@@ -1,5 +1,59 @@
 # Codex 云端能力兼容性跟踪
 
+## 已实现：Sol 与错误协议增量适配（0.11.2）
+
+参考上游 `c44deff7b1083e9660ac55d02122481f1cdf139b`，在既有 0.11.1 工作树上完成以下必要改动。此节取代下方历史审查中相应的“待适配”结论；不代表完整上游运行时对齐。
+
+- 模型目录仍动态获取，查询 `client_version` 升至 `0.155.0`，满足上游 Sol 条目的最低版本。仅为缺失目录 metadata 的精确 `gpt-6-sol` 增加 Lite 路由后备；正常目录的 `use_responses_lite` 仍是依据，Fast 仍须目录授权，未知模型不按名称前缀猜测协议。
+- HTTP 错误正文、SSE `response.failed` 与 WS `error` / `response.failed` 共用安全分类。`slow_down` 按限流处理并保留有界等待提示；新增三类 credit/organization/project 额度错误映射宿主 `QUOTA`；`invalid_prompt` 映射独立的 `INVALID_PROMPT`。这些失败不会在传输内重试、重连或回退 HTTP；原有 WS error 包装的限流代码 `RATE_LIMITED` 保持兼容。
+- 图片生成/编辑 HTTP 失败及 JSON/UTF-8 解码失败，通过正式 LlmError failure 元数据保留状态码和校验后的 requestId。图片专用响应头优先；拒绝非法 ID 与 token/account 回显，不增加图片 POST 重试。
+- 新增来自上游的精简 Sol fixture（含全部六档 reasoning effort），覆盖动态目录、最低版本过滤的模拟服务、metadata 优先、缺目录后备、Fast 权限；HTTP/SSE/WS 回归覆盖上述错误的终止行为和隐私边界。模拟版本过滤验证客户端请求条件，不证明真实账号一定获得 Sol。
+
+验证：`pnpm build`、`pnpm test`（26 文件 / 467 项）、`pnpm typecheck`、`git diff --check` 全部通过；生成产物与新鲜编译一致。已更新相关 `lib/` 产物和 CHANGELOG，保留全部已有工作树改动。没有运行真实账号推理、查询线上目录或发布/替换常驻 GUI 插件；当前进程是否使用新构建未验证。Provider/cloud 原始跟踪提交仍分别保持 `ddf04ad` / `b348fc26`，为集合 0.3.7 准备插件版本 0.11.2；尚未发布。
+
+## 上游增量审查：064e701b（插件 0.11.1 工作树）
+
+本次 `../codex` 从 `b348fc26674189f758d5941cdab3f78f258b2aa7` fast-forward 到 `064e701b0fa4f5c0dcaf195a565d088f99bb6af8`，新增 596 个提交；更新后 HEAD 与本次 fetch 的 origin/main 一致，工作树干净。插件以当前已有未提交改动的 0.11.1 工作树为审查对象（Git HEAD 为 `188abd13430b3fff7782c1ee87e5809c4a2e8e96`），不是仅审查已提交版本。
+
+结论：建议做针对性的兼容适配；目前证据不支持“必须整体重写”或“已完整对齐最新上游”。本次只更新上游并记录审查，没有修改插件运行时代码、跟踪常量或发布版本。
+
+### 优先适配：失败响应分类
+
+上游 `codex-rs/codex-api/src/sse/responses.rs` 的变化直接影响现有推理路径：
+
+- `slow_down` 现在与 `rate_limit_exceeded` 一样表示限流，并解析服务端建议等待时间。插件 `src/responses.ts:333` 的 `responsesFailure` 仅对后者返回 `RATE_LIMIT`，前者落入 `SERVER`。
+- `credit_balance_exhausted`、`organization_spend_limit_exceeded`、`project_spend_limit_exceeded` 现在明确归为额度耗尽。插件未按这些 code 分类；若 message 未命中宿主的额度文本识别，会落入 `SERVER`，影响不可重试额度错误的判断。
+- 已用现有 `lib/responses.js` 直接调用复现：上述四个 code 搭配中性 message 均返回 `SERVER`，对照 `rate_limit_exceeded` 返回 `RATE_LIMIT`。这是本地确定性复现，不是线上故障记录。
+- `bio_policy` 在上游已独立分类；插件仍返回不可重试的 `INVALID_REQUEST`。这是诊断粒度差异，优先级低于限流和额度分类。
+
+建议首个适配单元覆盖错误分类、等待时间，以及 HTTP/SSE、WebSocket 两条传输中的终止/重试语义；仅修改版本号不能解决差异。
+
+### 可按需要扩展的能力
+
+- **WebSocket 握手稳定性**：本次上游将已有 HTTP 基础设施 cookie store 接入 WSS 握手，并从成功或拒绝的 upgrade 响应回收 Set-Cookie（`websocket-client/src/lib.rs:145`）。插件没有对应 cookie store。可作为下一优先级的稳定性适配，但未验证当前账号存在握手故障。HTTP cookie store 是上次基线已有能力，不能将整个缺口归为本次新增；实现时应遵循 host/TLS 和基础设施 cookie allowlist，不共享账号/会话 cookie。
+- **WebSocket 空增量续传**：上游 `core/src/client.rs:1377` 放宽为允许与已完成上下文相等的 input；插件 `src/native-websocket-session.ts:83` 默认仍要求严格增长，仅预热例外。可减少无新增 input 时的全量重发，当前没有数据丢失证据。
+- **目录 access programs**：新增可选 `available_access_programs`，插件未建模；需要对应模型访问计划选择时再接入，不能单凭字段新增判定目录解析失败。
+
+- **工作区路由与 gateway OAuth**：上游增加账号工作区路由发现以及独立 gateway 登录。插件仍限制凭据端点为 chatgpt.com 或 loopback（`src/endpoint.ts`），没有对应发现流程。需要面向这类工作区或网关时再设计端点信任、账号绑定及切换后的缓存/连接隔离。上游 `login/src/auth/manager/workspace_routing.rs:63` 明确保留无 resolver 调用者的旧行为，不能据此认定普通 ChatGPT 登录已失效。
+- **推理强度增量更新**：目录新增 `supports_reasoning_effort_updates`；上游以 `configuration_update` 历史项保留请求基线、减少切换 effort 的缓存损失。该路径受功能开关、provider 和模型能力共同控制（`core/src/client.rs:548`）。插件继续使用请求级参数；属于缓存与功能对齐项目，尚无证据表明普通请求因此不兼容。
+- **图片文件引用**：`protocol/src/models.rs:897` 新增 `ImageReference::File { file_id }`，原有 `image_url` wire 形状仍保留。插件继续发送内联图片；搜索结果只提取 `image_url` 图片，不能将不认识的 file_id 视为已下载附件。可在明确上传、下载和账号作用域后单独接入。
+
+### 深入评估：推理增量更新与 file_id
+
+推理增量更新建议先做有开关的实验，暂不默认启用。插件当前 `responses.ts:245` 将 effort 放在请求属性中，`native-websocket-session.ts:57` 对请求属性做复用哈希，因此 effort 改变会使增量链不满足复用条件。保持请求基线并追加 configuration_update 有明确的客户端复用收益机制，但服务端缓存收益尚未实测。真正成本是持久化：现有 `replay.ts:7` 只记录 message/reasoning/function_call，不能直接表示宿主生成的配置更新及其历史位置。需先确认宿主能否提供稳定的轮次、分叉、压缩边界和持久化扩展点，再决定插件内扩展是否足够，不能只做进程内 sessionId→effort 缓存。验收应覆盖 medium→high→medium、断线/重启、分叉、失败重试、成功/失败压缩、模型切换以及能力缺失时保留请求级 effort。收益验证比较匹配历史的缓存输入量、请求字节数和首 token 延迟，不预设改善比例。
+
+file_id 建议暂缓产品化，先验证后端契约。补充检查发现上游 `attachment-store/src/lib.rs:161` 提供的 InlineAttachmentStore 直接返回原字节；`core/src/thread_manager.rs:498` 默认图片存储仍使用它。`core/src/image_preparation.rs:363` 接受可注入存储返回 File，并在上传失败时回退内联。因而协议存在 file_id 不等于默认 Codex 已经提供现成可复制的图片上传闭环。`codex-api/src/files.rs` 的通用/连接器文件上传也不能未经验证就当成 Responses 图片上传。下一步应以一张合成小图验证上传→finalize→同账号 Responses 识图→引用失效/解析契约；若不能确认接受性与生命周期，继续内联。后续实现优先将远端 ID 作为插件内部、按账号与内容隔离的缓存，保留 DSH 本地附件作恢复依据；应对重新上传、账号切换、并发、取消、签名 URL 凭据隔离，并避免中途改变历史图片表示破坏 WS 前缀。现有 WS 增量已避免重复发送不变历史，因此收益主要在 HTTP、多次新连接或跨请求复用，不能直接宣称节省视觉 token。
+
+本轮为源码评估，无线上请求和运行时代码修改；为读取上游接口追加了 `codex-rs/attachment-store` 稀疏检出目录。
+
+### 当前无需随上游机械改动的接口
+
+本次区间 `codex-api/src/search.rs`、`images.rs`、`endpoint/images.rs` 无变化；`endpoint/search.rs` 保留 `alpha/search`，主要是内部常量和测试类型调整。普通 Responses HTTP/WebSocket 仍使用 `/responses`，移除的是 Guardian 专用分支，不要求插件改路由。模型目录支持自定义 URL 和更多可选元数据，不等于默认目录的旧字段全部失效。
+
+### 验证与边界
+
+`pnpm test`：26 个文件、384 项测试全部通过；`pnpm typecheck` 通过；测试包括现有生成产物与新鲜 TypeScript 编译的一致性校验。未执行真实 OAuth、刷新或付费推理；现有回归通过不覆盖上游所有新增行为。原 Provider 基线 `ddf04ad` 与云能力基线 `b348fc26` 保持不变。下方历史章节中的旧缺口、旧测试数量和账号验证不能自动视为当前工作树结论。
+
 ## DSH 0.1.5-rc.1 版本适配
 
 `0.10.1` 迁移 ToolCallId、精确 SDK 依赖和客户端服务提供包，隐藏策略在目录发布投影之前执行。`tests/target-directory.spec.ts` 执行官方 shell 的真实 store/Zustand/Immer 与目标目录/catalog 类，使用合成 Remote 响应和投影输入；这不是浏览器联合验收。`tests/target-services.spec.ts` 使用真实 Cordis/LlmRuntime/ToolRuntime、真实 loopback HTTP/SSE/WebSocket，验证工具 ID、工具执行、含加密 reasoning 的历史回放、永久错误和取消，并确认 WS 没有偷偷回退 HTTP。实际 socket 测试也修复了 ws 成功回调为 null 时的误判。

package/README.md

@@ -17,7 +17,7 @@
 
 ## 快速开始
 
-版本 `0.11.0` 明确适配 DeepSeek Harness `0.1.5-rc.1`，SDK peers/runtime helpers 精确锁定该版本；不声明兼容旧 SDK。旧 DSH `0.1.1-rc.2` profile 应保留原插件 `0.10.0`，升级时在独立 profile 安装新版插件并保留原 profile/锁文件以便回滚。无需迁移账号文件或浏览器隐藏列表；`dsh.engines` 仅作兼容性说明，不当作宿主硬门禁。
+版本 `0.11.1` 明确适配 DeepSeek Harness `0.1.5-rc.1`，SDK peers/runtime helpers 精确锁定该版本；不声明兼容旧 SDK。旧 DSH `0.1.1-rc.2` profile 应保留原插件 `0.10.0`，升级时在独立 profile 安装新版插件并保留原 profile/锁文件以便回滚。无需迁移账号文件或浏览器隐藏列表；`dsh.engines` 仅作兼容性说明，不当作宿主硬门禁。
 
 本版本通过真实目标 LLM/tools 服务与本地 HTTP/SSE/WebSocket 回放、错误/取消回归；模型隐藏覆盖真实目录/catalog/store 的投影更新、重连和重新加载。验证命令为 `pnpm typecheck && pnpm build && pnpm test`；当前版本未执行线上 OAuth/付费模型验收。
 

package/client.js

@@ -225,6 +225,8 @@ window.__ModuleLoader__.load({
       .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)}
+      .codexNetwork{margin-top:8px;padding-top:10px;border-top:1px solid var(--dsw-alias-border-l2)}.codexNetworkHead,.codexNetworkRow{display:flex;align-items:baseline;justify-content:space-between;gap:12px}.codexNetworkHead{margin-bottom:5px}.codexNetworkHead strong{font-weight:500;color:var(--dsw-alias-label-primary)}.codexNetworkRow>span:first-child,.codexNetworkScope{color:var(--dsw-alias-label-tertiary)}.codexNetworkRow>span:last-child{font-variant-numeric:tabular-nums;text-align:right}.codexNetworkScope{margin:6px 0 0;font-size:11px;line-height:16px}.codexNetworkWarning{color:var(--dsw-alias-state-warn-label)}.codexQuotaPanel{max-height:min(680px,75vh);overflow-y:auto;width:min(300px,calc(100vw - 24px))}
+      .codexQuotaReconnecting .codexQuotaTrigger svg,.codexQuotaReconnecting .codexQuotaBarFill{animation:codexReconnectBreath 2s ease-in-out infinite}.codexQuotaReconnecting .codexQuotaTrack,.codexQuotaReconnecting .codexQuotaAvailable{stroke:var(--dsw-alias-state-warn-label)}@keyframes codexReconnectBreath{0%,100%{opacity:1}50%{opacity:.3}}@media(prefers-reduced-motion:reduce){.codexQuotaReconnecting .codexQuotaTrigger svg,.codexQuotaReconnecting .codexQuotaBarFill{animation:none}}
       @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}.codexAccountOption{align-items:stretch;flex-direction:column;gap:10px}.codexAccountActions{align-self:flex-start}.codexCode{font-size:20px}}
     `
     if (typeof document !== 'undefined' && document.querySelector('style[data-plugin="' + PLUGIN_ID + '"]') === null) {
@@ -408,10 +410,120 @@ window.__ModuleLoader__.load({
       )
     }
 
+    function networkDuration(ms) {
+      const seconds = Math.max(0, Math.floor(ms / 1000))
+      if (seconds < 60) return seconds + ' 秒'
+      return Math.floor(seconds / 60) + ' 分 ' + seconds % 60 + ' 秒'
+    }
+
+    function networkBytes(bytes) {
+      if (bytes < 1024) return Math.round(bytes) + ' B'
+      if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB'
+      return (bytes / 1048576).toFixed(1) + ' MB'
+    }
+
+    function networkSummary(snapshot) {
+      const active = snapshot.requests.filter((request) => !['completed', 'failed', 'cancelled'].includes(request.state))
+      const priority = { retrying: 0, waiting: 1, connecting: 2, preparing: 3, streaming: 4 }
+      const current = active.sort((a, b) => priority[a.state] - priority[b.state] || a.startedAt - b.startedAt)[0]
+        || snapshot.requests.slice().sort((a, b) => b.startedAt - a.startedAt)[0]
+      const labels = { preparing: '准备请求', connecting: '连接中', waiting: '等待响应', streaming: '接收中', retrying: '等待重试', completed: '最近请求已完成', failed: '最近请求失败', cancelled: '最近请求已取消' }
+      const stalled = current && current.state === 'streaming' && snapshot.updatedAt - (current.lastActivityAt || current.startedAt) >= 10000
+      return { current, label: stalled ? '等待后续数据' : current ? labels[current.state] || '状态未知' : '尚无请求', active: active.length > 0 }
+    }
+
+    function useNetworkStats(enabled) {
+      const [sample, setSample] = useState(null)
+      const [error, setError] = useState('')
+      useEffect(() => {
+        if (!enabled) return undefined
+        let disposed = false
+        let timer
+        let controller
+        let timeout
+        let previous
+        const poll = async () => {
+          if (disposed || document.visibilityState === 'hidden') return
+          controller = new AbortController()
+          timeout = window.setTimeout(() => controller.abort(), 5000)
+          try {
+            const response = await fetch(BASE + '/network', { cache: 'no-store', signal: controller.signal })
+            if (!response.ok) throw new Error('HTTP ' + response.status)
+            const snapshot = await response.json()
+            if (!snapshot.totals || !Array.isArray(snapshot.requests)) throw new Error('网络统计暂不可用')
+            const elapsed = previous && snapshot.updatedAt - previous.updatedAt
+            const delta = previous && snapshot.totals.receivedBytes - previous.totals.receivedBytes
+            const rate = previous && previous.startedAt === snapshot.startedAt && elapsed > 0 && delta >= 0
+              ? delta * 1000 / elapsed : null
+            previous = snapshot
+            if (!disposed) { setSample({ snapshot, rate }); setError('') }
+          } catch (failure) {
+            if (!disposed) setError('网络状态更新失败（' + messageOf(failure) + '）')
+          } finally {
+            window.clearTimeout(timeout)
+            controller = null
+            if (!disposed) timer = window.setTimeout(poll, 2000)
+          }
+        }
+        const onVisibility = () => {
+          if (document.visibilityState !== 'hidden' && !controller) {
+            window.clearTimeout(timer)
+            previous = null
+            void poll()
+          }
+        }
+        void poll()
+        document.addEventListener('visibilitychange', onVisibility)
+        return () => {
+          disposed = true
+          window.clearTimeout(timer)
+          window.clearTimeout(timeout)
+          if (controller) controller.abort()
+          document.removeEventListener('visibilitychange', onVisibility)
+        }
+      }, [enabled])
+      return { sample, error }
+    }
+
+    function networkReconnecting(network) {
+      return !network.error && network.sample && network.sample.snapshot.requests.some((request) =>
+        request.retryKind === 'connection' && ['retrying', 'preparing', 'connecting'].includes(request.state))
+    }
+
+    function CodexNetworkStats({ sample, error }) {
+      const snapshot = sample && sample.snapshot
+      const summary = snapshot && networkSummary(snapshot)
+      const current = summary && summary.current
+      const row = (label, value) => h('div', { className: 'codexNetworkRow', key: label }, h('span', null, label), h('span', null, value))
+      return h('section', { className: 'codexNetwork', 'aria-label': 'Codex 网络状态' },
+        h('div', { className: 'codexNetworkHead' }, h('strong', null, '网络'),
+          h('span', { className: error ? 'codexNetworkWarning' : '' }, error ? sample ? '数据已过期' : '读取失败' : summary ? summary.label : '读取中…')),
+        error ? h('p', { className: 'codexQuotaMessage error', role: 'status' }, error) : null,
+        snapshot ? h(React.Fragment, null,
+          row('进行中', snapshot.activeCount + ' 个请求'),
+          current ? row('传输', current.transport === 'websocket' ? 'WebSocket' : 'HTTP / SSE') : null,
+          summary.active && current ? h(React.Fragment, null,
+            row('本次已等待', networkDuration(snapshot.updatedAt - current.startedAt)),
+            row('最近收包', current.lastActivityAt === null ? '尚未收到' : networkDuration(snapshot.updatedAt - current.lastActivityAt) + '前'),
+            row('最近输出', current.lastOutputAt === null ? '尚无输出' : networkDuration(snapshot.updatedAt - current.lastOutputAt) + '前'),
+            current.state === 'retrying' && current.retryAt !== null ? row('下次重试', networkDuration(current.retryAt - snapshot.updatedAt) + '后') : null,
+            row('本次尝试 / 重试', current.attempts + ' / ' + current.retries),
+          ) : null,
+          row('接收速率', error || sample.rate === null ? '—' : networkBytes(sample.rate) + '/s'),
+          row('累计接收', networkBytes(snapshot.totals.receivedBytes)),
+          row('请求 / 成功 / 失败', snapshot.totals.requests + ' / ' + snapshot.totals.succeeded + ' / ' + snapshot.totals.failed),
+          row('累计重试 / 取消', snapshot.totals.retries + ' / ' + snapshot.totals.cancelled),
+          h('p', { className: 'codexNetworkScope' }, '本次加载以来 · 所有会话的原生 Codex 请求。接收量为响应及心跳载荷，不含协议开销。' + (snapshot.activeCount > 1 ? '上方显示优先等待的请求。' : '') + (snapshot.truncated ? '仅保留最近请求明细。' : '')),
+        ) : null,
+      )
+    }
+
     function CodexQuotaRing(props) {
       const running = props.useSession((snapshot) => snapshot.running)
       const status = useSharedStatus()
       const [open, setOpen] = useState(false)
+      const network = useNetworkStats(Boolean(status && status.loggedIn))
+      const reconnecting = networkReconnecting(network)
       const [loading, setLoading] = useState(false)
       const [error, setError] = useState('')
       const rootRef = useRef(null)
@@ -462,7 +574,7 @@ window.__ModuleLoader__.load({
       const used = meter ? Math.max(0, Math.min(100, Number(meter.usedPercent) || 0)) : 0
       const remaining = Math.max(0, 100 - used)
       const reading = meter ? Math.round(remaining) + '%' : '待更新'
-      const title = loading ? '正在刷新 Codex 额度' : 'Codex 额度剩余 ' + reading + '；点击刷新'
+      const title = reconnecting ? 'Codex 网络不可用，正在持续重连' : loading ? '正在刷新 Codex 额度' : 'Codex 额度剩余 ' + reading + '；点击刷新'
       const circumference = 2 * Math.PI * 5.5
       const usedLength = circumference * used / 100
       const remainingLength = circumference - usedLength
@@ -472,7 +584,7 @@ window.__ModuleLoader__.load({
 
       return h('span', {
         ref: rootRef,
-        className: 'codexQuotaRoot',
+        className: 'codexQuotaRoot' + (reconnecting ? ' codexQuotaReconnecting' : ''),
         onMouseEnter: () => { setOpen(true) },
         onMouseLeave: () => { setOpen(false) },
       },
@@ -510,6 +622,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(CodexNetworkStats, network),
           status.usageError ? h('p', { className: 'codexQuotaMessage error', role: 'status' }, '额度读取失败：' + status.usageError) : null,
           error ? h('p', { className: 'codexQuotaMessage error', role: 'status' }, '无法连接额度接口：' + error) : null,
         ) : null,

package/lib/cloud-http.js

@@ -1,5 +1,5 @@
 /** Nonstreaming Codex cloud requests. Never retry ambiguous POST failures. */
-import { attributionHeaders, LlmError } from '@deepseek-ai/dsh-llm';
+import { attributionHeaders, LlmError, ProviderRequestId } from '@deepseek-ai/dsh-llm';
 import { nativeCodexEndpoint } from './endpoint.js';
 const fail = (message, code = 'CODEX_CLOUD_FAILED') => new LlmError(message, code);
 function positive(value, fallback) {
@@ -93,6 +93,14 @@ export class NativeCodexCloudClient {
                 catch {
                     throw fail(signal.aborted ? 'Codex cloud request cancelled or timed out' : 'Codex cloud request failed; it was not retried', signal.aborted ? 'ABORTED' : 'CODEX_CLOUD_FAILED');
                 }
+                const rawRequestId = path.startsWith('images/')
+                    ? response.headers.get('x-codex-imagegen-request-id') ?? response.headers.get('x-request-id')
+                    : response.headers.get('x-request-id');
+                // Validate before branding: response headers are untrusted, including credential echoes.
+                const requestId = rawRequestId && /^[a-zA-Z0-9_.:-]{1,256}$/.test(rawRequestId)
+                    && ![options.credential.accessToken, credential.accessToken, accountId].some(secret => rawRequestId.includes(secret))
+                    ? ProviderRequestId(rawRequestId) : undefined;
+                const responseFail = (message, code = 'CODEX_CLOUD_FAILED') => new LlmError(message, code, { status: response.status, ...(requestId === undefined ? {} : { requestId }) });
                 if (!response.ok) {
                     void response.body?.cancel().catch(() => { });
                     if (response.status === 401 && attempt === 0 && this.options.recoverCredential) {
@@ -110,7 +118,7 @@ export class NativeCodexCloudClient {
                             continue;
                         }
                     }
-                    throw fail('Codex cloud service returned HTTP ' + response.status, response.status === 401 ? 'AUTH_REQUIRED' : 'CODEX_CLOUD_HTTP_ERROR');
+                    throw responseFail('Codex cloud service returned HTTP ' + response.status, response.status === 401 ? 'AUTH_REQUIRED' : 'CODEX_CLOUD_HTTP_ERROR');
                 }
                 const reader = response.body?.getReader();
                 if (!reader)
@@ -144,12 +152,9 @@ export class NativeCodexCloudClient {
                     parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
                 }
                 catch {
-                    throw fail('Codex cloud service returned invalid JSON');
+                    throw responseFail('Codex cloud service returned invalid JSON');
                 }
-                const requestId = path.startsWith('images/')
-                    ? response.headers.get('x-codex-imagegen-request-id') ?? response.headers.get('x-request-id')
-                    : response.headers.get('x-request-id');
-                return { body: parsed, ...(requestId && /^[a-zA-Z0-9_.:-]{1,256}$/.test(requestId) && !requestId.includes(credential.accessToken) ? { requestId } : {}) };
+                return { body: parsed, ...(requestId ? { requestId } : {}) };
             }
             throw fail('Codex cloud authentication failed', 'AUTH_REQUIRED');
         }

package/lib/index.d.ts

@@ -200,6 +200,7 @@ export declare class OpenAICodexAuth extends Service {
     private sendText;
     private trustedManagementRequest;
     private requireCsrf;
+    private handleNetwork;
     private handleStatus;
     private handleAccountUsage;
     private handleDeviceStart;

package/lib/index.js

@@ -18,6 +18,7 @@ import { NativeCodexCloudClient } from './cloud-http.js';
 import { registerCodexImageTools } from './cloud-tools.js';
 import { registerCodexWeb } from './cloud-web-tool.js';
 import { mergeDirectUsage, normalizeUsage } from './usage.js';
+import { networkTelemetry } from './network-telemetry.js';
 export { normalizeUsage } from './usage.js';
 export { CODEX_CLIENT_VERSION, TRACKED_CODEX_COMMIT, TRACKED_CODEX_RELEASE, TRACKED_CODEX_REPOSITORY, } from './upstream.js';
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
@@ -829,6 +830,7 @@ export class OpenAICodexAuth extends Service {
                     disposers.push(ctx.webServer.register({ kind: 'exact', path, handler }));
                 };
                 register('/openai-codex/status', (req, res) => this.handleStatus(req, res));
+                register('/openai-codex/network', (req, res) => this.handleNetwork(req, res));
                 register('/openai-codex/device/start', (req, res) => this.handleDeviceStart(req, res));
                 register('/openai-codex/browser/start', (req, res) => this.handleBrowserStart(req, res));
                 register('/openai-codex/browser/prepare', (req, res) => this.handleBrowserPrepare(req, res));
@@ -2013,6 +2015,15 @@ export class OpenAICodexAuth extends Service {
         this.sendJson(res, 403, { error: 'Invalid CSRF token.' });
         return false;
     }
+    handleNetwork(req, res) {
+        if (!this.trustedManagementRequest(req, res))
+            return;
+        if (req.method !== 'GET') {
+            this.sendJson(res, 405, { error: 'GET only' }, { allow: 'GET' });
+            return;
+        }
+        this.sendJson(res, 200, networkTelemetry.snapshot());
+    }
     async handleStatus(req, res) {
         if (!this.trustedManagementRequest(req, res))
             return;

package/lib/native-adapter.js

@@ -56,8 +56,8 @@ function supportsFast(model) {
 function responsesLiteMode(model, requestedModel = model?.slug) {
     if (model !== undefined && !model.useResponsesLite)
         return {};
-    // Never downgrade the tracked Lite-only Astra slug to Standard Responses during catalog outages.
-    if (model === undefined && requestedModel !== 'gpt-6-astra')
+    // Never downgrade known Lite-only slugs to Standard Responses during catalog outages.
+    if (model === undefined && requestedModel !== 'gpt-6-astra' && requestedModel !== 'gpt-6-sol')
         return {};
     return {
         responsesLite: {

package/lib/native-http.d.ts

@@ -1,3 +1,4 @@
+import { type NetworkTelemetry, type NetworkRequestHandle } from './network-telemetry.js';
 import { type ContentBlock, type GenerateOptions, type StreamChunk } from '@deepseek-ai/dsh-llm';
 import { type NativeCodexCredential } from './catalog.js';
 import { type NativeCodexTransportMode } from './native-adapter.js';
@@ -16,6 +17,7 @@ export interface NativeCodexHttpOptions {
     resolveCredential(signal?: AbortSignal): Promise<NativeCodexCredential>;
     recoverCredential?(previous: NativeCodexCredential, signal?: AbortSignal): Promise<boolean>;
     readImage?(attachment: ImageBlock['attachment'], signal?: AbortSignal): Promise<NativeCodexImageRead>;
+    telemetry?: NetworkTelemetry;
     fetch?: typeof fetch;
     endpoint?: string;
     requestTimeoutMs?: number;
@@ -54,6 +56,7 @@ export declare class NativeCodexHttpTransport {
     private waitForConnection;
     endpointUrl(): string;
     prepare(generation: GenerateOptions, mode?: NativeCodexTransportMode): Promise<NativeCodexPreparedRequest>;
-    stream(generation: GenerateOptions, mode?: NativeCodexTransportMode): AsyncIterable<StreamChunk>;
+    stream(generation: GenerateOptions, mode?: NativeCodexTransportMode, telemetry?: NetworkRequestHandle): AsyncIterable<StreamChunk>;
+    private streamTracked;
 }
 export {};

package/lib/native-http.js

@@ -1,10 +1,11 @@
 /** Native ChatGPT Codex HTTP/SSE transport with safe pre-output retries. */
 import { createHash, randomUUID } from 'node:crypto';
-import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, isContextWindowExceededError, isQuotaExceededError, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, attributionHeaders, } from '@deepseek-ai/dsh-llm';
+import { networkTelemetry, trackNetwork, observeNetworkOutput } from './network-telemetry.js';
+import { EMPTY_RESPONSE_CODE, LlmError, ProviderRequestId, attributionHeaders, } from '@deepseek-ai/dsh-llm';
 import { nativeCodexAuthorityHash } from './catalog.js';
 import { nativeCodexEndpoint } from './endpoint.js';
 import { NATIVE_CODEX_CONNECTION_FAILED_CODE, NATIVE_CODEX_STREAM_INTERRUPTED_CODE, isNativeCodexConnectionFailure, } from './native-adapter.js';
-import { boundedCodexTurnState, codexRequestBody, codexResponseTurnState, streamResponses, } from './responses.js';
+import { boundedCodexTurnState, codexRequestBody, codexResponseTurnState, streamResponses, responsesFailure, } from './responses.js';
 import { hasNativeCodexReplayKind } from './replay.js';
 import { parseCodexResponseUsageMetadata, publishCodexResponseUsage, } from './response-usage.js';
 import { parseCodexRateLimitEvent, parseCodexRateLimitHeaders, publishCodexRateLimits, } from './rate-limits.js';
@@ -198,7 +199,7 @@ async function resolveMessages(generation, options) {
     }
     return messages;
 }
-async function boundedError(response, signal) {
+async function boundedError(response, signal, telemetry) {
     if (response.body === null)
         return {};
     const reader = response.body.getReader();
@@ -222,6 +223,7 @@ async function boundedError(response, signal) {
                 return {};
             if (done)
                 break;
+            telemetry.activity(value.byteLength);
             total += value.byteLength;
             if (total > MAX_ERROR_BODY_BYTES) {
                 await reader.cancel().catch(() => { });
@@ -275,27 +277,23 @@ function errorFacts(response, maxDelayMs) {
             : { requestId: ProviderRequestId(requestId) },
     };
 }
-async function httpFailure(response, maxDelayMs, signal) {
-    const detail = await boundedError(response, signal);
+async function httpFailure(response, maxDelayMs, signal, telemetry) {
+    const detail = await boundedError(response, signal, telemetry);
     const facts = errorFacts(response, maxDelayMs);
-    const classification = `${detail.code ?? ''} ${detail.message ?? ''}`;
+    const classified = responsesFailure(detail.code, detail.message);
     if (response.status === 401 || response.status === 403) {
         return fixedFailure('native Codex rejected the configured credential', 'AUTH', facts);
     }
+    if (classified.code !== 'SERVER') {
+        const delay = facts?.providerRetryAfterMs ?? classified.failure.providerRetryAfterMs;
+        return fixedFailure(classified.message, classified.code, {
+            ...facts,
+            ...(delay === undefined ? {} : { providerRetryAfterMs: Math.min(delay, maxDelayMs) }),
+        });
+    }
     if (response.status === 429) {
-        if (isQuotaExceededError(classification)) {
-            return fixedFailure('native Codex account quota is exhausted', QUOTA_EXCEEDED_CODE, facts);
-        }
         return fixedFailure('native Codex request was rate limited', 'RATE_LIMIT', facts);
     }
-    if (detail.code === 'context_length_exceeded'
-        || detail.code === 'context_window_exceeded'
-        || isContextWindowExceededError(classification)) {
-        return fixedFailure('native Codex request exceeded the model context window', CONTEXT_WINDOW_EXCEEDED_CODE, facts);
-    }
-    if (isQuotaExceededError(classification)) {
-        return fixedFailure('native Codex account quota is exhausted', QUOTA_EXCEEDED_CODE, facts);
-    }
     if (response.status === 408 || response.status === 504) {
         return fixedFailure('native Codex request timed out', 'TIMEOUT', facts);
     }
@@ -374,11 +372,13 @@ export class NativeCodexHttpTransport {
         const jitter = 0.9 + Math.max(0, Math.min(1, random)) * 0.2;
         return Math.max(1, Math.round(exponential * jitter));
     }
-    async wait(retry, error, signal) {
+    async wait(retry, error, signal, telemetry) {
         const delay = this.retryDelay(retry, error.failure.providerRetryAfterMs);
+        telemetry.retry(delay);
         await (this.options.sleep ?? sleep)(delay, signal);
     }
-    async waitForConnection(delayMs, signal) {
+    async waitForConnection(delayMs, signal, telemetry) {
+        telemetry.retry(delayMs, 'connection');
         this.options.warn?.(`native Codex network is unavailable; reconnecting in ${delayMs}ms`);
         await (this.options.sleep ?? sleep)(delayMs, signal);
     }
@@ -419,7 +419,15 @@ export class NativeCodexHttpTransport {
         // Serialize only in the selected transport.
         return { generation, mode, request, routingId, routingHint };
     }
-    async *stream(generation, mode = {}) {
+    async *stream(generation, mode = {}, telemetry) {
+        if (telemetry !== undefined) {
+            yield* this.streamTracked(generation, mode, telemetry);
+            return;
+        }
+        yield* trackNetwork(this.options.telemetry ?? networkTelemetry, 'http', generation.signal, handle => this.streamTracked(generation, mode, handle));
+    }
+    async *streamTracked(generation, mode, telemetry) {
+        telemetry.state('preparing');
         const prepared = await this.prepare(generation, mode);
         const { request, routingId, routingHint } = prepared;
         let body;
@@ -441,6 +449,7 @@ export class NativeCodexHttpTransport {
         let pinnedAccountId = mode.pinnedAccountId;
         while (true) {
             throwIfAborted(generation.signal);
+            telemetry.state('preparing');
             const watchdog = attemptWatchdog(generation.signal, this.requestTimeoutMs, this.idleTimeoutMs);
             let response;
             let credential;
@@ -459,6 +468,7 @@ export class NativeCodexHttpTransport {
                     throw fixedFailure('native Codex Fast capability authority changed before request', 'FAST_CAPABILITY_UNAVAILABLE');
                 }
                 fetching = true;
+                telemetry.attempt('http');
                 response = await this.fetchImpl(this.endpoint, {
                     method: 'POST',
                     redirect: 'error',
@@ -491,16 +501,18 @@ export class NativeCodexHttpTransport {
                     : connection ?? mappedFailure(error, watchdog, generation.signal);
                 watchdog.stop();
                 if (connection !== undefined) {
-                    await this.waitForConnection(connectionRetryDelayMs, generation.signal);
+                    await this.waitForConnection(connectionRetryDelayMs, generation.signal, telemetry);
                     connectionRetryDelayMs = Math.min(connectionRetryDelayMs * 2, MAX_CONNECTION_RETRY_DELAY_MS);
                     continue;
                 }
                 if (retryable(failure) && transientRetries < this.maxRetries) {
-                    await this.wait(transientRetries++, failure, generation.signal);
+                    await this.wait(transientRetries++, failure, generation.signal, telemetry);
                     continue;
                 }
                 throw failure;
             }
+            telemetry.activity();
+            telemetry.state('waiting');
             publishCodexRateLimits(credential.accountId, parseCodexRateLimitHeaders(response.headers), this.options.onRateLimits, this.options.warn);
             if (activeTurnState === undefined) {
                 const headerTurnState = boundedCodexTurnState(response.headers.get('x-codex-turn-state'));
@@ -515,8 +527,10 @@ export class NativeCodexHttpTransport {
                     const changed = await this.options.recoverCredential(credential, watchdog.signal);
                     recovered = true;
                     watchdog.stop();
-                    if (changed)
+                    if (changed) {
+                        telemetry.retry(0);
                         continue;
+                    }
                     throw fixedFailure('native Codex rejected the configured credential', 'AUTH', errorFacts(response, this.maxDelayMs));
                 }
                 catch (error) {
@@ -524,7 +538,7 @@ export class NativeCodexHttpTransport {
                     const failure = connection ?? mappedFailure(error, watchdog, generation.signal);
                     watchdog.stop();
                     if (connection !== undefined) {
-                        await this.waitForConnection(connectionRetryDelayMs, generation.signal);
+                        await this.waitForConnection(connectionRetryDelayMs, generation.signal, telemetry);
                         connectionRetryDelayMs = Math.min(connectionRetryDelayMs * 2, MAX_CONNECTION_RETRY_DELAY_MS);
                         continue;
                     }
@@ -532,13 +546,13 @@ export class NativeCodexHttpTransport {
                 }
             }
             if (!response.ok) {
-                let failure = await httpFailure(response, this.maxDelayMs, watchdog.signal);
+                let failure = await httpFailure(response, this.maxDelayMs, watchdog.signal, telemetry);
                 if (generation.signal?.aborted || watchdog.timedOut()) {
                     failure = mappedFailure(failure, watchdog, generation.signal);
                 }
                 watchdog.stop();
                 if (retryable(failure) && transientRetries < this.maxRetries) {
-                    await this.wait(transientRetries++, failure, generation.signal);
+                    await this.wait(transientRetries++, failure, generation.signal, telemetry);
                     continue;
                 }
                 throw failure;
@@ -554,6 +568,7 @@ export class NativeCodexHttpTransport {
                 for await (const chunk of streamResponses(response.body, {
                     signal: watchdog.signal,
                     onActivity: watchdog.pulse,
+                    onBytes: bytes => telemetry.activity(bytes),
                     onMalformedEvent: () => {
                         this.options.warn?.('native Codex ignored a malformed SSE event');
                     },
@@ -576,6 +591,7 @@ export class NativeCodexHttpTransport {
                     },
                 })) {
                     emitted = true;
+                    observeNetworkOutput(telemetry, chunk);
                     if (chunk.type === 'finish'
                         && ['stop', 'tool-calls', 'max-tokens'].includes(chunk.reason.kind))
                         completed = true;
@@ -594,7 +610,7 @@ export class NativeCodexHttpTransport {
             catch (error) {
                 const failure = mappedFailure(error, watchdog, generation.signal);
                 if (!emitted && retryable(failure) && transientRetries < this.maxRetries) {
-                    await this.wait(transientRetries++, failure, generation.signal);
+                    await this.wait(transientRetries++, failure, generation.signal, telemetry);
                     continue;
                 }
                 if (emitted && retryable(failure))

package/lib/native-websocket-socket.d.ts

@@ -10,6 +10,8 @@ export interface NativeCodexWebSocket {
     readonly responseHeaders: Readonly<Record<string, string>>;
     send(text: string, signal?: AbortSignal): Promise<void>;
     receive(signal?: AbortSignal): Promise<NativeCodexWebSocketFrame>;
+    /** Observe incoming payload bytes while a logical inference owns the socket. */
+    observeActivity?(observer: (bytes: number) => void): () => void;
     close(): void;
 }
 export interface NativeCodexWebSocketConnectOptions {

package/lib/native-websocket-socket.js

@@ -55,10 +55,19 @@ class NodeNativeCodexWebSocket {
     queue = [];
     waiters = [];
     ended = false;
+    activityObserver;
+    observeActivity(observer) {
+        this.activityObserver = observer;
+        return () => { if (this.activityObserver === observer)
+            this.activityObserver = undefined; };
+    }
     constructor(socket, responseHeaders) {
         this.socket = socket;
         this.responseHeaders = responseHeaders;
+        socket.on('ping', data => { this.activityObserver?.(data.byteLength); });
+        socket.on('pong', data => { this.activityObserver?.(data.byteLength); });
         socket.on('message', (data, isBinary) => {
+            this.activityObserver?.(Array.isArray(data) ? data.reduce((sum, part) => sum + part.byteLength, 0) : data.byteLength);
             if (isBinary) {
                 this.fail(failure('native Codex WebSocket returned a binary frame', 'WS_PROTOCOL_ERROR'));
                 return;

package/lib/native-websocket.d.ts

@@ -40,5 +40,6 @@ export declare class NativeCodexWebSocketTransport implements NativeCodexTranspo
     private exchange;
     private attempt;
     stream(generation: GenerateOptions, mode?: NativeCodexTransportMode): AsyncIterable<StreamChunk>;
+    private streamTracked;
     dispose(): void;
 }

package/lib/native-websocket.js

@@ -1,5 +1,6 @@
 /** WebSocket v2 Responses transport with bounded session state and sticky HTTP fallback. */
 import { createHash } from 'node:crypto';
+import { networkTelemetry, trackNetwork, observeNetworkOutput } from './network-telemetry.js';
 import { LlmError, ProviderRequestId, attributionHeaders, } from '@deepseek-ai/dsh-llm';
 import { nativeCodexAuthorityHash } from './catalog.js';
 import { NATIVE_CODEX_CONNECTION_FAILED_CODE, NATIVE_CODEX_STREAM_INTERRUPTED_CODE, isNativeCodexConnectionFailure, } from './native-adapter.js';
@@ -7,7 +8,7 @@ import { NativeCodexHttpTransport, } from './native-http.js';
 import { replayableItemId } from './replay.js';
 import { parseCodexResponseUsageMetadata, publishCodexResponseUsage, } from './response-usage.js';
 import { parseCodexRateLimitEvent, parseCodexRateLimitHeaders, publishCodexRateLimits, } from './rate-limits.js';
-import { ResponsesStreamTranslator, codexResponseTurnState, } from './responses.js';
+import { ResponsesStreamTranslator, responsesFailure, codexResponseTurnState, } from './responses.js';
 import { NodeNativeCodexWebSocketFactory, } from './native-websocket-socket.js';
 import { NativeCodexWebSocketSessionState } from './native-websocket-session.js';
 const WS_BETA = 'responses_websockets=2026-02-06';
@@ -192,8 +193,15 @@ function eventFailure(event) {
     }
     if (status === 403)
         return new LlmError('native Codex WebSocket authorization failed', 'AUTH', facts);
-    if (providerCode === 'rate_limit_exceeded' || providerCode === 'usage_limit_reached'
-        || status === 429) {
+    const classified = responsesFailure(providerCode, typeof error.message === 'string' ? error.message : undefined);
+    if (classified.code !== 'SERVER') {
+        const delay = facts?.providerRetryAfterMs ?? classified.failure.providerRetryAfterMs;
+        return new LlmError(classified.message, classified.code === 'RATE_LIMIT' ? 'RATE_LIMITED' : classified.code, {
+            ...facts,
+            ...(delay === undefined ? {} : { providerRetryAfterMs: Math.min(delay, 120_000) }),
+        });
+    }
+    if (providerCode === 'usage_limit_reached' || status === 429) {
         return new LlmError('native Codex WebSocket rate limit was reached', 'RATE_LIMITED', facts);
     }
     if (status !== undefined && status >= 500) {
@@ -238,11 +246,13 @@ export class NativeCodexWebSocketTransport {
         const jitter = 0.9 + Math.max(0, Math.min(1, random)) * 0.2;
         return Math.max(1, Math.round(exponential * jitter));
     }
-    async wait(retry, error, signal) {
+    async wait(retry, error, signal, telemetry) {
         const delay = this.retryDelay(retry, error);
+        telemetry.retry(delay);
         await (this.options.sleep ?? sleep)(delay, signal);
     }
-    async waitForConnection(delayMs, signal) {
+    async waitForConnection(delayMs, signal, telemetry) {
+        telemetry.retry(delayMs, 'connection');
         this.options.warn?.(`native Codex network is unavailable; reconnecting in ${delayMs}ms`);
         await (this.options.sleep ?? sleep)(delayMs, signal);
     }
@@ -324,7 +334,7 @@ export class NativeCodexWebSocketTransport {
             ...attributionHeaders(),
         };
     }
-    async ensureSocket(entry, prepared, credential, signal) {
+    async ensureSocket(entry, prepared, credential, signal, telemetry) {
         const fingerprint = socketCredential(credential);
         if (entry.socket !== undefined && entry.socketCredential === fingerprint)
             return;
@@ -339,6 +349,7 @@ export class NativeCodexWebSocketTransport {
             socket.close();
             throw failure('native Codex WebSocket transport was disposed', 'DISPOSED');
         }
+        telemetry.activity();
         entry.socket = socket;
         entry.socketCredential = fingerprint;
         publishCodexRateLimits(credential.accountId, parseCodexRateLimitHeaders(socket.responseHeaders), this.options.onRateLimits, this.options.warn);
@@ -372,11 +383,12 @@ export class NativeCodexWebSocketTransport {
                 clearTimeout(timer);
         }
     }
-    async *exchange(entry, payload, generation, mode, accountId, prewarm, signal) {
+    async *exchange(entry, payload, generation, mode, accountId, prewarm, signal, telemetry) {
         if (entry.socket === undefined)
             throw failure('native Codex WebSocket is unavailable', 'WS_RETRYABLE');
         const encoded = JSON.stringify(payload);
         await entry.socket.send(encoded, signal);
+        telemetry.state('waiting');
         const translator = new ResponsesStreamTranslator(prewarm ? undefined : {
             provider: generation.provider,
             model: mode.publicModel ?? generation.model,
@@ -384,6 +396,8 @@ export class NativeCodexWebSocketTransport {
         const outputItems = [];
         while (true) {
             const text = await this.receive(entry, signal);
+            if (entry.socket?.observeActivity === undefined)
+                telemetry.activity(Buffer.byteLength(text));
             let event;
             try {
                 event = JSON.parse(text);
@@ -432,28 +446,38 @@ export class NativeCodexWebSocketTransport {
             }
         }
     }
-    async *attempt(entry, prepared, credential, signal) {
-        await this.ensureSocket(entry, prepared, credential, signal);
-        let justPrewarmed = false;
-        if (!entry.prewarmAttempted) {
-            entry.prewarmAttempted = true;
-            const warm = entry.protocol.prewarm(withRequestMetadata(prepared.request, entry.turnState, prepared.mode.responsesLite !== undefined));
-            for await (const _chunk of this.exchange(entry, warm.payload, prepared.generation, prepared.mode, credential.accountId, true, signal)) { /* prewarm is invisible */ }
-            entry.prewarmSucceeded = true;
-            justPrewarmed = true;
-        }
-        const plan = entry.protocol.plan(withRequestMetadata(prepared.request, entry.turnState, prepared.mode.responsesLite !== undefined), justPrewarmed);
-        yield* this.exchange(entry, plan.payload, prepared.generation, prepared.mode, credential.accountId, false, signal);
-        if (this.options.onCompleted !== undefined) {
-            try {
-                this.options.onCompleted();
+    async *attempt(entry, prepared, credential, signal, telemetry) {
+        telemetry.attempt('websocket');
+        await this.ensureSocket(entry, prepared, credential, signal, telemetry);
+        const stopActivity = entry.socket?.observeActivity?.(bytes => telemetry.activity(bytes));
+        try {
+            let justPrewarmed = false;
+            if (!entry.prewarmAttempted) {
+                entry.prewarmAttempted = true;
+                const warm = entry.protocol.prewarm(withRequestMetadata(prepared.request, entry.turnState, prepared.mode.responsesLite !== undefined));
+                for await (const _chunk of this.exchange(entry, warm.payload, prepared.generation, prepared.mode, credential.accountId, true, signal, telemetry)) { /* prewarm is invisible */ }
+                entry.prewarmSucceeded = true;
+                justPrewarmed = true;
             }
-            catch {
-                this.options.warn?.('native Codex usage refresh could not be scheduled');
+            const plan = entry.protocol.plan(withRequestMetadata(prepared.request, entry.turnState, prepared.mode.responsesLite !== undefined), justPrewarmed);
+            yield* this.exchange(entry, plan.payload, prepared.generation, prepared.mode, credential.accountId, false, signal, telemetry);
+            if (this.options.onCompleted !== undefined) {
+                try {
+                    this.options.onCompleted();
+                }
+                catch {
+                    this.options.warn?.('native Codex usage refresh could not be scheduled');
+                }
             }
         }
+        finally {
+            stopActivity?.();
+        }
     }
     async *stream(generation, mode = {}) {
+        yield* trackNetwork(this.options.telemetry ?? networkTelemetry, 'websocket', generation.signal, handle => this.streamTracked(generation, mode, handle));
+    }
+    async *streamTracked(generation, mode, telemetry) {
         if (this.disposed)
             throw failure('native Codex WebSocket transport was disposed', 'DISPOSED');
         const lifecycle = new AbortController();
@@ -500,7 +524,7 @@ export class NativeCodexWebSocketTransport {
         let requestCompleted = false;
         try {
             if (entry.disabled) {
-                yield* this.http.stream(activeGeneration, fallbackMode());
+                yield* this.http.stream(activeGeneration, fallbackMode(), telemetry);
                 requestCompleted = true;
                 return;
             }
@@ -509,6 +533,7 @@ export class NativeCodexWebSocketTransport {
                 let attemptedCredential;
                 const enteringPrewarm = !entry.prewarmAttempted;
                 try {
+                    telemetry.state('preparing');
                     const credential = await this.options.resolveCredential(signal);
                     attemptedCredential = credential;
                     if (pinnedAccountId === undefined)
@@ -517,8 +542,9 @@ export class NativeCodexWebSocketTransport {
                         throw failure('native Codex account changed during request', 'AUTH');
                     }
                     this.assertFastAuthority(credential, mode);
-                    for await (const chunk of this.attempt(entry, prepared, credential, signal)) {
+                    for await (const chunk of this.attempt(entry, prepared, credential, signal, telemetry)) {
                         emitted = true;
+                        observeNetworkOutput(telemetry, chunk);
                         yield chunk;
                     }
                     requestCompleted = true;
@@ -543,7 +569,7 @@ export class NativeCodexWebSocketTransport {
                     // the DSH turn in an invisible infinite reconnect loop.
                     if (attemptedCredential === undefined
                         && isNativeCodexConnectionFailure(failureValue)) {
-                        await this.waitForConnection(connectionRetryDelayMs, signal);
+                        await this.waitForConnection(connectionRetryDelayMs, signal, telemetry);
                         connectionRetryDelayMs = Math.min(connectionRetryDelayMs * 2, MAX_CONNECTION_RETRY_DELAY_MS);
                         continue;
                     }
@@ -555,8 +581,10 @@ export class NativeCodexWebSocketTransport {
                         try {
                             const changed = await this.options.recoverCredential(attemptedCredential, signal);
                             recovered = true;
-                            if (changed)
+                            if (changed) {
+                                telemetry.retry(0);
                                 continue;
+                            }
                             throw failure('native Codex rejected the configured credential', 'AUTH');
                         }
                         catch (recoveryError) {
@@ -566,7 +594,7 @@ export class NativeCodexWebSocketTransport {
                             if (generation.signal?.aborted)
                                 throw recoveryError;
                             if (isNativeCodexConnectionFailure(recoveryError)) {
-                                await this.waitForConnection(connectionRetryDelayMs, signal);
+                                await this.waitForConnection(connectionRetryDelayMs, signal, telemetry);
                                 connectionRetryDelayMs = Math.min(connectionRetryDelayMs * 2, MAX_CONNECTION_RETRY_DELAY_MS);
                                 continue;
                             }
@@ -577,18 +605,19 @@ export class NativeCodexWebSocketTransport {
                     if (failureValue.code !== 'WS_UPGRADE_REQUIRED' && retryable
                         && enteringPrewarm && !entry.prewarmSucceeded) {
                         entry.prewarmAttempted = true;
-                        await this.wait(0, failureValue, signal);
+                        await this.wait(0, failureValue, signal, telemetry);
                         continue;
                     }
                     if (failureValue.code !== 'WS_UPGRADE_REQUIRED' && retryable
                         && reconnects < this.maxReconnects) {
-                        await this.wait(reconnects, failureValue, signal);
+                        await this.wait(reconnects, failureValue, signal, telemetry);
                         reconnects++;
                         continue;
                     }
                     if (failureValue.code === 'WS_UPGRADE_REQUIRED' || retryable) {
                         entry.disabled = true;
-                        yield* this.http.stream(activeGeneration, fallbackMode());
+                        telemetry.retry(0);
+                        yield* this.http.stream(activeGeneration, fallbackMode(), telemetry);
                         requestCompleted = true;
                         return;
                     }

package/lib/network-telemetry.d.ts

@@ -0,0 +1,61 @@
+/** Process-wide, content-free inference telemetry. All mutations are synchronous. */
+import type { StreamChunk } from '@deepseek-ai/dsh-llm';
+export type NetworkState = 'preparing' | 'connecting' | 'waiting' | 'streaming' | 'retrying' | 'completed' | 'failed' | 'cancelled';
+export type NetworkTransport = 'http' | 'websocket';
+export interface NetworkRequest {
+    id: string;
+    state: NetworkState;
+    transport: NetworkTransport;
+    startedAt: number;
+    lastActivityAt: number | null;
+    lastOutputAt: number | null;
+    retryAt: number | null;
+    retryKind: 'transient' | 'connection' | null;
+    retries: number;
+    receivedBytes: number;
+    attempts: number;
+}
+export interface NetworkSnapshot {
+    scope: 'process';
+    startedAt: number;
+    updatedAt: number;
+    activeCount: number;
+    totals: {
+        requests: number;
+        succeeded: number;
+        failed: number;
+        cancelled: number;
+        retries: number;
+        receivedBytes: number;
+    };
+    requests: NetworkRequest[];
+    truncated: boolean;
+}
+export interface NetworkRequestHandle {
+    state(state: 'preparing' | 'waiting'): void;
+    attempt(transport: NetworkTransport): void;
+    activity(bytes?: number): void;
+    output(): void;
+    retry(delayMs: number, kind?: 'transient' | 'connection'): void;
+    finish(state: 'completed' | 'failed' | 'cancelled'): void;
+}
+/** Keeps at most limit records, preferentially evicting terminal records. Handles
+ * remain owned by running generators; overflow never loses aggregate accounting.
+ * No timers, request content, external identifiers, or errors are retained. */
+export declare class NetworkTelemetry {
+    private readonly limit;
+    private readonly now;
+    private readonly rows;
+    private readonly startedAt;
+    private activeCount;
+    private sequence;
+    private evicted;
+    private readonly totals;
+    constructor(limit?: number, now?: () => number);
+    begin(transport: NetworkTransport): NetworkRequestHandle;
+    snapshot(): NetworkSnapshot;
+}
+export declare const networkTelemetry: NetworkTelemetry;
+export declare function observeNetworkOutput(handle: NetworkRequestHandle, chunk: StreamChunk): void;
+/** Generator return/break is cancellation; fallback delegates with the same handle. */
+export declare function trackNetwork<T>(telemetry: NetworkTelemetry, transport: NetworkTransport, signal: AbortSignal | undefined, run: (handle: NetworkRequestHandle) => AsyncIterable<T>): AsyncIterable<T>;

package/lib/network-telemetry.js

@@ -0,0 +1,104 @@
+/** Keeps at most limit records, preferentially evicting terminal records. Handles
+ * remain owned by running generators; overflow never loses aggregate accounting.
+ * No timers, request content, external identifiers, or errors are retained. */
+export class NetworkTelemetry {
+    limit;
+    now;
+    rows = new Map();
+    startedAt;
+    activeCount = 0;
+    sequence = 0;
+    evicted = false;
+    totals = { requests: 0, succeeded: 0, failed: 0, cancelled: 0, retries: 0, receivedBytes: 0 };
+    constructor(limit = 128, now = Date.now) {
+        this.limit = limit;
+        this.now = now;
+        if (!Number.isSafeInteger(limit) || limit < 1)
+            throw new RangeError('Invalid telemetry limit');
+        this.startedAt = now();
+    }
+    begin(transport) {
+        const row = {
+            id: String(++this.sequence), state: 'preparing', transport, startedAt: this.now(),
+            lastActivityAt: null, lastOutputAt: null, retryAt: null, retryKind: null, retries: 0, receivedBytes: 0, attempts: 0,
+        };
+        if (this.rows.size >= this.limit) {
+            const terminal = [...this.rows.values()].find(item => ['completed', 'failed', 'cancelled'].includes(item.state));
+            this.rows.delete(terminal?.id ?? this.rows.keys().next().value);
+            this.evicted = true;
+        }
+        this.rows.set(row.id, row);
+        this.activeCount++;
+        this.totals.requests++;
+        let finished = false;
+        const mutate = (fn) => {
+            if (finished)
+                return;
+            fn();
+        };
+        return {
+            state: state => mutate(() => { row.state = state; row.retryAt = null; if (state === 'waiting')
+                row.retryKind = null; }),
+            attempt: transport => mutate(() => {
+                row.transport = transport;
+                row.state = 'connecting';
+                row.retryAt = null;
+                row.attempts++;
+            }),
+            activity: (bytes = 0) => mutate(() => {
+                row.lastActivityAt = this.now();
+                if (Number.isSafeInteger(bytes) && bytes > 0) {
+                    row.receivedBytes += bytes;
+                    this.totals.receivedBytes += bytes;
+                }
+            }),
+            output: () => mutate(() => { row.state = 'streaming'; row.retryKind = null; row.lastOutputAt = this.now(); }),
+            retry: (delayMs, kind = 'transient') => mutate(() => {
+                row.retryKind = kind;
+                row.state = 'retrying';
+                row.retryAt = this.now() + Math.max(0, delayMs);
+                row.retries++;
+                this.totals.retries++;
+            }),
+            finish: state => mutate(() => {
+                row.state = state;
+                row.retryAt = null;
+                row.retryKind = null;
+                this.activeCount--;
+                this.totals[state === 'completed' ? 'succeeded' : state]++;
+                finished = true;
+            }),
+        };
+    }
+    snapshot() {
+        return {
+            scope: 'process', startedAt: this.startedAt, updatedAt: this.now(),
+            activeCount: this.activeCount, totals: { ...this.totals },
+            requests: [...this.rows.values()].reverse().map(row => ({ ...row })), truncated: this.evicted,
+        };
+    }
+}
+export const networkTelemetry = new NetworkTelemetry();
+export function observeNetworkOutput(handle, chunk) {
+    if ((chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') && chunk.text.length > 0
+        || chunk.type === 'tool-call-delta')
+        handle.output();
+    if (chunk.type === 'finish' && chunk.reason.kind === 'error')
+        handle.finish('failed');
+}
+/** Generator return/break is cancellation; fallback delegates with the same handle. */
+export async function* trackNetwork(telemetry, transport, signal, run) {
+    const handle = telemetry.begin(transport);
+    try {
+        yield* run(handle);
+        handle.finish('completed');
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+        handle.finish(signal?.aborted || code === 'ABORTED' || code === 'DISPOSED' ? 'cancelled' : 'failed');
+        throw error;
+    }
+    finally {
+        handle.finish('cancelled');
+    }
+}

package/lib/responses.js

@@ -282,16 +282,21 @@ export function responsesFailure(code, message) {
         || isContextWindowExceededError(detail)) {
         return fixedError('native Codex request exceeded the model context window', CONTEXT_WINDOW_EXCEEDED_CODE);
     }
-    if (code === 'insufficient_quota' || isQuotaExceededError(detail)) {
+    if (code === 'insufficient_quota' || code === 'credit_balance_exhausted'
+        || code === 'organization_spend_limit_exceeded' || code === 'project_spend_limit_exceeded'
+        || isQuotaExceededError(detail)) {
         return fixedError('native Codex account quota is exhausted', QUOTA_EXCEEDED_CODE);
     }
-    if (code === 'rate_limit_exceeded') {
+    if (code === 'rate_limit_exceeded' || code === 'slow_down') {
         const delay = retryDelay(message);
         return new LlmError('native Codex request was rate limited', 'RATE_LIMIT', {
             ...delay === undefined ? {} : { providerRetryAfterMs: delay },
         });
     }
-    if (code === 'invalid_prompt' || code === 'bio_policy') {
+    if (code === 'invalid_prompt') {
+        return fixedError('native Codex rejected the prompt', 'INVALID_PROMPT');
+    }
+    if (code === 'bio_policy') {
         return fixedError('native Codex rejected the request', 'INVALID_REQUEST');
     }
     return fixedError('native Codex reported a failed response', 'SERVER');

package/lib/upstream.d.ts

@@ -5,4 +5,4 @@ export declare const TRACKED_CODEX_RELEASE = "main@ddf04ad";
 /** Independently audited cloud search/image contracts; not local Codex executor parity. */
 export declare const TRACKED_CODEX_CLOUD_COMMIT = "b348fc26674189f758d5941cdab3f78f258b2aa7";
 /** Whole stable release version sent to the Codex model-catalog endpoint. */
-export declare const CODEX_CLIENT_VERSION = "0.153.4";
+export declare const CODEX_CLIENT_VERSION = "0.155.0";

package/lib/upstream.js

@@ -5,4 +5,4 @@ export const TRACKED_CODEX_RELEASE = 'main@ddf04ad';
 /** Independently audited cloud search/image contracts; not local Codex executor parity. */
 export const TRACKED_CODEX_CLOUD_COMMIT = 'b348fc26674189f758d5941cdab3f78f258b2aa7';
 /** Whole stable release version sent to the Codex model-catalog endpoint. */
-export const CODEX_CLIENT_VERSION = '0.153.4';
+export const CODEX_CLIENT_VERSION = '0.155.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Native ChatGPT Codex provider, device-code-first login, and same-origin Web integration for DeepSeek Harness",
   "license": "MIT",
   "publishConfig": {
@@ -41,6 +41,8 @@
     "lib/native-adapter.d.ts",
     "lib/native-http.js",
     "lib/native-http.d.ts",
+    "lib/network-telemetry.js",
+    "lib/network-telemetry.d.ts",
     "lib/native-websocket.js",
     "lib/native-websocket.d.ts",
     "lib/native-websocket-session.js",
@@ -86,12 +88,6 @@
     "LICENSE",
     "CODEX-COMPATIBILITY.md"
   ],
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "prepack": "pnpm build"
-  },
   "dsh": {
     "engines": {
       "dsh": "0.1.5-rc.1"
@@ -174,5 +170,10 @@
     "@deepseek-ai/dsh-sandbox-policy": {
       "optional": true
     }
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
-}
+}