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

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## 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
+
+- Migrated to DSH 0.1.7-rc.2 SDK
+- Updated tool message format: tool results are now role:'tool' with top-level toolCallId/isError
+- Migrated shell.run to shell.execute with result() method
+- Updated peer dependencies to 0.1.7-rc.2
+- Updated cordis to ~4.0.4
+- Preserved developer messages in HTTP/WS wire requests
+- Restored successful-result-only matched provenance in cloud context
+- Added mismatch/failed-result regressions in cloud context tests
+
+### Key Changes
+
+- Tool messages: role:'tool' with top-level toolCallId/isError (no longer tool-result content blocks)
+- Shell: execute() then .result() instead of run()
+- 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.
@@ -131,4 +166,4 @@
 - Rejects redirects for credential-bearing OAuth, Catalog, Responses, and subscription-usage requests.
 - Keeps OAuth credentials and account authority host-side, validates credential-bearing endpoint authorities, bounds request/response/replay/WebSocket state, and refuses managed/external credential mismatches.
 - Pins Host/runtime contracts to DSH rc.6 and includes synchronized JavaScript/declaration artifacts plus the complete native transport modules.
-- Keeps the package name `@pure01fx/dsh-openai-codex-auth`; a rename is intentionally deferred.
+- Keeps the package name `@pure01fx/dsh-openai-codex-auth`; a rename is intentionally deferred.

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.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` 仅作兼容性说明，不当作宿主硬门禁。
+版本 `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 文件/附件策略仍生效。
 
@@ -356,4 +356,4 @@ node --check client.js
 
 ## License
 
-[MIT](./LICENSE)
+[MIT](./LICENSE)

package/lib/cloud-context.js

