@pure01fx/dsh-openai-codex-auth 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.13.0
+
+- Targets DSH 0.2.0-rc.2 with exact SDK peers, development dependencies and runtime helpers; retains the tool-message, shell and provenance migration below.
+- Merges GPT-6.1 catalog routing, shared Retry-After handling, assistant phases and deterministic developer instructions from the latest source.
+- Target build/typecheck and all 517 regression tests pass on DSH 0.2.0-rc.2. No live OAuth/model requests were made; collection-level Web validation is recorded separately.
+
 ## 0.12.0
 
 ### Migration
@@ -22,6 +28,15 @@
 - Developer messages: preserved in Responses API requests
 - Cloud context: requires toolCallId === source.callId and !isError
 
+- Shares Retry-After parsing across HTTP, SSE, and WebSocket errors, including nested JSON headers and HTTP dates; preserves server deadlines across retries and HTTP fallback without truncating advice to local backoff limits.
+
+- Preserves commentary, partial_answer, and final_answer phases through response events, durable replay, and WebSocket continuation matching; legacy phase-less replay remains readable.
+
+- Moves Standard base instructions into the same deterministic developer-message prefix used by Lite, preserving each protocol’s tool and reasoning controls; changed instructions invalidate WebSocket prefix reuse.
+
+- Requests the live model catalog as Codex 0.162.0 to discover GPT-6.1 Sol; verified that 0.155.0 omits it for the same account despite the bundled 0.153.0 minimum. Adds its exact Lite fallback and dynamic metadata/routing regressions without fabricating catalog availability.
+
+
 ## 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.

package/CODEX-COMPATIBILITY.md

@@ -1,5 +1,44 @@
 # Codex 云端能力兼容性跟踪
 
+## 重试、消息阶段与 Standard 指令对齐（Unreleased）
+
+本节记录对 `ea27864f` 的三项增量适配，取代下方 Retry-After、phase 和 Standard 指令位置的历史待办；其余工作仍独立跟踪。
+
+- Standard 基础指令改为 input 首部的 developer message，和 Lite 共用稳定 UUID 与 `model.base_instructions` metadata 构造。Standard 顶层 tools、并行工具与 reasoning 参数保留各自协议；Lite 的工具前缀及目录模板/DSH 指令组合保持独立。回归验证相同指令保持 WS 前缀复用，改变指令会触发完整请求，HTTP 历史、图片、工具输出和加密 reasoning 顺序不变。
+- 消息 phase 已接收并保留 commentary / partial_answer / final_answer，通过 v1 描述符的可选字段持久化再回放，并让 WS 复用比较使用同一有效 phase。added-only 的 phase 保留到 done，done 的显式 phase 优先；流中的 null/缺失值表示未提供，非法枚举拒绝。测试覆盖 JSON 保存/恢复、分叉和重启的请求构造、真实传输类的增量匹配与 phase 改变后完整重发。缺少 phase 的旧会话可读；旧插件的严格字段校验无法读取含 phase 的新描述符，降级时需考虑这一限制。
+- Retry-After 共用秒数/HTTP-date 解析，支持 JSON 数字值，嵌套错误 headers 优先；保留单次收到建议的单调时钟截止时间，不用本地退避上限截短服务端等待。HTTP 读取错误正文及其超时不会重置或丢弃等待，WS 最后一次失败后切换 HTTP 也遵守剩余等待。长等待分段使用 Node timer，仍可取消。宿主 `LlmError` 只公开正数 duration，无法跨宿主持久化表达单调时钟 deadline；本插件默认 normal 重试策略在宿主等待超上限时交还错误，不会提前重试。宿主另行配置的 always 策略可能忽略长等待，不属于本次插件内改动。
+
+验证：`npm run build`、`npm test`（27 文件 / 511 项）、`npm run typecheck`、`git diff --check`、`npm pack --dry-run --ignore-scripts` 均通过；所有生成模块与新鲜编译一致，新 retry-after 模块已加入打包清单。独立审查发现的非法日期归一化问题已修复，并加入内层非法日期回退外层有效等待的回归。本轮为源码、模拟传输与 loopback 验证，未执行线上推理、发布、替换 hu profile 或重启 GUI。
+
+## GPT-6.1 Sol 增量对齐（Unreleased，2026-10-08）
+
+`../codex` 已 fast-forward 到 `ea27864f99f0b086cec2f9f0251b7190fb9844f1`（本次获取的 origin/main），工作树干净。此轮针对模型发现与 Lite 路由，不宣称完整运行时对齐，原 Provider/cloud 跟踪提交保持不变。
+
+### 已确认的缺失原因与修复
+
+对同一当前账号执行只读线上目录请求（未调用推理、未记录凭据）：
+
+| client_version | originator | HTTP | 返回目录 |
+| --- | --- | --- | --- |
+| 0.153.4 | dsh | 200 | 不含 gpt-6-sol / gpt-6.1-sol |
+| 0.155.0 | dsh | 200 | 含 gpt-6-sol，不含 gpt-6.1-sol |
+| 0.162.0 | dsh | 200 | 含 gpt-6.1-sol，visibility=list |
+| 0.162.0 | codex_cli_rs | 200 | 同样含 gpt-6.1-sol |
+
+上游 `models-manager/models.json` 将 6.1 Sol 的 minimal_client_version 标为 0.153.0，但它不等于线上实际发现门槛。请求版本升至本次已验证的 0.162.0（上游已有 rust-v0.162.0-alpha.20；目录发送去预发布后缀的整版本）。不更改 originator，不将静态模型强行加入账号目录。
+
+补充精确 `gpt-6.1-sol` 的 Lite 后备，目录存在时仍以 metadata 为准。新增精简上游 fixture，验证动态发现、六档 reasoning、默认 low / multi-agent xhigh、Fast 授权、metadata 优先及未知近似名称不误用 Lite。
+
+当前 3080 GUI 的 hu profile 安装的是插件 0.11.1，请求版本 0.153.4。本轮只修改并构建仓库，未替换 profile 安装或重启当前会话；仓库修改不会自动改变正在运行的 GUI。
+
+验证：`npm run build`、`npm test`（26 文件 / 469 项）、`npm run typecheck`、`git diff --check` 全部通过；生成产物一致性测试通过。使用新构建的 NativeCodexCatalog + NativeCodexAdapter 查询当前账号，已返回 `gpt-6.1-sol` 与 `gpt-6.1-sol-fast`，六档推理配置及默认 low 解析成功。本轮未执行模型推理，因此此结果验证发现与元数据，不代表线上推理端到端验收。
+
+### 独立后续兼容性工作
+
+- Retry-After：新上游从 response.failed.response.error.headers 读取等待提示，WebSocket 优先嵌套 headers，支持数字 JSON 值和 HTTP 日期；插件仍遗漏部分嵌套提示并将等待上限压到 120 秒。建议单独对齐共享解析及 deadline 传递，避免早于服务端建议重试。依据 `codex-api/src/sse/responses_error.rs`、`endpoint/responses_websocket.rs`、`http-client/src/retry_after.rs`。这不是 6.1 模型目录缺失原因。
+- 数字自定义 reasoning effort、Standard instructions 移入 developer input、partial_answer phase 回放保真分别存在增量差异，应单独设计与验证。6.1 现有命名 effort 和 Lite 路径不依赖这些改动。
+
+
 ## 已实现：Sol 与错误协议增量适配（0.11.2）
 
 参考上游 `c44deff7b1083e9660ac55d02122481f1cdf139b`，在既有 0.11.1 工作树上完成以下必要改动。此节取代下方历史审查中相应的“待适配”结论；不代表完整上游运行时对齐。

