@pure01fx/dsh-openai-codex-auth 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.7.1
+
+### Native stream compatibility
+
+- Aligns long native Codex streams with codex-rs by removing aggregate event/wire-byte, output-item, and replay-item ceilings, using a 300-second WebSocket idle timeout, and retaining 64 MiB single-event/frame, queued-byte, translated-content, retained-output, and replay-state safeguards.
+
 ## 0.7.0
 
 ### DSH 0.1.1 compatibility

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_OUTPUT_ITEMS = 2048;
 const MAX_RESPONSE_ID_BYTES = 256;
 const IGNORED_REUSE_FIELDS = new Set([
     'input', 'previous_response_id', 'generate', 'client_metadata',
@@ -90,10 +89,6 @@ export class NativeCodexWebSocketSessionState {
             this.reset();
             throw failure('native Codex WebSocket completion identity is invalid');
         }
-        if (outputItems.length > MAX_OUTPUT_ITEMS) {
-            this.reset();
-            throw failure('native Codex WebSocket response has too many items');
-        }
         this.completed = {
             propertyHash: this.pending.propertyHash,
             contextLength: this.pending.inputLength + outputItems.length,

package/lib/native-websocket-socket.js

@@ -4,9 +4,8 @@ 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 = 1024 * 1024;
-const MAX_QUEUED_FRAMES = 4096;
-const MAX_QUEUED_BYTES = 24 * 1024 * 1024;
+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 });
 }
@@ -83,7 +82,7 @@ class NodeNativeCodexWebSocket {
                 waiter.resolve(value);
             return;
         }
-        if (this.queue.length >= MAX_QUEUED_FRAMES || this.queuedBytes + bytes > MAX_QUEUED_BYTES) {
+        if (this.queuedBytes + bytes > MAX_QUEUED_BYTES) {
             this.fail(failure('native Codex WebSocket queued too much response data', 'WS_RESPONSE_TOO_LARGE'));
             return;
         }

package/lib/native-websocket.js

@@ -11,8 +11,8 @@ import { ResponsesStreamTranslator, codexResponseTurnState, } from './responses.
 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 = 30_000;
-const DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
+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,9 +21,7 @@ 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_EVENTS_PER_RESPONSE = 4096;
-const MAX_OUTPUT_ITEMS_PER_RESPONSE = 2048;
-const MAX_RESPONSE_BYTES = 24 * 1024 * 1024;
+const MAX_RETAINED_OUTPUT_BYTES = 64 * 1024 * 1024;
 function failure(message, code, cause) {
     return new LlmError(message, code, cause === undefined ? undefined : { cause });
 }
@@ -221,7 +219,7 @@ 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, MAX_RESPONSE_BYTES, 'WebSocket frame limit');
+        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);
@@ -385,14 +383,9 @@ export class NativeCodexWebSocketTransport {
             model: mode.publicModel ?? generation.model,
         });
         const outputItems = [];