@@ -14,16 +14,6 @@ export function chooseCloudModel(params, models) {
 export function visibleCloudImages(messages) {
     const images = [];
     const calls = new Set();
-    const visit = (blocks, depth = 0) => {
-        if (depth > 16)
-            return;
-        for (const block of blocks) {
-            if (block.type === 'image')
-                images.push(block.attachment);
-            else if (block.type === 'tool-result' && !block.isError && calls.has(block.toolCallId))
-                visit(block.content, depth + 1);
-        }
-    };
     for (const message of messages) {
         if (message.role === 'assistant') {
             for (const block of message.content)
@@ -36,10 +26,16 @@ export function visibleCloudImages(messages) {
                 if (block.type === 'image')
                     images.push(block.attachment);
         }
-        else if (message.role === 'user' && message.source.kind === 'tool' && calls.has(message.source.callId)) {
+        else if (message.role === 'tool' && message.source.kind === 'tool') {
+            // Require successful result with matching callId and earlier matching call
+            if (message.isError || message.toolCallId !== message.source.callId)
+                continue;
+            if (!calls.has(message.source.callId))
+                continue;
+            // Tool messages with images in their content
             for (const block of message.content)
-                if (block.type === 'tool-result' && block.toolCallId === message.source.callId && !block.isError)
-                    visit(block.content);
+                if (block.type === 'image')
+                    images.push(block.attachment);
         }
     }
     return images;

package/lib/cloud-media.d.ts

@@ -24,7 +24,7 @@ export interface ResolvedCloudImage {
 export declare function resolveImageSources(value: ImageSelection, deps: MediaSourceDependencies): Promise<ResolvedCloudImage[]>;
 export interface MediaOutputDependencies {
     fs: Pick<FileSystem, 'resolve' | 'processPath' | 'contains'>;
-    shell: Pick<ShellExecutor, 'resolve' | 'run' | 'sandboxMode'>;
+    shell: Pick<ShellExecutor, 'resolve' | 'execute' | 'sandboxMode'>;
     /** Resolve from the calling session with the public sandboxPolicy service. */
     policy: SandboxExecutionPolicy;
     attachments: Pick<AttachmentStore, 'validateImage' | 'saveImage'>;

package/lib/cloud-media.js

@@ -92,11 +92,12 @@ export async function saveImageOutputs(response, deps) {
         if (!deps.fs.contains(workspace, target))
             throw new Error('Original image target escapes caller workspace');
         const path = deps.fs.processPath(target);
-        const outcome = await deps.shell.run(deps.shell.resolve({
+        const execution = await deps.shell.execute(deps.shell.resolve({
             command: 'node -e ' + quote(WRITE_ORIGINAL) + ' -- ' + quote(path),
             stdin: Buffer.from(image.data).toString('base64'), workdir: deps.fs.processPath(workspace),
             sandboxPolicy: deps.policy, signal: deps.signal, timeoutMs: 30_000, stdoutMaxBytes: 1024,
         }));
+        const outcome = await execution.result();
         if (outcome.sandbox?.denied || outcome.sandbox?.runnerFailed || outcome.exitCode !== 0 || outcome.aborted || outcome.timedOut)
             throw new Error('Original image write failed under caller filesystem policy');
         const attachment = await deps.attachments.saveImage({ data: image.data, mediaType: image.mediaType, name });

package/lib/cloud-web-tool.js

@@ -124,12 +124,11 @@ function checkReferences(args, messages, id, recent) {
             for (const block of message.content)
                 if (block.type === 'tool-call')
                     calls.set(block.id, block.name);
-        if (message.source.kind !== 'tool' || !['codex_web', 'run_code'].includes(calls.get(message.source.callId) ?? ''))
+        if (message.role !== 'tool' || message.isError || message.source.kind !== 'tool'
+            || message.toolCallId !== message.source.callId
+            || !['codex_web', 'run_code'].includes(calls.get(message.toolCallId) ?? ''))
             continue;
-        for (const block of message.content)
-            if (block.type === 'tool-result' && block.toolCallId === message.source.callId && !block.isError) {
-                outputs.push(block.content.filter(part => part.type === 'text').map(part => part.text).join('\n'));
-            }
+        outputs.push(message.content.filter(block => block.type === 'text').map(block => block.text).join('\n'));
     }
     outputs.push(...recent);
     for (const ref of refs) {

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;
@@ -122,28 +105,29 @@ async function resolveImage(block, options, signal) {
         ...stored.detail === undefined ? {} : { detail: stored.detail },
     };
 }
-async function resolveToolResult(block, options, signal) {
-    const content = [];
-    for (const part of block.content) {
-        throwIfAborted(signal);
-        if (part.type === 'text')
-            content.push(part);
-        else if (part.type === 'image')
-            content.push(await resolveImage(part, options, signal));
-        else {
-            throw fixedFailure('native Codex tool output contains an unsupported content block', 'UNSUPPORTED');
-        }
-    }
-    return {
-        type: 'tool-result',
-        toolCallId: block.toolCallId,
-        content,
-        ...block.isError === undefined ? {} : { isError: block.isError },
-    };
-}
 async function resolveMessages(generation, options) {
     const messages = [];
     for (const message of generation.messages) {
+        if (message.role === 'tool') {
+            const content = [];
+            for (const block of message.content) {
+                throwIfAborted(generation.signal);
+                if (block.type === 'text')
+                    content.push(block);
+                else if (block.type === 'image')
+                    content.push(await resolveImage(block, options, generation.signal));
+                else {
+                    throw fixedFailure('native Codex tool output contains an unsupported content block', 'UNSUPPORTED');
+                }
+            }
+            messages.push({
+                role: 'tool',
+                content,
+                toolCallId: message.toolCallId,
+                ...message.isError !== undefined ? { isError: message.isError } : {},
+            });
+            continue;
+        }
         const content = [];
         const source = message.source;
         const sourceKind = source?.kind;
@@ -177,12 +161,6 @@ async function resolveMessages(generation, options) {
                     // A settlement copies the child's assistant output into user-role context.
                     // Its tool calls belong to the child and must not become parent wire calls.
                     break;
-                case 'tool-result':
-                    if (message.role !== 'user') {
-                        throw fixedFailure('native Codex tool results require user messages', 'INVALID_ARGS');
-                    }
-                    content.push(await resolveToolResult(block, options, generation.signal));
-                    break;
                 default:
                     throw fixedFailure('native Codex request contains an unsupported content block', 'UNSUPPORTED');
             }
@@ -191,6 +169,7 @@ async function resolveMessages(generation, options) {
             && source.replayState !== undefined && hasNativeCodexReplayKind(source.replayState)
             ? { provider: source.provider, model: source.model, replayState: source.replayState }
             : undefined;
+        // Developer messages are preserved for the Responses API
         messages.push({
             role: message.role,
             content,
@@ -256,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,
@@ -277,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 });
@@ -335,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 }),
@@ -366,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 = {}) {
@@ -531,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);
@@ -546,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);