package/README.md

@@ -17,9 +17,9 @@
 
 ## 快速开始
 
-版本 `0.12.0` 明确适配 DeepSeek Harness `0.1.7-rc.2`，SDK peers/runtime helpers 精确锁定该版本；不声明兼容旧 SDK。旧 DSH `0.1.5-rc.1` profile 应保留原插件 `0.11.2`，升级时在独立 profile 安装新版插件并保留原 profile/锁文件以便回滚。无需迁移账号文件或浏览器隐藏列表；`dsh.engines` 仅作兼容性说明，不当作宿主硬门禁。
+版本 `0.13.0` 明确适配 DeepSeek Harness `0.2.0-rc.2`，SDK peers/runtime helpers 精确锁定该版本；不声明兼容旧 SDK。旧 DSH `0.1.5-rc.1` profile 应保留原插件 `0.11.2`，升级时在独立 profile 安装新版插件并保留原 profile/锁文件以便回滚。无需迁移账号文件或浏览器隐藏列表；`dsh.engines` 仅作兼容性说明，不当作宿主硬门禁。
 
-本版本通过真实目标 LLM/tools 服务与本地 HTTP/SSE/WebSocket 回放、错误/取消回归；模型隐藏覆盖真实目录/catalog/store 的投影更新、重连和重新加载。验证命令为 `pnpm typecheck && pnpm build && pnpm test`；当前版本未执行线上 OAuth/付费模型验收。
+回归范围包含真实目标 LLM/tools 服务、本地 HTTP/SSE/WebSocket 回放、错误/取消，以及模型隐藏在真实目录/catalog/store 的投影更新、重连和重新加载。验证命令为 `pnpm typecheck && pnpm build && pnpm test`；0.13.0 候选版已通过目标版本构建、类型检查和 517 项测试；当前未执行线上 OAuth/付费模型验收。
 
 `0.11.0` 移除了插件额外设置的请求、响应、SSE/WebSocket、图片和重放状态大小上限，以及相应的 transport 选项（含 `maxRequestBodyBytes`）；旧配置中的该字段应删除。搜索结果完整保留，WebSocket 继续优先复用增量上下文。服务端限制、协议校验及 DSH 文件/附件策略仍生效。
 

package/lib/native-adapter.js

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

package/lib/native-http.js

@@ -4,6 +4,7 @@ import { networkTelemetry, trackNetwork, observeNetworkOutput } from './network-
 import { EMPTY_RESPONSE_CODE, LlmError, ProviderRequestId, attributionHeaders, } from '@deepseek-ai/dsh-llm';
 import { nativeCodexAuthorityHash } from './catalog.js';
 import { nativeCodexEndpoint } from './endpoint.js';
+import { retryAfterMs, retryError, remainingRetryDelay, sleepRetry, inheritRetryDeadline } from './retry-after.js';
 import { NATIVE_CODEX_CONNECTION_FAILED_CODE, NATIVE_CODEX_STREAM_INTERRUPTED_CODE, isNativeCodexConnectionFailure, } from './native-adapter.js';
 import { boundedCodexTurnState, codexRequestBody, codexResponseTurnState, streamResponses, responsesFailure, } from './responses.js';
 import { hasNativeCodexReplayKind } from './replay.js';
@@ -19,7 +20,7 @@ const INITIAL_CONNECTION_RETRY_DELAY_MS = 5_000;
 const MAX_CONNECTION_RETRY_DELAY_MS = 60_000;
 const MAX_ERROR_BODY_BYTES = 64 * 1024;
 function aborted(message = 'native Codex request was aborted') {
-    return new LlmError(message, 'ABORTED');
+    return retryError(message, 'ABORTED');
 }
 function throwIfAborted(signal) {
     if (!signal?.aborted)
@@ -29,7 +30,7 @@ function throwIfAborted(signal) {
     throw aborted();
 }
 function fixedFailure(message, code, options) {
-    return new LlmError(message, code, options);
+    return retryError(message, code, options);
 }
 function safePositiveInteger(value, fallback, name) {
     const resolved = value ?? fallback;
@@ -52,24 +53,6 @@ function stablePromptCacheKey(sessionId) {
     const hex = bytes.toString('hex');
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
-function sleep(delayMs, signal) {
-    throwIfAborted(signal);
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(done, delayMs);
-        const abort = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', abort);
-            const reason = signal?.reason;
-            reject(reason instanceof LlmError
-                ? reason : aborted('native Codex retry wait was aborted'));
-        };
-        function done() {
-            signal?.removeEventListener('abort', abort);
-            resolve();
-        }
-        signal?.addEventListener('abort', abort, { once: true });
-    });
-}
 function attemptWatchdog(parent, requestMs, idleMs) {
     const controller = new AbortController();
     let timeout;
@@ -252,18 +235,8 @@ async function boundedError(response, signal, telemetry) {
         return {};
     }
 }