-        let events = 0;
-        let responseBytes = 0;
-        while (events++ < MAX_EVENTS_PER_RESPONSE) {
+        let outputBytes = 0;
+        while (true) {
             const text = await this.receive(entry, signal);
-            responseBytes += Buffer.byteLength(text);
-            if (responseBytes > MAX_RESPONSE_BYTES) {
-                throw failure('native Codex WebSocket response exceeded the size limit', 'WS_RESPONSE_TOO_LARGE');
-            }
             let event;
             try {
                 event = JSON.parse(text);
@@ -421,10 +414,12 @@ export class NativeCodexWebSocketTransport {
             }
             const output = normalizedOutputItem(event);
             if (output !== undefined) {
-                if (outputItems.length >= MAX_OUTPUT_ITEMS_PER_RESPONSE) {
-                    throw failure('native Codex WebSocket response had too many output items', 'WS_RESPONSE_TOO_LARGE');
+                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');
                 }
                 outputItems.push(output);
+                outputBytes = nextOutputBytes;
             }
             if (event.type === 'response.completed') {
                 const response = typeof event.response === 'object'
@@ -444,7 +439,6 @@ export class NativeCodexWebSocketTransport {
                 return;
             }
         }
-        throw failure('native Codex WebSocket response had too many events', 'WS_PROTOCOL_ERROR');
     }
     async *attempt(entry, prepared, credential, signal) {
         await this.ensureSocket(entry, prepared, credential, signal);

package/lib/replay.d.ts

@@ -32,12 +32,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 bounded accumulator; no ciphertext can grow unchecked before completion. */
+/** Attempt-local byte-bounded accumulator; no ciphertext can grow unchecked before completion. */
 export declare class NativeCodexReplayCapture {
     private readonly provider;
     private readonly model;
     private readonly descriptors;
-    private references;
     private stateBytes;
     constructor(provider: string, model: string);
     add(item: NativeCodexReplayDescriptor): void;

package/lib/replay.js

@@ -2,11 +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;
-const MAX_REPLAY_DESCRIPTORS = 128;
-const MAX_REPLAY_BLOCK_REFS = 256;
 const MAX_REPLAY_ITEM_ID_BYTES = 256;
-const MAX_REPLAY_CIPHERTEXT_BYTES = 1024 * 1024;
-const MAX_REPLAY_STATE_BYTES = 4 * 1024 * 1024;
+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);
 }
@@ -105,8 +103,9 @@ export function hasNativeCodexReplayKind(value) {
     return object(replayPayload(value))?.kind === NATIVE_CODEX_REPLAY_KIND;
 }
 function parseState(value) {
-    safeStateSize(value, 'INVALID_REPLAY_STATE');
-    const row = object(replayPayload(value));
+    const payload = replayPayload(value);
+    safeStateSize(payload, 'INVALID_REPLAY_STATE');
+    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'])) {
@@ -115,13 +114,10 @@ function parseState(value) {
     const provider = boundedString(row.provider);
     const model = boundedString(row.model, 512);
     if (provider === undefined || model === undefined || !Array.isArray(row.items)
-        || row.items.length === 0 || row.items.length > MAX_REPLAY_DESCRIPTORS) {
+        || row.items.length === 0) {
         throw failure('native Codex replay state metadata is invalid');
     }
     const items = row.items.map(parseDescriptor);
-    const refs = items.reduce((total, item) => total + (item.type === 'function_call' ? 1 : item.blocks.length), 0);
-    if (refs > MAX_REPLAY_BLOCK_REFS)
-        throw failure('native Codex replay state has too many block references');
     return {
         kind: NATIVE_CODEX_REPLAY_KIND,
         version: NATIVE_CODEX_REPLAY_VERSION,
@@ -130,12 +126,11 @@ function parseState(value) {
         items,
     };
 }
-/** Attempt-local bounded accumulator; no ciphertext can grow unchecked before completion. */
+/** Attempt-local byte-bounded accumulator; no ciphertext can grow unchecked before completion. */
 export class NativeCodexReplayCapture {
     provider;
     model;
     descriptors = [];
-    references = 0;
     stateBytes;
     constructor(provider, model) {
         this.provider = provider;
@@ -149,13 +144,6 @@ export class NativeCodexReplayCapture {
         }));
     }
     add(item) {
-        if (this.descriptors.length >= MAX_REPLAY_DESCRIPTORS) {
-            throw failure('native Codex response has too many replay descriptors', 'MALFORMED_RESPONSE');
-        }
-        const addedReferences = item.type === 'function_call' ? 1 : item.blocks.length;
-        if (this.references + addedReferences > MAX_REPLAY_BLOCK_REFS) {
-            throw failure('native Codex response has too many replay block references', 'MALFORMED_RESPONSE');
-        }
         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');
@@ -166,7 +154,6 @@ export class NativeCodexReplayCapture {
             throw failure('native Codex replay state exceeded the size limit', 'REPLAY_STATE_TOO_LARGE');
         }
         this.descriptors.push(item);
-        this.references += addedReferences;
         this.stateBytes = nextBytes;
     }
     finish() {

package/lib/responses.d.ts

@@ -100,9 +100,13 @@ 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;
     private close;
     private closeItem;
@@ -114,8 +118,6 @@ export interface StreamResponsesOptions extends ParseSseOptions {
     onMalformedEvent?: () => void;
     onEvent?: (event: ResponsesStreamEvent) => void;
     replayContext?: ResponsesReplayContext;
-    maxResponseBytes?: number;
-    maxResponseEvents?: number;
 }
 /** Validate one opaque sticky turn token before retaining or forwarding it. */
 export declare function boundedCodexTurnState(value: unknown): string | undefined;

package/lib/responses.js

@@ -6,6 +6,7 @@ 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;
 function fixedError(message, code) { return new LlmError(message, code); }
 function imageItem(image) {
     if (!/^image[/][a-z0-9.+-]+$/i.test(image.mediaType) || image.dataBase64.length === 0) {
@@ -242,6 +243,7 @@ export class ResponsesStreamTranslator {
     order = [];
     replayCapture;
     nextIndex = 0;
+    retainedBytes = 0;
     sawToolCall = false;
     terminated = false;
     constructor(replayContext) {
@@ -250,7 +252,26 @@ 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 },
@@ -308,7 +329,7 @@ export class ResponsesStreamTranslator {
                 const key = `${eventItemId(event)}:text:${String(event.content_index ?? 0)}`;
                 const block = this.blocks.get(key) ?? this.open(key, 'text', chunks);
                 const delta = eventDelta(event);
-                block.text += delta;
+                this.append(block, delta);
                 chunks.push({ type: 'text-delta', index: block.index, text: delta });
                 return chunks;
             }
@@ -316,7 +337,7 @@ export class ResponsesStreamTranslator {
                 const key = `${eventItemId(event)}:summary:${String(event.summary_index ?? 0)}`;
                 const block = this.blocks.get(key) ?? this.open(key, 'reasoning', chunks);
                 const delta = eventDelta(event);
-                block.text += delta;
+                this.append(block, delta);
                 chunks.push({ type: 'reasoning-delta', index: block.index, text: delta });
                 return chunks;
             }
@@ -329,7 +350,7 @@ export class ResponsesStreamTranslator {
                     throw fixedError('native Codex function arguments have no open call', 'MALFORMED_RESPONSE');
                 }
                 const delta = eventDelta(event);
-                block.text += delta;
+                this.append(block, delta);
                 chunks.push({
                     type: 'tool-call-delta', index: block.index, id: CallId(block.callId),
                     ...block.name === undefined ? {} : { name: block.name }, argumentsDelta: delta,
@@ -360,8 +381,7 @@ export class ResponsesStreamTranslator {
                     }
                     block.callId = item.call_id;
                     block.name = item.name;
-                    if (block.text.length === 0)
-                        block.text = item.arguments;
+                    this.fill(block, item.arguments);
                     this.close(key, chunks);
                     if (this.replayContext !== undefined)
                         this.replayCapture?.add({
@@ -385,8 +405,7 @@ export class ResponsesStreamTranslator {
                         if (block.text.length > 0 && block.text !== part.text) {
                             throw fixedError('native Codex text changed during streaming', 'MALFORMED_RESPONSE');
                         }
-                        if (block.text.length === 0)
-                            block.text = part.text;
+                        this.fill(block, part.text);
                         refs.push(block.index);
                         this.close(key, chunks);
                     }
@@ -417,8 +436,7 @@ export class ResponsesStreamTranslator {
                         if (block.text.length > 0 && block.text !== text) {
                             throw fixedError('native Codex reasoning summary changed during streaming', 'MALFORMED_RESPONSE');
                         }
-                        if (block.text.length === 0)
-                            block.text = text;
+                        this.fill(block, text);
                         refs.push(block.index);
                         this.close(key, chunks);
                     }
@@ -528,29 +546,8 @@ export function codexResponseTurnState(event) {
 }
 /** Consume framed SSE JSON into DSH chunks. */
 export async function* streamResponses(stream, options = {}) {
-    const byteLimit = options.maxResponseBytes ?? 24 * 1024 * 1024;
-    const eventLimit = options.maxResponseEvents ?? 4096;
-    if (!Number.isSafeInteger(byteLimit) || byteLimit <= 0 || byteLimit > 24 * 1024 * 1024
-        || !Number.isSafeInteger(eventLimit) || eventLimit <= 0 || eventLimit > 4096) {
-        throw fixedError('native Codex response limit is invalid', 'INVALID_CONFIG');
-    }
-    let responseBytes = 0;
-    let responseEvents = 0;
     const translator = new ResponsesStreamTranslator(options.replayContext);
-    for await (const frame of parseSse(stream, {
-        ...options,
-        onBytes: (bytes) => {
-            options.onBytes?.(bytes);
-            responseBytes += bytes;
-            if (responseBytes > byteLimit) {
-                throw fixedError('native Codex response exceeded the size limit', 'RESPONSE_TOO_LARGE');
-            }
-        },
-    })) {
-        responseEvents += 1;
-        if (responseEvents > eventLimit) {
-            throw fixedError('native Codex response had too many events', 'RESPONSE_TOO_LARGE');
-        }
+    for await (const frame of parseSse(stream, options)) {
         let event;
         try {
             event = JSON.parse(frame.data);

package/lib/sse.js

@@ -1,6 +1,6 @@
 /** Bounded, cancellable Server-Sent Events byte framing. */
 import { LlmError } from '@deepseek-ai/dsh-llm';
-export const DEFAULT_MAX_SSE_EVENT_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_SSE_EVENT_BYTES = 64 * 1024 * 1024;
 function aborted() {
     return new LlmError('native Codex SSE stream was cancelled', 'ABORTED');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Native ChatGPT Codex provider, device-code-first login, and same-origin Web integration for DeepSeek Harness",
   "license": "MIT",
   "publishConfig": {
@@ -69,6 +69,11 @@
     "CHANGELOG.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "prepack": "pnpm build"
+  },
   "dsh": {
     "engines": {
       "dsh": "0.1.1-rc.2"
@@ -107,9 +112,5 @@
     "@types/node": "^22.20.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.8"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run"
   }
-}
+}