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

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';
@@ -12,7 +13,6 @@ import { NodeNativeCodexWebSocketFactory, } from './native-websocket-socket.js';
 import { NativeCodexWebSocketSessionState } from './native-websocket-session.js';
 const WS_BETA = 'responses_websockets=2026-02-06';
 const DEFAULT_IDLE_TIMEOUT_MS = 300_000;
-const DEFAULT_MAX_FRAME_BYTES = 64 * 1024 * 1024;
 const DEFAULT_MAX_SESSIONS = 32;
 const DEFAULT_SESSION_IDLE_MS = 30 * 60_000;
 const DEFAULT_MAX_RECONNECTS = 5;
@@ -21,14 +21,13 @@ const DEFAULT_MAX_RETRY_DELAY_MS = 10_000;
 const INITIAL_CONNECTION_RETRY_DELAY_MS = 5_000;
 const MAX_CONNECTION_RETRY_DELAY_MS = 60_000;
 const MAX_TURN_STATE_BYTES = 4096;
-const MAX_RETAINED_OUTPUT_BYTES = 64 * 1024 * 1024;
 function failure(message, code, cause) {
     return new LlmError(message, code, cause === undefined ? undefined : { cause });
 }
 function reconnectable(code) {
     return [
         'WS_RETRYABLE', 'WS_RETRYABLE_RESET', 'WS_PROTOCOL_ERROR',
-        'WS_FRAME_TOO_LARGE', 'WS_RESPONSE_TOO_LARGE', 'TIMEOUT',
+        'TIMEOUT',
         NATIVE_CODEX_CONNECTION_FAILED_CODE,
     ].includes(code);
 }
@@ -211,7 +210,6 @@ export class NativeCodexWebSocketTransport {
     sessions = new Map();
     connectTimeoutMs;
     idleTimeoutMs;
-    maxFrameBytes;
     maxSessions;
     sessionIdleMs;
     maxReconnects;
@@ -226,7 +224,6 @@ export class NativeCodexWebSocketTransport {
         this.factory = options.webSocketFactory ?? new NodeNativeCodexWebSocketFactory();
         this.connectTimeoutMs = boundedPositive(options.webSocketConnectTimeoutMs, 10_000, 120_000, 'WebSocket connect timeout');
         this.idleTimeoutMs = boundedPositive(options.webSocketIdleTimeoutMs, DEFAULT_IDLE_TIMEOUT_MS, 60 * 60_000, 'WebSocket idle timeout');
-        this.maxFrameBytes = boundedPositive(options.maxWebSocketFrameBytes, DEFAULT_MAX_FRAME_BYTES, DEFAULT_MAX_FRAME_BYTES, 'WebSocket frame limit');
         this.maxSessions = boundedPositive(options.maxWebSocketSessions, DEFAULT_MAX_SESSIONS, 256, 'WebSocket session limit');
         this.sessionIdleMs = boundedPositive(options.webSocketSessionIdleMs, DEFAULT_SESSION_IDLE_MS, 24 * 60 * 60_000, 'WebSocket session idle limit');
         this.maxReconnects = retryCount(options.maxWebSocketReconnects);
@@ -242,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);
     }
@@ -328,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;
@@ -338,12 +337,12 @@ export class NativeCodexWebSocketTransport {
             headers: this.headers(prepared, credential),
             signal,
             connectTimeoutMs: this.connectTimeoutMs,
-            maxFrameBytes: this.maxFrameBytes,
         });
         if (this.disposed) {
             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);
@@ -377,22 +376,21 @@ 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);
-        if (Buffer.byteLength(encoded) > 24 * 1024 * 1024) {
-            throw failure('native Codex WebSocket request exceeded the size limit', 'REQUEST_TOO_LARGE');
-        }
         await entry.socket.send(encoded, signal);
+        telemetry.state('waiting');
         const translator = new ResponsesStreamTranslator(prewarm ? undefined : {
             provider: generation.provider,
             model: mode.publicModel ?? generation.model,
         });
         const outputItems = [];
-        let outputBytes = 0;
         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);
