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

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 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/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/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-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,5 +1,6 @@
 /** Native ChatGPT Codex HTTP/SSE transport with safe pre-output retries. */
 import { createHash, randomUUID } from 'node:crypto';
+import { networkTelemetry, trackNetwork, observeNetworkOutput } from './network-telemetry.js';
 import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, isContextWindowExceededError, isQuotaExceededError, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, attributionHeaders, } from '@deepseek-ai/dsh-llm';
 import { nativeCodexAuthorityHash } from './catalog.js';
 import { nativeCodexEndpoint } from './endpoint.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,8 +277,8 @@ 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 ?? ''}`;
     if (response.status === 401 || response.status === 403) {
@@ -374,11 +376,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 +423,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 +453,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 +472,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 +505,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 +531,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 +542,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 +550,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 +572,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 +595,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 +614,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';
@@ -238,11 +239,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 +327,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 +342,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 +376,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 +389,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 +439,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 +517,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 +526,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 +535,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 +562,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 +574,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 +587,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 +598,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "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",