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

package/lib/native-http.d.ts

@@ -20,11 +20,9 @@ export interface NativeCodexHttpOptions {
     endpoint?: string;
     requestTimeoutMs?: number;
     streamIdleTimeoutMs?: number;
-    maxSseEventBytes?: number;
     maxTransientRetries?: number;
     initialRetryDelayMs?: number;
     maxRetryDelayMs?: number;
-    maxRequestBodyBytes?: number;
     random?: () => number;
     sleep?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
     createRequestId?: () => string;
@@ -37,7 +35,6 @@ export interface NativeCodexPreparedRequest {
     generation: GenerateOptions;
     mode: NativeCodexTransportMode;
     request: Record<string, unknown>;
-    body: string;
     routingId: string;
     routingHint: string;
 }
@@ -51,7 +48,6 @@ export declare class NativeCodexHttpTransport {
     private readonly maxRetries;
     private readonly initialDelayMs;
     private readonly maxDelayMs;
-    private readonly maxBodyBytes;
     constructor(options: NativeCodexHttpOptions);
     private retryDelay;
     private wait;

package/lib/native-http.js

@@ -16,7 +16,6 @@ const DEFAULT_INITIAL_RETRY_DELAY_MS = 200;
 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 DEFAULT_MAX_REQUEST_BODY_BYTES = 24 * 1024 * 1024;
 const MAX_ERROR_BODY_BYTES = 64 * 1024;
 function aborted(message = 'native Codex request was aborted') {
     return new LlmError(message, 'ABORTED');
@@ -357,7 +356,6 @@ export class NativeCodexHttpTransport {
     maxRetries;
     initialDelayMs;
     maxDelayMs;
-    maxBodyBytes;
     constructor(options) {
         this.options = options;
         this.fetchImpl = options.fetch ?? fetch;
@@ -367,7 +365,6 @@ export class NativeCodexHttpTransport {
         this.maxRetries = safeRetryCount(options.maxTransientRetries);
         this.initialDelayMs = safePositiveInteger(options.initialRetryDelayMs, DEFAULT_INITIAL_RETRY_DELAY_MS, 'initial retry delay');
         this.maxDelayMs = safePositiveInteger(options.maxRetryDelayMs, DEFAULT_MAX_RETRY_DELAY_MS, 'maximum retry delay');
-        this.maxBodyBytes = safePositiveInteger(options.maxRequestBodyBytes, DEFAULT_MAX_REQUEST_BODY_BYTES, 'request body limit');
     }
     retryDelay(retry, providerDelay) {
         if (providerDelay !== undefined)
@@ -410,24 +407,28 @@ export class NativeCodexHttpTransport {
                 sessionId: stablePromptCacheKey(sessionId),
             };
         let request;
-        let body;
         try {
             request = codexRequestBody(wireOptions, messages, mode);
-            body = JSON.stringify(request);
         }
         catch (error) {
             if (error instanceof LlmError)
                 throw error;
             throw fixedFailure('native Codex request could not be encoded', 'INVALID_ARGS', { cause: error });
         }
-        if (Buffer.byteLength(body) > this.maxBodyBytes) {
-            throw fixedFailure('native Codex request exceeded the size limit', 'REQUEST_TOO_LARGE');
-        }
-        return { generation, mode, request, body, routingId, routingHint };
+        // WebSocket chooses a full request or an incremental suffix after preparation.
+        // Serialize only in the selected transport.
+        return { generation, mode, request, routingId, routingHint };
     }
     async *stream(generation, mode = {}) {
         const prepared = await this.prepare(generation, mode);
-        const { body, routingId, routingHint } = prepared;
+        const { request, routingId, routingHint } = prepared;
+        let body;
+        try {
+            body = JSON.stringify(request);
+        }
+        catch (error) {
+            throw fixedFailure('native Codex request could not be encoded', 'INVALID_ARGS', { cause: error });
+        }
         let activeTurnState = mode.turnState;
         if (activeTurnState !== undefined
             && (activeTurnState.length === 0 || Buffer.byteLength(activeTurnState) > 4096
@@ -553,9 +554,6 @@ export class NativeCodexHttpTransport {
                 for await (const chunk of streamResponses(response.body, {
                     signal: watchdog.signal,
                     onActivity: watchdog.pulse,
-                    ...this.options.maxSseEventBytes === undefined
-                        ? {}
-                        : { maxEventBytes: this.options.maxSseEventBytes },
                     onMalformedEvent: () => {
                         this.options.warn?.('native Codex ignored a malformed SSE event');
                     },

package/lib/native-websocket-session.js

@@ -1,7 +1,6 @@
 /** Pure WebSocket v2 previous-response and incremental suffix state. */
 import { createHash } from 'node:crypto';
 import { LlmError } from '@deepseek-ai/dsh-llm';
-const MAX_RESPONSE_ID_BYTES = 256;
 const IGNORED_REUSE_FIELDS = new Set([
     'input', 'previous_response_id', 'generate', 'client_metadata',
     'stream_options', 'access_programs',
@@ -84,8 +83,7 @@ export class NativeCodexWebSocketSessionState {
         return { ...plan, payload: { ...plan.payload, generate: false } };
     }
     complete(responseId, outputItems) {
-        if (this.pending === undefined || responseId.length === 0
-            || Buffer.byteLength(responseId) > MAX_RESPONSE_ID_BYTES) {
+        if (this.pending === undefined || responseId.length === 0) {
             this.reset();
             throw failure('native Codex WebSocket completion identity is invalid');
         }

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

@@ -17,7 +17,6 @@ export interface NativeCodexWebSocketConnectOptions {
     headers: Record<string, string>;
     signal?: AbortSignal;
     connectTimeoutMs?: number;
-    maxFrameBytes?: number;
 }
 export interface NativeCodexWebSocketFactory {
     connect(options: NativeCodexWebSocketConnectOptions): Promise<NativeCodexWebSocket>;

package/lib/native-websocket-socket.js

@@ -1,4 +1,4 @@
-/** Bounded Node WebSocket client seam with injectable deterministic factories. */
+/** Node WebSocket client seam with injectable deterministic factories. */
 import { LlmError, ProviderRequestId } from '@deepseek-ai/dsh-llm';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 import { getProxyForUrl } from 'proxy-from-env';
@@ -6,8 +6,6 @@ import { nativeCodexEndpoint } from './endpoint.js';
 import { NATIVE_CODEX_CONNECTION_FAILED_CODE, isNativeCodexConnectionFailure, } from './native-adapter.js';
 import WebSocket from 'ws';
 const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
-const DEFAULT_MAX_FRAME_BYTES = 64 * 1024 * 1024;
-const MAX_QUEUED_BYTES = 64 * 1024 * 1024;
 function failure(message, code, cause) {
     return new LlmError(message, code, cause === undefined ? undefined : { cause });
 }
@@ -54,25 +52,20 @@ export function nativeCodexWebSocketUrl(endpoint) {
 class NodeNativeCodexWebSocket {
     socket;
     responseHeaders;
-    maxFrameBytes;
     queue = [];
-    queuedBytes = 0;
     waiters = [];
     ended = false;
-    constructor(socket, responseHeaders, maxFrameBytes) {
+    constructor(socket, responseHeaders) {
         this.socket = socket;
         this.responseHeaders = responseHeaders;
-        this.maxFrameBytes = maxFrameBytes;
         socket.on('message', (data, isBinary) => {
             if (isBinary) {
                 this.fail(failure('native Codex WebSocket returned a binary frame', 'WS_PROTOCOL_ERROR'));
                 return;
             }
-            if (data.byteLength > maxFrameBytes) {
-                this.fail(failure('native Codex WebSocket frame exceeded the size limit', 'WS_FRAME_TOO_LARGE'));
-                return;
-            }
-            this.push({ type: 'text', text: data.toString('utf8') }, data.byteLength);
+            const buffer = Array.isArray(data) ? Buffer.concat(data)
+                : Buffer.isBuffer(data) ? data : Buffer.from(data);
+            this.push({ type: 'text', text: buffer.toString('utf8') });
         });
         socket.on('close', (code, reason) => {
             this.ended = true;
@@ -82,7 +75,7 @@ class NodeNativeCodexWebSocket {
             this.fail(failure('native Codex WebSocket transport failed', 'WS_RETRYABLE', error));
         });
     }
-    push(value, bytes = 0) {
+    push(value) {
         const waiter = this.waiters.shift();
         if (waiter !== undefined) {
             if (value instanceof LlmError)
@@ -91,12 +84,7 @@ class NodeNativeCodexWebSocket {
                 waiter.resolve(value);
             return;
         }
-        if (this.queuedBytes + bytes > MAX_QUEUED_BYTES) {
-            this.fail(failure('native Codex WebSocket queued too much response data', 'WS_RESPONSE_TOO_LARGE'));
-            return;
-        }
-        this.queue.push({ value, bytes });
-        this.queuedBytes += bytes;
+        this.queue.push(value);
     }
     fail(error) {
         if (!this.ended)
@@ -106,9 +94,8 @@ class NodeNativeCodexWebSocket {
         for (const waiter of waiters)
             waiter.reject(error);
         this.queue.length = 0;
-        this.queuedBytes = 0;
         if (waiters.length === 0)
-            this.queue.push({ value: error, bytes: 0 });
+            this.queue.push(error);
     }
     async send(text, signal) {
         if (signal?.aborted)
@@ -124,7 +111,7 @@ class NodeNativeCodexWebSocket {
             signal?.addEventListener('abort', abort, { once: true });
             this.socket.send(text, (error) => {
                 signal?.removeEventListener('abort', abort);
-                if (error === undefined)
+                if (error === undefined || error === null)
                     resolve();
                 else
                     reject(failure('native Codex WebSocket send failed', 'WS_RETRYABLE', error));
@@ -136,10 +123,9 @@ class NodeNativeCodexWebSocket {
             throw abortFailure(signal);
         const queued = this.queue.shift();
         if (queued !== undefined) {
-            this.queuedBytes -= queued.bytes;
-            if (queued.value instanceof LlmError)
-                throw queued.value;
-            return queued.value;
+            if (queued instanceof LlmError)
+                throw queued;
+            return queued;
         }
         return new Promise((resolve, reject) => {
             let waiter;
@@ -169,7 +155,6 @@ class NodeNativeCodexWebSocket {
 export class NodeNativeCodexWebSocketFactory {
     async connect(options) {
         const timeout = positive(options.connectTimeoutMs, DEFAULT_CONNECT_TIMEOUT_MS, 'connect timeout');
-        const maximum = positive(options.maxFrameBytes, DEFAULT_MAX_FRAME_BYTES, 'frame limit');
         if (options.signal?.aborted)
             throw abortFailure(options.signal);
         return new Promise((resolve, reject) => {
@@ -180,7 +165,8 @@ export class NodeNativeCodexWebSocketFactory {
                 headers: options.headers,
                 ...(agent === undefined ? {} : { agent }),
                 handshakeTimeout: timeout,
-                maxPayload: maximum,
+                // ws uses zero to disable its default message-size ceiling.
+                maxPayload: 0,
                 perMessageDeflate: true,
             });
             const abort = () => {
@@ -211,7 +197,7 @@ export class NodeNativeCodexWebSocketFactory {
             });
             socket.on('open', () => {
                 options.signal?.removeEventListener('abort', abort);
-                resolve(new NodeNativeCodexWebSocket(socket, responseHeaders, maximum));
+                resolve(new NodeNativeCodexWebSocket(socket, responseHeaders));
             });
             socket.on('error', (error) => {
                 options.signal?.removeEventListener('abort', abort);

package/lib/native-websocket.d.ts

@@ -6,7 +6,6 @@ export interface NativeCodexWebSocketTransportOptions extends NativeCodexHttpOpt
     webSocketFactory?: NativeCodexWebSocketFactory;
     webSocketConnectTimeoutMs?: number;
     webSocketIdleTimeoutMs?: number;
-    maxWebSocketFrameBytes?: number;
     maxWebSocketSessions?: number;
     webSocketSessionIdleMs?: number;
     maxWebSocketReconnects?: number;
@@ -19,7 +18,6 @@ export declare class NativeCodexWebSocketTransport implements NativeCodexTranspo
     private readonly sessions;
     private readonly connectTimeoutMs;
     private readonly idleTimeoutMs;
-    private readonly maxFrameBytes;
     private readonly maxSessions;
     private readonly sessionIdleMs;
     private readonly maxReconnects;

package/lib/native-websocket.js

@@ -12,7 +12,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 +20,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 +209,6 @@ export class NativeCodexWebSocketTransport {
     sessions = new Map();
     connectTimeoutMs;
     idleTimeoutMs;
-    maxFrameBytes;
     maxSessions;
     sessionIdleMs;
     maxReconnects;
@@ -226,7 +223,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);
@@ -338,7 +334,6 @@ export class NativeCodexWebSocketTransport {
             headers: this.headers(prepared, credential),
             signal,
             connectTimeoutMs: this.connectTimeoutMs,
-            maxFrameBytes: this.maxFrameBytes,
         });
         if (this.disposed) {
             socket.close();
@@ -381,16 +376,12 @@ export class NativeCodexWebSocketTransport {
         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);
         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);
             let event;
@@ -420,14 +411,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

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

@@ -1,4 +1,4 @@
-import { CallId, LlmError, type ContentBlock, type GenerateOptions, type StreamChunk, type TokenUsage, type ToolSchema } from '@deepseek-ai/dsh-llm';
+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';
 export declare const DEFAULT_CODEX_INSTRUCTIONS = "You are Codex, an AI coding agent. Help the user with software engineering tasks.";
@@ -11,7 +11,7 @@ export interface ResolvedImagePart {
 }
 export interface ResolvedToolResultPart {
     type: 'tool-result';
-    toolCallId: CallId;
+    toolCallId: ToolCallId;
     content: readonly ResolvedContentPart[];
     isError?: boolean;
 }
@@ -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

@@ -1,12 +1,11 @@
 /** Pure DSH-to-Codex Responses request and stream translation. */
 import { createHash } from 'node:crypto';
-import { CallId, CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, isContextWindowExceededError, isQuotaExceededError, LlmError, QUOTA_EXCEEDED_CODE, } from '@deepseek-ai/dsh-llm';
+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';
 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);
@@ -312,7 +311,7 @@ function closeBlock(block) {
         return { type: 'text', text: block.text };
     if (block.kind === 'reasoning')
         return { type: 'reasoning', text: block.text };
-    return { type: 'tool-call', id: CallId(block.callId), name: block.name ?? '', arguments: block.text };
+    return { type: 'tool-call', id: ToolCallId(block.callId), name: block.name ?? '', arguments: block.text };
 }
 /** Stateful, transport-free Responses event to DSH chunk translator. */
 export class ResponsesStreamTranslator {
@@ -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 },
@@ -398,7 +385,7 @@ export class ResponsesStreamTranslator {
                 this.sawToolCall = true;
                 const block = this.open(`${item.id}:call`, 'tool-call', chunks, item.call_id, item.name);
                 chunks.push({
-                    type: 'tool-call-delta', index: block.index, id: CallId(block.callId),
+                    type: 'tool-call-delta', index: block.index, id: ToolCallId(block.callId),
                     name: item.name, argumentsDelta: '',
                 });
                 return chunks;
@@ -430,7 +417,7 @@ export class ResponsesStreamTranslator {
                 const delta = eventDelta(event);
                 this.append(block, delta);
                 chunks.push({
-                    type: 'tool-call-delta', index: block.index, id: CallId(block.callId),
+                    type: 'tool-call-delta', index: block.index, id: ToolCallId(block.callId),
                     ...block.name === undefined ? {} : { name: block.name }, argumentsDelta: delta,
                 });
                 return chunks;
@@ -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>;