@@ -420,14 +418,8 @@ export class NativeCodexWebSocketTransport {
                     entry.turnState = nextTurnState;
             }
             const output = normalizedOutputItem(event);
-            if (output !== undefined) {
-                const nextOutputBytes = outputBytes + Buffer.byteLength(JSON.stringify(output));
-                if (nextOutputBytes > MAX_RETAINED_OUTPUT_BYTES) {
-                    throw failure('native Codex WebSocket retained output exceeded the size limit', 'WS_RESPONSE_TOO_LARGE');
-                }
+            if (output !== undefined)
                 outputItems.push(output);
-                outputBytes = nextOutputBytes;
-            }
             if (event.type === 'response.completed') {
                 const response = typeof event.response === 'object'
                     && event.response !== null
@@ -447,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();
@@ -515,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;
             }
@@ -524,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)
@@ -532,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;
@@ -558,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;
                     }
@@ -570,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) {
@@ -581,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;
                             }
@@ -592,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/lib/replay.d.ts

@@ -1,4 +1,4 @@
-/** Bounded, versioned Codex Responses continuation state. */
+/** Versioned Codex Responses continuation state. */
 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;
@@ -33,12 +33,11 @@ export interface NativeCodexReplaySource {
 export declare function replayableItemId(value: string | undefined): string | undefined;
 /** True only for legacy raw state or an rc.2 envelope emitted by this package. */
 export declare function hasNativeCodexReplayKind(value: unknown): boolean;
-/** Attempt-local byte-bounded accumulator; no ciphertext can grow unchecked before completion. */
+/** Attempt-local accumulator for completed replay descriptors. */
 export declare class NativeCodexReplayCapture {
     private readonly provider;
     private readonly model;
     private readonly descriptors;
-    private stateBytes;
     constructor(provider: string, model: string);
     add(item: NativeCodexReplayDescriptor): void;
     finish(): NativeCodexReplayState | undefined;

package/lib/replay.js

@@ -1,10 +1,7 @@
-/** Bounded, versioned Codex Responses continuation state. */
+/** Versioned Codex Responses continuation state. */
 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;
-const MAX_REPLAY_ITEM_ID_BYTES = 256;
-const MAX_REPLAY_CIPHERTEXT_BYTES = 64 * 1024 * 1024;
-const MAX_REPLAY_STATE_BYTES = 64 * 1024 * 1024;
 function failure(message, code = 'INVALID_REPLAY_STATE') {
     return new LlmError(message, code);
 }
@@ -17,30 +14,22 @@ function onlyKeys(row, keys) {
     const allowed = new Set(keys);
     return Object.keys(row).every(key => allowed.has(key));
 }
-function boundedString(value, maximum = 256) {
-    return typeof value === 'string' && value.length > 0
-        && Buffer.byteLength(value) <= maximum ? value : undefined;
+function nonemptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
 /** Preserve only server item IDs that Codex itself would replay. */
 export function replayableItemId(value) {
     if (value === undefined)
         return undefined;
-    if (Buffer.byteLength(value) > MAX_REPLAY_ITEM_ID_BYTES) {
-        throw failure('native Codex response item identity exceeded the replay limit', 'MALFORMED_RESPONSE');
-    }
     const split = value.indexOf('_');
     return split > 0 && split < value.length - 1 ? value : undefined;
 }
-function safeStateSize(value, code) {
-    let serialized;
+function validateStateJson(value) {
     try {
-        serialized = JSON.stringify(value);
+        JSON.stringify(value);
     }
     catch {
-        throw failure('native Codex replay state is not lossless JSON', code);
-    }
-    if (Buffer.byteLength(serialized) > MAX_REPLAY_STATE_BYTES) {
-        throw failure('native Codex replay state exceeded the size limit', code);
+        throw failure('native Codex replay state is not lossless JSON');
     }
 }
 function validateBlockArray(value) {
@@ -59,7 +48,7 @@ function parseDescriptor(value) {
     if (row === undefined || typeof row.type !== 'string') {
         throw failure('native Codex replay descriptor is invalid');
     }
-    const id = row.id === undefined ? undefined : boundedString(row.id, MAX_REPLAY_ITEM_ID_BYTES);
+    const id = row.id === undefined ? undefined : nonemptyString(row.id);
     const split = id?.indexOf('_') ?? -1;
     if (row.id !== undefined && (id === undefined || split <= 0 || split >= id.length - 1)) {
         throw failure('native Codex replay item identity is invalid');
@@ -74,7 +63,7 @@ function parseDescriptor(value) {
     if (row.type === 'reasoning') {
         const blocks = validateBlockArray(row.blocks);
         const encryptedContent = row.encryptedContent === undefined
-            ? undefined : boundedString(row.encryptedContent, MAX_REPLAY_CIPHERTEXT_BYTES);
+            ? undefined : nonemptyString(row.encryptedContent);
         if (blocks === undefined
             || (row.encryptedContent !== undefined && encryptedContent === undefined)
             || !onlyKeys(row, ['type', 'id', 'blocks', 'encryptedContent'])) {
@@ -86,7 +75,7 @@ function parseDescriptor(value) {
         };
     }
     if (row.type === 'function_call') {
-        const namespace = row.namespace === undefined ? undefined : boundedString(row.namespace);
+        const namespace = row.namespace === undefined ? undefined : nonemptyString(row.namespace);
         if (!Number.isSafeInteger(row.block) || Number(row.block) < 0
             || (row.namespace !== undefined && namespace === undefined)
             || !onlyKeys(row, ['type', 'id', 'namespace', 'block'])) {
@@ -109,15 +98,15 @@ export function hasNativeCodexReplayKind(value) {
 }
 function parseState(value) {
     const payload = replayPayload(value);
-    safeStateSize(payload, 'INVALID_REPLAY_STATE');
+    validateStateJson(payload);
     const row = object(payload);
     if (row === undefined || row.kind !== NATIVE_CODEX_REPLAY_KIND
         || row.version !== NATIVE_CODEX_REPLAY_VERSION
         || !onlyKeys(row, ['kind', 'version', 'provider', 'model', 'items'])) {
         throw failure('native Codex replay state kind or version is invalid');
     }
-    const provider = boundedString(row.provider);
-    const model = boundedString(row.model, 512);
+    const provider = nonemptyString(row.provider);
+    const model = nonemptyString(row.model);
     if (provider === undefined || model === undefined || !Array.isArray(row.items)
         || row.items.length === 0) {
         throw failure('native Codex replay state metadata is invalid');
@@ -131,35 +120,17 @@ function parseState(value) {
         items,
     };
 }
-/** Attempt-local byte-bounded accumulator; no ciphertext can grow unchecked before completion. */
+/** Attempt-local accumulator for completed replay descriptors. */
 export class NativeCodexReplayCapture {
     provider;
     model;
     descriptors = [];
-    stateBytes;
     constructor(provider, model) {
         this.provider = provider;
         this.model = model;
-        this.stateBytes = Buffer.byteLength(JSON.stringify({
-            kind: NATIVE_CODEX_REPLAY_KIND,
-            version: NATIVE_CODEX_REPLAY_VERSION,
-            provider,
-            model,
-            items: [],
-        }));
     }
     add(item) {
-        if (item.type === 'reasoning' && item.encryptedContent !== undefined
-            && Buffer.byteLength(item.encryptedContent) > MAX_REPLAY_CIPHERTEXT_BYTES) {
-            throw failure('native Codex encrypted reasoning exceeded the replay limit', 'MALFORMED_RESPONSE');
-        }
-        const itemBytes = Buffer.byteLength(JSON.stringify(item));
-        const nextBytes = this.stateBytes + itemBytes + (this.descriptors.length === 0 ? 0 : 1);
-        if (nextBytes > MAX_REPLAY_STATE_BYTES) {
-            throw failure('native Codex replay state exceeded the size limit', 'REPLAY_STATE_TOO_LARGE');
-        }
         this.descriptors.push(item);
-        this.stateBytes = nextBytes;
     }
     finish() {
         return createNativeCodexReplayState(this.provider, this.model, this.descriptors);
@@ -176,7 +147,6 @@ export function createNativeCodexReplayState(provider, model, items) {
         model,
         items: items.map(item => ({ ...item })),
     };
-    safeStateSize(state, 'REPLAY_STATE_TOO_LARGE');
     try {
         return parseState(state);
     }

package/lib/responses.d.ts

@@ -109,11 +109,9 @@ export declare class ResponsesStreamTranslator {
     private readonly order;
     private readonly replayCapture;
     private nextIndex;
-    private retainedBytes;
     private sawToolCall;
     terminated: boolean;
     constructor(replayContext?: ResponsesReplayContext | undefined);
-    private reserve;
     private append;
     private fill;
     private open;

package/lib/responses.js

@@ -6,7 +6,6 @@ import { NativeCodexReplayCapture, replayAssistantInput, replayableItemId, } fro
 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_';
-const MAX_RETAINED_RESPONSE_BYTES = 64 * 1024 * 1024;
 const UUID_NAMESPACE_OID = Buffer.from('6ba7b8129dad11d180b400c04fd430c8', 'hex');
 function uuidV5(namespace, name) {
     const bytes = createHash('sha1').update(namespace).update(name).digest().subarray(0, 16);
@@ -321,7 +320,6 @@ export class ResponsesStreamTranslator {
     order = [];
     replayCapture;
     nextIndex = 0;
-    retainedBytes = 0;
     sawToolCall = false;
     terminated = false;
     constructor(replayContext) {
@@ -330,26 +328,15 @@ export class ResponsesStreamTranslator {
             ? undefined
             : new NativeCodexReplayCapture(replayContext.provider, replayContext.model);
     }
-    reserve(bytes) {
-        const nextBytes = this.retainedBytes + bytes;
-        if (!Number.isSafeInteger(nextBytes) || nextBytes > MAX_RETAINED_RESPONSE_BYTES) {
-            throw fixedError('native Codex response retained content exceeded the size limit', 'RESPONSE_TOO_LARGE');
-        }
-        this.retainedBytes = nextBytes;
-    }
     append(block, delta) {
-        this.reserve(Buffer.byteLength(delta));
         block.text += delta;
     }
     fill(block, text) {
         if (block.text.length > 0)
             return;
-        this.reserve(Buffer.byteLength(text));
         block.text = text;
     }
     open(key, kind, chunks, callId = '', name) {
-        this.reserve(128 + Buffer.byteLength(key) + Buffer.byteLength(callId)
-            + (name === undefined ? 0 : Buffer.byteLength(name)));
         const block = {
             index: this.nextIndex++, kind, text: '', callId,
             ...name === undefined ? {} : { name },
@@ -445,7 +432,7 @@ export class ResponsesStreamTranslator {
                     if (item.call_id === undefined || item.call_id.length === 0
                         || item.name === undefined || item.name.length === 0
                         || (item.namespace !== undefined && (typeof item.namespace !== 'string'
-                            || item.namespace.length === 0 || Buffer.byteLength(item.namespace) > 256))
+                            || item.namespace.length === 0))
                         || typeof item.arguments !== 'string') {
                         throw fixedError('native Codex function call has invalid content', 'MALFORMED_RESPONSE');
                     }

package/lib/sse.d.ts

@@ -1,4 +1,3 @@
-export declare const DEFAULT_MAX_SSE_EVENT_BYTES: number;
 export interface SseEvent {
     data: string;
     event?: string;
@@ -7,7 +6,6 @@ export interface ParseSseOptions {
     signal?: AbortSignal;
     onActivity?: () => void;
     onBytes?: (bytes: number) => void;
-    maxEventBytes?: number;
 }
-/** Decode a byte stream into bounded SSE frames. */
+/** Decode a byte stream into SSE frames. */
 export declare function parseSse(stream: ReadableStream<Uint8Array>, options?: ParseSseOptions): AsyncGenerator<SseEvent>;