-function retryAfterMs(response, maxDelayMs) {
-    const raw = response.headers.get('retry-after');
-    if (raw === null)
-        return undefined;
-    const seconds = Number(raw);
-    const value = Number.isFinite(seconds)
-        ? seconds * 1_000
-        : Date.parse(raw) - Date.now();
-    return Number.isFinite(value) && value > 0 ? Math.min(value, maxDelayMs) : undefined;
-}
-function errorFacts(response, maxDelayMs) {
-    const providerRetryAfterMs = retryAfterMs(response, maxDelayMs);
+function errorFacts(response) {
+    const providerRetryAfterMs = retryAfterMs(response.headers.get('retry-after'));
     const requestId = response.headers.get('x-request-id');
     return {
         status: response.status,
@@ -273,37 +246,43 @@ function errorFacts(response, maxDelayMs) {
             : { requestId: ProviderRequestId(requestId) },
     };
 }
-async function httpFailure(response, maxDelayMs, signal, telemetry) {
+async function httpFailure(response, signal, telemetry) {
+    const facts = errorFacts(response);
+    const advice = retryError('native Codex HTTP retry advice', 'SERVER', facts);
+    const fail = (message, code, options) => inheritRetryDeadline(fixedFailure(message, code, options), advice);
     const detail = await boundedError(response, signal, telemetry);
-    const facts = errorFacts(response, maxDelayMs);
     const classified = responsesFailure(detail.code, detail.message);
     if (response.status === 401 || response.status === 403) {
-        return fixedFailure('native Codex rejected the configured credential', 'AUTH', facts);
+        return fail('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, {
+        return fail(classified.message, classified.code, {
             ...facts,
-            ...(delay === undefined ? {} : { providerRetryAfterMs: Math.min(delay, maxDelayMs) }),
+            ...(delay === undefined ? {} : { providerRetryAfterMs: delay }),
         });
     }
     if (response.status === 429) {
-        return fixedFailure('native Codex request was rate limited', 'RATE_LIMIT', facts);
+        return fail('native Codex request was rate limited', 'RATE_LIMIT', facts);
     }
     if (response.status === 408 || response.status === 504) {
-        return fixedFailure('native Codex request timed out', 'TIMEOUT', facts);
+        return fail('native Codex request timed out', 'TIMEOUT', facts);
     }
     if (response.status >= 500) {
-        return fixedFailure('native Codex server request failed', 'SERVER', facts);
+        return fail('native Codex server request failed', 'SERVER', facts);
     }
-    return fixedFailure('native Codex request was rejected', 'INVALID_REQUEST', facts);
+    return fail('native Codex request was rejected', 'INVALID_REQUEST', facts);
 }
 function mappedFailure(error, watchdog, parent) {
     if (parent?.aborted) {
         return parent.reason instanceof LlmError ? parent.reason : aborted();
     }
     if (watchdog.timedOut())
-        return fixedFailure('native Codex request timed out', 'TIMEOUT');
+        return fixedFailure('native Codex request timed out', 'TIMEOUT', {
+            cause: error,
+            ...(error instanceof LlmError && error.failure.providerRetryAfterMs !== undefined
+                ? { providerRetryAfterMs: error.failure.providerRetryAfterMs } : {}),
+        });
     if (error instanceof LlmError)
         return error;
     return fixedFailure('native Codex transport failed', 'TRANSPORT', { cause: error });
@@ -331,8 +310,7 @@ function retryable(error) {
 }
 function failedStepRetry(error) {
     const failure = error.failure;
-    const providerRetryAfterMs = failure.providerRetryAfterMs === undefined
-        ? undefined : Math.min(failure.providerRetryAfterMs, DEFAULT_MAX_RETRY_DELAY_MS);
+    const providerRetryAfterMs = failure.providerRetryAfterMs;
     return fixedFailure(`native Codex response stream was interrupted: ${error.message}`, NATIVE_CODEX_STREAM_INTERRUPTED_CODE, {
         cause: error,
         ...(failure.status === undefined ? {} : { status: failure.status }),
@@ -362,21 +340,21 @@ export class NativeCodexHttpTransport {
     }
     retryDelay(retry, providerDelay) {
         if (providerDelay !== undefined)
-            return Math.min(providerDelay, this.maxDelayMs);
+            return providerDelay;
         const exponential = Math.min(this.initialDelayMs * (2 ** retry), this.maxDelayMs);
         const random = this.options.random?.() ?? Math.random();
         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, telemetry) {
-        const delay = this.retryDelay(retry, error.failure.providerRetryAfterMs);
+        const delay = this.retryDelay(retry, remainingRetryDelay(error));
         telemetry.retry(delay);
-        await (this.options.sleep ?? sleep)(delay, signal);
+        await (this.options.sleep ?? sleepRetry)(delay, 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);
+        await (this.options.sleep ?? sleepRetry)(delayMs, signal);
     }
     endpointUrl() { return this.endpoint; }
     async prepare(generation, mode = {}) {
@@ -527,7 +505,7 @@ export class NativeCodexHttpTransport {
                         telemetry.retry(0);
                         continue;
                     }
-                    throw fixedFailure('native Codex rejected the configured credential', 'AUTH', errorFacts(response, this.maxDelayMs));
+                    throw fixedFailure('native Codex rejected the configured credential', 'AUTH', errorFacts(response));
                 }
                 catch (error) {
                     const connection = connectionFailure(error, watchdog, generation.signal);
@@ -542,7 +520,7 @@ export class NativeCodexHttpTransport {
                 }
             }
             if (!response.ok) {
-                let failure = await httpFailure(response, this.maxDelayMs, watchdog.signal, telemetry);
+                let failure = await httpFailure(response, watchdog.signal, telemetry);
                 if (generation.signal?.aborted || watchdog.timedOut()) {
                     failure = mappedFailure(failure, watchdog, generation.signal);
                 }

package/lib/native-websocket-socket.js

@@ -3,11 +3,12 @@ import { LlmError, ProviderRequestId } from '@deepseek-ai/dsh-llm';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 import { getProxyForUrl } from 'proxy-from-env';
 import { nativeCodexEndpoint } from './endpoint.js';
+import { retryAfterMs, retryError } from './retry-after.js';
 import { NATIVE_CODEX_CONNECTION_FAILED_CODE, isNativeCodexConnectionFailure, } from './native-adapter.js';
 import WebSocket from 'ws';
 const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
 function failure(message, code, cause) {
-    return new LlmError(message, code, cause === undefined ? undefined : { cause });
+    return retryError(message, code, cause === undefined ? undefined : { cause });
 }
 function abortFailure(signal) {
     return signal?.reason instanceof LlmError
@@ -17,9 +18,7 @@ function abortFailure(signal) {
 function handshakeFacts(status, headers) {
     const first = (value) => Array.isArray(value) ? value[0] : value;
     const requestId = first(headers['x-request-id']);
-    const retryAfter = Number(first(headers['retry-after']));
-    const providerRetryAfterMs = Number.isFinite(retryAfter) && retryAfter > 0
-        ? Math.min(retryAfter * 1_000, 120_000) : undefined;
+    const providerRetryAfterMs = retryAfterMs(first(headers['retry-after']));
     return {
         ...(status === undefined ? {} : { status }),
         ...(providerRetryAfterMs === undefined ? {} : { providerRetryAfterMs }),
@@ -202,7 +201,7 @@ export class NodeNativeCodexWebSocketFactory {
                                     ? 'WS_RETRYABLE'
                                     : response.statusCode !== undefined && response.statusCode >= 400
                                         ? 'INVALID_REQUEST' : 'WS_HANDSHAKE';
-                reject(new LlmError(`native Codex WebSocket handshake failed (HTTP ${response.statusCode ?? 0})`, code, handshakeFacts(response.statusCode, response.headers)));
+                reject(retryError(`native Codex WebSocket handshake failed (HTTP ${response.statusCode ?? 0})`, code, handshakeFacts(response.statusCode, response.headers)));
             });
             socket.on('open', () => {
                 options.signal?.removeEventListener('abort', abort);

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 { retryError, remainingRetryDelay, sleepRetry, jsonRetryAfterMs } from './retry-after.js';
 import { networkTelemetry, trackNetwork, observeNetworkOutput } from './network-telemetry.js';
 import { LlmError, ProviderRequestId, attributionHeaders, } from '@deepseek-ai/dsh-llm';
 import { nativeCodexAuthorityHash } from './catalog.js';
@@ -22,7 +23,7 @@ const INITIAL_CONNECTION_RETRY_DELAY_MS = 5_000;
 const MAX_CONNECTION_RETRY_DELAY_MS = 60_000;
 const MAX_TURN_STATE_BYTES = 4096;
 function failure(message, code, cause) {
-    return new LlmError(message, code, cause === undefined ? undefined : { cause });
+    return retryError(message, code, cause === undefined ? undefined : { cause });
 }
 function reconnectable(code) {
     return [
@@ -36,9 +37,8 @@ function failedStepRetryable(code) {
 }
 function failedStepRetry(error) {
     const facts = error.failure;
-    const providerRetryAfterMs = facts.providerRetryAfterMs === undefined
-        ? undefined : Math.min(facts.providerRetryAfterMs, DEFAULT_MAX_RETRY_DELAY_MS);
-    return new LlmError(`native Codex response stream was interrupted: ${error.message}`, NATIVE_CODEX_STREAM_INTERRUPTED_CODE, {
+    const providerRetryAfterMs = facts.providerRetryAfterMs;
+    return retryError(`native Codex response stream was interrupted: ${error.message}`, NATIVE_CODEX_STREAM_INTERRUPTED_CODE, {
         cause: error,
         ...(facts.status === undefined ? {} : { status: facts.status }),
         ...(providerRetryAfterMs === undefined ? {} : { providerRetryAfterMs }),
@@ -65,26 +65,6 @@ function retryCount(value) {
     }
     return resolved;
 }
-function sleep(delayMs, signal) {
-    if (signal?.aborted) {
-        return Promise.reject(failure('native Codex WebSocket retry wait was aborted', 'ABORTED'));
-    }
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(done, delayMs);
-        const abort = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', abort);
-            const reason = signal?.reason;
-            reject(reason instanceof LlmError
-                ? reason : failure('native Codex WebSocket retry wait was aborted', 'ABORTED'));
-        };
-        function done() {
-            signal?.removeEventListener('abort', abort);
-            resolve();
-        }
-        signal?.addEventListener('abort', abort, { once: true });
-    });
-}
 function socketCredential(credential) {
     return createHash('sha256')
         .update(credential.accountId).update('\0').update(credential.accessToken)
@@ -123,15 +103,17 @@ function withRequestMetadata(request, turnState, responsesLite) {
         },
     };
 }
-function normalizedOutputItem(event) {
+function normalizedOutputItem(event, translator) {
     if (event.type !== 'response.output_item.done' || event.item === undefined)
         return undefined;
     const item = event.item;
     const id = replayableItemId(item.id);
     if (item.type === 'message') {
+        const phase = item.id === undefined ? undefined : translator.messagePhase(item.id);
         return {
             type: 'message', ...(id === undefined ? {} : { id }), role: 'assistant',
             content: (item.content ?? []).map(part => ({ type: 'output_text', text: part.text })),
+            ...(phase === undefined ? {} : { phase }),
         };
     }
     if (item.type === 'reasoning') {
@@ -164,10 +146,9 @@ function eventHeader(event, name) {
 }
 function eventErrorFacts(event, status) {
     const requestId = eventHeader(event, 'x-request-id');
-    const retryAfter = eventHeader(event, 'retry-after');
-    const seconds = retryAfter === undefined ? undefined : Number(retryAfter);
-    const retryMs = seconds !== undefined && Number.isFinite(seconds) && seconds > 0
-        ? Math.min(seconds * 1_000, 120_000) : undefined;
+    const nested = typeof event.error === 'object' && event.error !== null
+        ? event.error : undefined;
+    const retryMs = jsonRetryAfterMs(nested?.headers) ?? jsonRetryAfterMs(event.headers);
     return {
         ...(status === undefined ? {} : { status }),
         ...(retryMs === undefined ? {} : { providerRetryAfterMs: retryMs }),
@@ -187,28 +168,28 @@ function eventFailure(event) {
     const facts = eventErrorFacts(event, status);
     if (providerCode === 'websocket_connection_limit_reached'
         || providerCode === 'previous_response_not_found') {
-        return new LlmError('native Codex WebSocket requested a fresh connection', 'WS_RETRYABLE_RESET', facts);
+        return retryError('native Codex WebSocket requested a fresh connection', 'WS_RETRYABLE_RESET', facts);
     }
     if (providerCode === 'unauthorized' || providerCode === 'invalid_api_key' || status === 401) {
-        return new LlmError('native Codex WebSocket authentication failed', 'WS_AUTH', facts);
+        return retryError('native Codex WebSocket authentication failed', 'WS_AUTH', facts);
     }
     if (status === 403)
-        return new LlmError('native Codex WebSocket authorization failed', 'AUTH', facts);
+        return retryError('native Codex WebSocket authorization failed', 'AUTH', facts);
     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, {
+        return retryError(classified.message, classified.code === 'RATE_LIMIT' ? 'RATE_LIMITED' : classified.code, {
             ...facts,
-            ...(delay === undefined ? {} : { providerRetryAfterMs: Math.min(delay, 120_000) }),
+            ...(delay === undefined ? {} : { providerRetryAfterMs: delay }),
         });
     }
     if (providerCode === 'usage_limit_reached' || status === 429) {
-        return new LlmError('native Codex WebSocket rate limit was reached', 'RATE_LIMITED', facts);
+        return retryError('native Codex WebSocket rate limit was reached', 'RATE_LIMITED', facts);
     }
     if (status !== undefined && status >= 500) {
-        return new LlmError('native Codex WebSocket service failed', 'WS_RETRYABLE', facts);
+        return retryError('native Codex WebSocket service failed', 'WS_RETRYABLE', facts);
     }
-    return new LlmError('native Codex WebSocket request was rejected', 'INVALID_REQUEST', facts);
+    return retryError('native Codex WebSocket request was rejected', 'INVALID_REQUEST', facts);
 }
 /** Prefer WebSocket v2; once safe retries exhaust, keep that DSH session on HTTP. */
 export class NativeCodexWebSocketTransport {
@@ -239,9 +220,9 @@ export class NativeCodexWebSocketTransport {
         this.maxRetryDelayMs = boundedPositive(options.maxRetryDelayMs, DEFAULT_MAX_RETRY_DELAY_MS, 120_000, 'WebSocket maximum retry delay');
     }
     retryDelay(retry, error) {
-        const providerDelay = error.failure.providerRetryAfterMs;
+        const providerDelay = remainingRetryDelay(error);
         if (providerDelay !== undefined)
-            return Math.min(providerDelay, this.maxRetryDelayMs);
+            return providerDelay;
         const exponential = Math.min(this.initialRetryDelayMs * (2 ** retry), this.maxRetryDelayMs);
         const random = this.options.random?.() ?? Math.random();
         const jitter = 0.9 + Math.max(0, Math.min(1, random)) * 0.2;
@@ -250,12 +231,12 @@ export class NativeCodexWebSocketTransport {
     async wait(retry, error, signal, telemetry) {
         const delay = this.retryDelay(retry, error);
         telemetry.retry(delay);
-        await (this.options.sleep ?? sleep)(delay, signal);
+        await (this.options.sleep ?? sleepRetry)(delay, 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);
+        await (this.options.sleep ?? sleepRetry)(delayMs, signal);
     }
     closeEntry(entry) {
         entry.socket?.close();
@@ -425,7 +406,8 @@ export class NativeCodexWebSocketTransport {
                 if (nextTurnState !== undefined)
                     entry.turnState = nextTurnState;
             }
-            const output = normalizedOutputItem(event);
+            const chunks = translator.push(event);
+            const output = normalizedOutputItem(event, translator);
             if (output !== undefined)
                 outputItems.push(output);
             if (event.type === 'response.completed') {
@@ -436,7 +418,6 @@ export class NativeCodexWebSocketTransport {
                 const responseId = typeof response?.id === 'string' ? response.id : '';
                 entry.protocol.complete(responseId, outputItems);
             }
-            const chunks = translator.push(event);
             if (!prewarm)
                 for (const chunk of chunks)
                     yield chunk;
@@ -617,7 +598,11 @@ export class NativeCodexWebSocketTransport {
                     }
                     if (failureValue.code === 'WS_UPGRADE_REQUIRED' || retryable) {
                         entry.disabled = true;
-                        telemetry.retry(0);
+                        if (remainingRetryDelay(failureValue) !== undefined) {
+                            await this.wait(reconnects, failureValue, signal, telemetry);
+                        }
+                        else
+                            telemetry.retry(0);
                         yield* this.http.stream(activeGeneration, fallbackMode(), telemetry);
                         requestCompleted = true;
                         return;

package/lib/replay.d.ts

@@ -2,10 +2,13 @@
 import { type ContentBlock } from '@deepseek-ai/dsh-llm';
 export declare const NATIVE_CODEX_REPLAY_KIND = "openai-codex-native.responses-replay";
 export declare const NATIVE_CODEX_REPLAY_VERSION = 1;
+export type CodexMessagePhase = 'commentary' | 'partial_answer' | 'final_answer';
+export declare function isCodexMessagePhase(value: unknown): value is CodexMessagePhase;
 export type NativeCodexReplayDescriptor = {
     type: 'message';
     id?: string;
     blocks: number[];
+    phase?: CodexMessagePhase;
 } | {
     type: 'reasoning';
     id?: string;

package/lib/replay.js

@@ -2,6 +2,9 @@
 import { LlmError } from '@deepseek-ai/dsh-llm';
 export const NATIVE_CODEX_REPLAY_KIND = 'openai-codex-native.responses-replay';
 export const NATIVE_CODEX_REPLAY_VERSION = 1;
+export function isCodexMessagePhase(value) {
+    return value === 'commentary' || value === 'partial_answer' || value === 'final_answer';
+}
 function failure(message, code = 'INVALID_REPLAY_STATE') {
     return new LlmError(message, code);
 }
@@ -55,10 +58,12 @@ function parseDescriptor(value) {
     }
     if (row.type === 'message') {
         const blocks = validateBlockArray(row.blocks);
-        if (blocks === undefined || !onlyKeys(row, ['type', 'id', 'blocks'])) {
+        if (blocks === undefined || (row.phase !== undefined && !isCodexMessagePhase(row.phase))
+            || !onlyKeys(row, ['type', 'id', 'blocks', 'phase'])) {
             throw failure('native Codex message replay descriptor is invalid');
         }
-        return { type: 'message', ...(id === undefined ? {} : { id }), blocks };
+        return { type: 'message', ...(id === undefined ? {} : { id }), blocks,
+            ...(row.phase === undefined ? {} : { phase: row.phase }) };
     }
     if (row.type === 'reasoning') {
         const blocks = validateBlockArray(row.blocks);
@@ -179,6 +184,7 @@ export function replayAssistantInput(content, source) {
             input.push({
                 type: 'message', ...(item.id === undefined ? {} : { id: item.id }),
                 role: 'assistant', content: parts,
+                ...(item.phase === undefined ? {} : { phase: item.phase }),
             });
         }
         else if (item.type === 'reasoning') {

package/lib/responses.d.ts

@@ -1,6 +1,6 @@
 import { ToolCallId, LlmError, type ContentBlock, type GenerateOptions, type StreamChunk, type TokenUsage, type ToolSchema } from '@deepseek-ai/dsh-llm';
 import { type ParseSseOptions } from './sse.js';
-import { type NativeCodexReplaySource } from './replay.js';
+import { type CodexMessagePhase, type NativeCodexReplaySource } from './replay.js';
 export declare const DEFAULT_CODEX_INSTRUCTIONS = "You are Codex, an AI coding agent. Help the user with software engineering tasks.";
 export type CodexImageDetail = 'auto' | 'low' | 'high' | 'original';
 export interface ResolvedImagePart {
@@ -53,7 +53,7 @@ export interface ResponsesUsage {
 /** Map provider totals to DSH's strict disjoint token counts. */
 export declare function mapResponsesUsage(usage: ResponsesUsage): TokenUsage;
 /** Classify in-band failure data without reflecting provider text. */
-export declare function responsesFailure(code?: string, message?: string): LlmError;
+export declare function responsesFailure(code?: string, message?: string, headers?: unknown): LlmError;
 interface ResponsesOutputItem {
     type?: string;
     id?: string;
@@ -64,6 +64,7 @@ interface ResponsesOutputItem {
     encrypted_content?: string;
     summary?: unknown[];
     status?: string;
+    phase?: CodexMessagePhase | null;
     content?: Array<{
         type?: string;
         text?: string;
@@ -86,6 +87,7 @@ export interface ResponsesStreamEvent {
         error?: {
             code?: string;
             message?: string;
+            headers?: unknown;
         };
         incomplete_details?: {
             reason?: string;
@@ -103,11 +105,15 @@ export declare class ResponsesStreamTranslator {
     private readonly replayContext?;
     private readonly blocks;
     private readonly order;
+    private readonly messagePhases;
     private readonly replayCapture;
     private nextIndex;
     private sawToolCall;
     terminated: boolean;
     constructor(replayContext?: ResponsesReplayContext | undefined);
+    /** The same effective phase feeds durable replay and WebSocket prefix comparison. */
+    messagePhase(id: string): CodexMessagePhase | undefined;
+    private captureMessagePhase;
     private append;
     private fill;
     private open;

package/lib/responses.js

@@ -2,7 +2,8 @@
 import { createHash } from 'node:crypto';
 import { ToolCallId, CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, isContextWindowExceededError, isQuotaExceededError, LlmError, QUOTA_EXCEEDED_CODE, } from '@deepseek-ai/dsh-llm';
 import { parseSse } from './sse.js';
-import { NativeCodexReplayCapture, replayAssistantInput, replayableItemId, } from './replay.js';
+import { jsonRetryAfterMs, retryError } from './retry-after.js';
+import { NativeCodexReplayCapture, isCodexMessagePhase, replayAssistantInput, replayableItemId, } from './replay.js';
 export const DEFAULT_CODEX_INSTRUCTIONS = 'You are Codex, an AI coding agent. Help the user with software engineering tasks.';
 const CALL_ID_MAX_LENGTH = 64;
 const CALL_ID_PREFIX = 'call_';
@@ -211,11 +212,21 @@ export function codexRequestBody(options, messages, mode = {}) {
         ...mode.serviceTier === undefined ? {} : { service_tier: mode.serviceTier },
         ...options.sessionId === undefined ? {} : { prompt_cache_key: String(options.sessionId) },
     };
+    const baseInstructions = mode.responsesLite?.instructionsTemplate ?? instructions;
+    const prefixNamespace = uuidBytes(uuidV5(UUID_NAMESPACE_OID, String(options.sessionId ?? options.model)));
+    const instructionPrefix = baseInstructions.length === 0 ? [] : [{
+            type: 'message',
+            id: `msg_${uuidV5(prefixNamespace, baseInstructions)}`,
+            role: 'developer',
+            content: [{ type: 'input_text', text: baseInstructions }],
+            internal_chat_message_metadata_passthrough: {
+                content_item_kinds: ['model.base_instructions'],
+            },
+        }];
     if (mode.responsesLite === undefined) {
         return {
             ...common,
-            instructions,
-            input,
+            input: [...instructionPrefix, ...input],
             ...options.tools !== undefined && options.tools.length > 0
                 ? { tools: toResponsesTools(options.tools) } : {},
             parallel_tool_calls: true,
@@ -224,7 +235,6 @@ export function codexRequestBody(options, messages, mode = {}) {
         };
     }
     const tools = toResponsesLiteTools(options.tools ?? []);
-    const baseInstructions = mode.responsesLite.instructionsTemplate ?? instructions;
     const contextualInstructions = mode.responsesLite.instructionsTemplate !== undefined
         && resolved.instructions !== undefined && resolved.instructions !== baseInstructions
         ? [{
@@ -232,21 +242,12 @@ export function codexRequestBody(options, messages, mode = {}) {
                 content: [{ type: 'input_text', text: resolved.instructions }],
             }]
         : [];
-    const prefixNamespace = uuidBytes(uuidV5(UUID_NAMESPACE_OID, String(options.sessionId ?? options.model)));
     const prefix = [{
             type: 'additional_tools',
             id: `at_${uuidV5(prefixNamespace, JSON.stringify(tools))}`,
             role: 'developer',
             tools,
-        }, {
-            type: 'message',
-            id: `msg_${uuidV5(prefixNamespace, baseInstructions)}`,
-            role: 'developer',
-            content: [{ type: 'input_text', text: baseInstructions }],
-            internal_chat_message_metadata_passthrough: {
-                content_item_kinds: ['model.base_instructions'],
-            },
-        }];
+        }, ...instructionPrefix];
     return {
         ...common,
         input: [...prefix, ...contextualInstructions, ...input],
@@ -293,10 +294,11 @@ function retryDelay(message) {
     const value = Number(match[1]);
     if (!Number.isFinite(value) || value <= 0)
         return undefined;
-    return Math.min(match[2]?.toLowerCase() === 'ms' ? value : value * 1000, 600_000);
+    const delay = match[2]?.toLowerCase() === 'ms' ? value : value * 1000;
+    return Number.isFinite(delay) && delay <= Number.MAX_SAFE_INTEGER ? delay : undefined;
 }
 /** Classify in-band failure data without reflecting provider text. */
-export function responsesFailure(code, message) {
+export function responsesFailure(code, message, headers) {
     const detail = `${code ?? ''} ${message ?? ''}`;
     if (code === 'context_length_exceeded' || code === 'context_window_exceeded'
         || isContextWindowExceededError(detail)) {
@@ -308,8 +310,8 @@ export function responsesFailure(code, message) {
         return fixedError('native Codex account quota is exhausted', QUOTA_EXCEEDED_CODE);
     }
     if (code === 'rate_limit_exceeded' || code === 'slow_down') {
-        const delay = retryDelay(message);
-        return new LlmError('native Codex request was rate limited', 'RATE_LIMIT', {
+        const delay = jsonRetryAfterMs(headers) ?? retryDelay(message);
+        return retryError('native Codex request was rate limited', 'RATE_LIMIT', {
             ...delay === undefined ? {} : { providerRetryAfterMs: delay },
         });
     }
@@ -319,7 +321,10 @@ export function responsesFailure(code, message) {
     if (code === 'bio_policy') {
         return fixedError('native Codex rejected the request', 'INVALID_REQUEST');
     }
-    return fixedError('native Codex reported a failed response', 'SERVER');
+    const delay = jsonRetryAfterMs(headers);
+    return retryError('native Codex reported a failed response', 'SERVER', {
+        ...delay === undefined ? {} : { providerRetryAfterMs: delay },
+    });
 }
 function eventItemId(event) {
     if (typeof event.item_id === 'string' && event.item_id.length > 0)
@@ -343,6 +348,7 @@ export class ResponsesStreamTranslator {
     replayContext;
     blocks = new Map();
     order = [];
+    messagePhases = new Map();
     replayCapture;
     nextIndex = 0;
     sawToolCall = false;
@@ -353,6 +359,18 @@ export class ResponsesStreamTranslator {
             ? undefined
             : new NativeCodexReplayCapture(replayContext.provider, replayContext.model);
     }
+    /** The same effective phase feeds durable replay and WebSocket prefix comparison. */
+    messagePhase(id) {
+        return this.messagePhases.get(id);
+    }
+    captureMessagePhase(item) {
+        if (item.phase === undefined || item.phase === null)
+            return;
+        if (!isCodexMessagePhase(item.phase) || typeof item.id !== 'string' || item.id.length === 0) {
+            throw fixedError('native Codex message phase is invalid', 'MALFORMED_RESPONSE');
+        }
+        this.messagePhases.set(item.id, item.phase);
+    }
     append(block, delta) {
         block.text += delta;
     }
@@ -400,6 +418,8 @@ export class ResponsesStreamTranslator {
         switch (event.type) {
             case 'response.output_item.added': {
                 const item = event.item;
+                if (item?.type === 'message')
+                    this.captureMessagePhase(item);
                 if (item?.type !== 'function_call')
                     return chunks;
                 if (item.id === undefined || item.id.length === 0
@@ -483,6 +503,8 @@ export class ResponsesStreamTranslator {
                         });
                 }
                 else if (item.type === 'message') {
+                    this.captureMessagePhase(item);
+                    const phase = this.messagePhase(item.id);
                     if (!Array.isArray(item.content)) {
                         throw fixedError('native Codex message item has invalid content', 'MALFORMED_RESPONSE');
                     }
@@ -507,6 +529,7 @@ export class ResponsesStreamTranslator {
                     if (this.replayContext !== undefined)
                         this.replayCapture?.add({
                             type: 'message', ...(replayId === undefined ? {} : { id: replayId }), blocks: refs,
+                            ...(phase === undefined ? {} : { phase }),
                         });
                 }
                 else if (item.type === 'reasoning') {
@@ -595,7 +618,7 @@ export class ResponsesStreamTranslator {
                 return chunks;
             }
             case 'response.failed':
-                throw responsesFailure(event.response?.error?.code, event.response?.error?.message);
+                throw responsesFailure(event.response?.error?.code, event.response?.error?.message, event.response?.error?.headers);
             case 'error':
                 throw responsesFailure(event.code, event.message);
             default:

package/lib/retry-after.d.ts

@@ -0,0 +1,9 @@
+/** Server advice is separate from the client's bounded exponential backoff. */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+export declare function retryAfterMs(raw: unknown): number | undefined;
+export declare function jsonRetryAfterMs(headers: unknown): number | undefined;
+export declare function retryError(message: string, code: string, options?: ConstructorParameters<typeof LlmError>[2]): LlmError;
+export declare function inheritRetryDeadline(error: LlmError, source: LlmError): LlmError;
+export declare function remainingRetryDelay(error: LlmError): number | undefined;
+/** Node timers overflow above 2^31-1; chunk long waits without shortening advice. */
+export declare function sleepRetry(delay: number, signal?: AbortSignal): Promise<void>;

package/lib/retry-after.js

@@ -0,0 +1,109 @@
+/** Server advice is separate from the client's bounded exponential backoff. */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+const deadlines = new WeakMap();
+function httpDate(value) {
+    const standard = /^([A-Za-z]{3}), ([0-9]{2}) ([A-Za-z]{3}) ([0-9]{4}) ([0-9]{2}:[0-9]{2}:[0-9]{2}) GMT$/.exec(value);
+    const obsolete = /^([A-Za-z]+), ([0-9]{2})-([A-Za-z]{3})-([0-9]{2}) ([0-9]{2}:[0-9]{2}:[0-9]{2}) GMT$/.exec(value);
+    const ascii = /^([A-Za-z]{3}) ([A-Za-z]{3}) ([ 0-9][0-9]) ([0-9]{2}:[0-9]{2}:[0-9]{2}) ([0-9]{4})$/.exec(value);
+    const parts = standard ?? obsolete;
+    const weekday = parts?.[1] ?? ascii?.[1];
+    const day = parts?.[2] ?? ascii?.[3];
+    const month = parts?.[3] ?? ascii?.[2];
+    const year = parts?.[4] ?? ascii?.[5];
+    const time = parts?.[5] ?? ascii?.[4];
+    if (!weekday || !day || !month || !year || !time)
+        return undefined;
+    const timestamp = Date.parse(value.endsWith('GMT') ? value : value + ' GMT');
+    if (!Number.isFinite(timestamp))
+        return undefined;
+    const date = new Date(timestamp);
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const weekdays = obsolete
+        ? ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+        : ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    // Date.parse normalizes impossible dates; HTTP header parsing must reject them.
+    if (date.getUTCDate() !== Number(day) || months[date.getUTCMonth()] !== month
+        || weekdays[date.getUTCDay()] !== weekday
+        || (obsolete ? date.getUTCFullYear() % 100 : date.getUTCFullYear()) !== Number(year)
+        || date.toISOString().slice(11, 19) !== time)
+        return undefined;
+    return timestamp;
+}
+export function retryAfterMs(raw) {
+    if (typeof raw !== 'string' && typeof raw !== 'number')
+        return undefined;
+    const text = String(raw);
+    if (/[^\t\x20-\x7e]/.test(text))
+        return undefined;
+    const value = text.trim();
+    let delay;
+    if (/^\d+$/.test(value))
+        delay = Number(value) * 1000;
+    else {
+        const timestamp = httpDate(value);
+        if (timestamp === undefined)
+            return undefined;
+        delay = Math.max(0, timestamp - Date.now());
+    }
+    return Number.isSafeInteger(delay) && delay >= 0 ? delay : undefined;
+}
+export function jsonRetryAfterMs(headers) {
+    if (typeof headers !== 'object' || headers === null || Array.isArray(headers))
+        return undefined;
+    let value;
+    // serde_json's ordered map inserts later case variants over earlier ones.
+    for (const key of Object.keys(headers).sort()) {
+        const raw = headers[key];
+        if (key.toLowerCase() === 'retry-after'
+            && (typeof raw === 'string' || typeof raw === 'number' || typeof raw === 'boolean')
+            && !/[^\t\x20-\x7e]/.test(String(raw)))
+            value = raw;
+    }
+    return retryAfterMs(value);
+}
+export function retryError(message, code, options) {
+    const delay = options?.providerRetryAfterMs;
+    // The host permits only positive duration metadata; retain zero advice locally.
+    const normalized = { ...options };
+    if (delay === 0)
+        delete normalized.providerRetryAfterMs;
+    const error = new LlmError(message, code, normalized);
+    const inherited = options?.cause instanceof LlmError ? deadlines.get(options.cause) : undefined;
+    if (inherited !== undefined || delay !== undefined) {
+        deadlines.set(error, inherited ?? performance.now() + delay);
+    }
+    return error;
+}
+export function inheritRetryDeadline(error, source) {
+    const deadline = deadlines.get(source);
+    if (deadline !== undefined)
+        deadlines.set(error, deadline);
+    return error;
+}
+export function remainingRetryDelay(error) {
+    let deadline = deadlines.get(error);
+    if (deadline === undefined) {
+        const delay = error.failure.providerRetryAfterMs;
+        if (delay === undefined)
+            return undefined;
+        deadline = performance.now() + delay;
+        deadlines.set(error, deadline);
+    }
+    return Math.max(0, Math.ceil(deadline - performance.now()));
+}
+/** Node timers overflow above 2^31-1; chunk long waits without shortening advice. */
+export async function sleepRetry(delay, signal) {
+    const deadline = performance.now() + delay;
+    do {
+        if (signal?.aborted)
+            throw signal.reason instanceof LlmError ? signal.reason : new LlmError('native Codex retry wait was aborted', 'ABORTED');
+        const remaining = Math.max(0, Math.ceil(deadline - performance.now()));
+        if (remaining === 0)
+            return;
+        await new Promise((resolve, reject) => {
+            const abort = () => { clearTimeout(timer); reject(signal?.reason instanceof LlmError ? signal.reason : new LlmError('native Codex retry wait was aborted', 'ABORTED')); };
+            const timer = setTimeout(() => { signal?.removeEventListener('abort', abort); resolve(); }, Math.min(remaining, 2_147_483_647));
+            signal?.addEventListener('abort', abort, { once: true });
+        });
+    } while (true);
+}

package/lib/upstream.d.ts

@@ -4,5 +4,5 @@ export declare const TRACKED_CODEX_COMMIT = "ddf04ad26789d040f9ef6a96736f76602e3
 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.155.0";
+/** Whole client version sent to the catalog; live gating can exceed bundled model minima. */
+export declare const CODEX_CLIENT_VERSION = "0.162.0";

package/lib/upstream.js

@@ -4,5 +4,5 @@ export const TRACKED_CODEX_COMMIT = 'ddf04ad26789d040f9ef6a96736f76602e35a6cc';
 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.155.0';
+/** Whole client version sent to the catalog; live gating can exceed bundled model minima. */
+export const CODEX_CLIENT_VERSION = '0.162.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Native ChatGPT Codex provider, device-code-first login, and same-origin Web integration for DeepSeek Harness",
   "license": "MIT",
   "publishConfig": {
@@ -53,6 +53,8 @@
     "lib/responses.d.ts",
     "lib/replay.js",
     "lib/replay.d.ts",
+    "lib/retry-after.js",
+    "lib/retry-after.d.ts",
     "lib/rate-limits.js",
     "lib/rate-limits.d.ts",
     "lib/response-usage.js",
@@ -96,7 +98,7 @@
   },
   "dsh": {
     "engines": {
-      "dsh": "0.1.7-rc.2"
+      "dsh": "0.2.0-rc.2"
     },
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -113,19 +115,19 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-attachment": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-credentials": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-llm": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox-policy": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-shell": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-tools": "0.1.7-rc.2"
+    "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-credentials": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-fs": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-shell": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2"
   },
   "dependencies": {
-    "@deepseek-ai/dsh-atomic-write": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-home-paths": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-atomic-write": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.2.0-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1",
     "https-proxy-agent": "7.0.6",
     "image-size": "^2.0.2",
@@ -134,23 +136,23 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-attachment": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-attachment-local": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-store": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-model-selection": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-credentials": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-fs": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-llm": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-sandbox-policy": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-scope": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-shell": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-tools": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-web-frontend": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-attachment-local": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-store": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-model-selection": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-credentials": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-fs": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-shell": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-web-frontend": "0.2.0-rc.2",
     "@types/node": "^22.20.0",
     "@types/proxy-from-env": "1.0.4",
     "@types/ws": "8.18.1",