@pure01fx/dsh-openai-codex-auth 0.7.3 → 0.9.0

package/lib/native-adapter.d.ts

@@ -18,12 +18,19 @@ export declare function nativeCodexWireReasoningEffort(effort: string | undefine
 /** Request-scoped native Codex transport owned by this package. */
 export interface NativeCodexTransportMode {
     serviceTier?: typeof CODEX_FAST_SERVICE_TIER;
+    /** Enables the model-specific Responses Lite request and routing contract. */
+    responsesLite?: {
+        defaultVerbosity?: string;
+        instructionsTemplate?: string;
+    };
     publicModel?: string;
     authorityHash?: string;
     /** Turn-scoped sticky routing state captured from a provider response. */
     turnState?: string;
     /** @internal Receives a newly observed bounded turn-state token. */
     captureTurnState?: (state: string) => void;
+    /** @internal Pins WebSocket reconnects and HTTP fallback to one account. */
+    pinnedAccountId?: string;
 }
 export interface NativeCodexTransport {
     stream(options: GenerateOptions, mode?: NativeCodexTransportMode): AsyncIterable<StreamChunk>;

package/lib/native-adapter.js

@@ -53,6 +53,20 @@ function supportsFast(model) {
     return model.serviceTiers.some(tier => tier.id === CODEX_FAST_SERVICE_TIER)
         || model.additionalSpeedTiers.includes('fast');
 }
+function responsesLiteMode(model, requestedModel = model?.slug) {
+    if (model !== undefined && !model.useResponsesLite)
+        return {};
+    // Never downgrade the tracked Lite-only Astra slug to Standard Responses during catalog outages.
+    if (model === undefined && requestedModel !== 'gpt-6-astra')
+        return {};
+    return {
+        responsesLite: {
+            defaultVerbosity: model?.defaultVerbosity ?? 'low',
+            ...model?.instructionsTemplate === undefined ? {}
+                : { instructionsTemplate: model.instructionsTemplate },
+        },
+    };
+}
 function fastRoutes(models) {
     const exact = new Set(models.map(model => model.slug));
     const routes = new Map();
@@ -81,9 +95,10 @@ export function nativeCodexWireReasoningEffort(effort, model) {
     return [...supported].reverse().find(level => level.effort !== 'ultra')?.effort ?? 'medium';
 }
 function withWireReasoning(options, model) {
-    const selected = options.reasoningEffort === undefined ? undefined : String(options.reasoningEffort);
+    const explicit = options.reasoningEffort === undefined ? undefined : String(options.reasoningEffort);
+    const selected = explicit ?? (model?.useResponsesLite ? model.defaultReasoningLevel : undefined);
     const wire = nativeCodexWireReasoningEffort(selected, model);
-    return wire === undefined || wire === selected
+    return wire === undefined || wire === explicit
         ? options
         : { ...options, reasoningEffort: ReasoningEffortId(wire) };
 }
@@ -217,7 +232,7 @@ export class NativeCodexAdapter extends LlmAdapter {
             this.assertNotAborted(options.signal);
             const exact = view.models.find(candidate => candidate.slug === options.model);
             if (exact !== undefined) {
-                yield* this.transport.stream(withWireReasoning(options, exact));
+                yield* this.transport.stream(withWireReasoning(options, exact), responsesLiteMode(exact));
                 return;
             }
             const fast = fastRoutes(view.models).get(options.model);
@@ -231,16 +246,13 @@ export class NativeCodexAdapter extends LlmAdapter {
                 serviceTier: CODEX_FAST_SERVICE_TIER,
                 publicModel: options.model,
                 authorityHash: view.authorityHash,
+                ...responsesLiteMode(fast),
             });
             return;
         }
-        const selectedEffort = options.reasoningEffort === undefined
-            ? undefined : String(options.reasoningEffort);
-        const model = selectedEffort === 'ultra'
-            ? (await this.catalog?.list(options.signal) ?? [])
-                .find(candidate => candidate.slug === options.model)
-            : undefined;
+        const model = (await this.catalog?.list(options.signal) ?? [])
+            .find(candidate => candidate.slug === options.model);
         this.assertNotAborted(options.signal);
-        yield* this.transport.stream(withWireReasoning(options, model));
+        yield* this.transport.stream(withWireReasoning(options, model), responsesLiteMode(model, options.model));
     }
 }

package/lib/native-http.js

@@ -436,6 +436,7 @@ export class NativeCodexHttpTransport {
         let transientRetries = 0;
         let connectionRetryDelayMs = INITIAL_CONNECTION_RETRY_DELAY_MS;
         let recovered = false;
+        let pinnedAccountId = mode.pinnedAccountId;
         while (true) {
             throwIfAborted(generation.signal);
             const watchdog = attemptWatchdog(generation.signal, this.requestTimeoutMs, this.idleTimeoutMs);
@@ -445,6 +446,11 @@ export class NativeCodexHttpTransport {
             try {
                 credential = await this.options.resolveCredential(watchdog.signal);
                 throwIfAborted(watchdog.signal);
+                if (pinnedAccountId === undefined)
+                    pinnedAccountId = credential.accountId;
+                else if (credential.accountId !== pinnedAccountId) {
+                    throw fixedFailure('native Codex account changed during request', 'AUTH');
+                }
                 if (mode.serviceTier !== undefined
                     && (mode.authorityHash === undefined
                         || nativeCodexAuthorityHash(credential.accountId) !== mode.authorityHash)) {
@@ -464,6 +470,8 @@ export class NativeCodexHttpTransport {
                         'x-codex-routing-hint': routingHint,
                         ...(activeTurnState === undefined ? {} : { 'x-codex-turn-state': activeTurnState }),
                         ...(generation.purpose === 'compaction' ? { 'x-openai-subagent': 'compact' } : {}),
+                        ...(mode.responsesLite === undefined
+                            ? {} : { 'x-openai-internal-codex-responses-lite': 'true' }),
                         accept: 'text/event-stream',
                         'content-type': 'application/json',
                         ...attributionHeaders(),

package/lib/native-websocket.js

@@ -106,8 +106,8 @@ function turnKey(generation) {
     return createHash('sha256')
         .update(`${generation.purpose ?? 'ordinary'}:handbuilt`).digest('base64url');
 }
-function withTurnState(request, turnState) {
-    if (turnState === undefined)
+function withRequestMetadata(request, turnState, responsesLite) {
+    if (turnState === undefined && !responsesLite)
         return request;
     const metadata = typeof request.client_metadata === 'object'
         && request.client_metadata !== null && !Array.isArray(request.client_metadata)
@@ -115,7 +115,12 @@ function withTurnState(request, turnState) {
         : {};
     return {
         ...request,
-        client_metadata: { ...metadata, 'x-codex-turn-state': turnState },
+        client_metadata: {
+            ...metadata,
+            ...(turnState === undefined ? {} : { 'x-codex-turn-state': turnState }),
+            ...(responsesLite
+                ? { ws_request_header_x_openai_internal_codex_responses_lite: 'true' } : {}),
+        },
     };
 }
 function normalizedOutputItem(event) {
@@ -140,6 +145,7 @@ function normalizedOutputItem(event) {
     if (item.type === 'function_call') {
         return {
             type: 'function_call', ...(id === undefined ? {} : { id }),
+            ...(typeof item.namespace === 'string' ? { namespace: item.namespace } : {}),
             call_id: item.call_id, name: item.name, arguments: item.arguments,
         };
     }
@@ -446,12 +452,12 @@ export class NativeCodexWebSocketTransport {
         let justPrewarmed = false;
         if (!entry.prewarmAttempted) {
             entry.prewarmAttempted = true;
-            const warm = entry.protocol.prewarm(withTurnState(prepared.request, entry.turnState));
+            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(withTurnState(prepared.request, entry.turnState), justPrewarmed);
+        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 {
@@ -500,10 +506,12 @@ export class NativeCodexWebSocketTransport {
                 if (entry.turnState === undefined)
                     entry.turnState = state;
             },
+            ...(pinnedAccountId === undefined ? {} : { pinnedAccountId }),
         });
         let reconnects = 0;
         let connectionRetryDelayMs = INITIAL_CONNECTION_RETRY_DELAY_MS;
         let recovered = false;
+        let pinnedAccountId = mode.pinnedAccountId;
         let requestCompleted = false;
         try {
             if (entry.disabled) {
@@ -518,6 +526,11 @@ export class NativeCodexWebSocketTransport {
                 try {
                     const credential = await this.options.resolveCredential(signal);
                     attemptedCredential = credential;
+                    if (pinnedAccountId === undefined)
+                        pinnedAccountId = credential.accountId;
+                    else if (credential.accountId !== pinnedAccountId) {
+                        throw failure('native Codex account changed during request', 'AUTH');
+                    }
                     this.assertFastAuthority(credential, mode);
                     for await (const chunk of this.attempt(entry, prepared, credential, signal)) {
                         emitted = true;

package/lib/replay.d.ts

@@ -14,6 +14,7 @@ export type NativeCodexReplayDescriptor = {
 } | {
     type: 'function_call';
     id?: string;
+    namespace?: string;
     block: number;
 };
 export interface NativeCodexReplayState {

package/lib/replay.js

@@ -86,11 +86,16 @@ function parseDescriptor(value) {
         };
     }
     if (row.type === 'function_call') {
+        const namespace = row.namespace === undefined ? undefined : boundedString(row.namespace);
         if (!Number.isSafeInteger(row.block) || Number(row.block) < 0
-            || !onlyKeys(row, ['type', 'id', 'block'])) {
+            || (row.namespace !== undefined && namespace === undefined)
+            || !onlyKeys(row, ['type', 'id', 'namespace', 'block'])) {
             throw failure('native Codex function replay descriptor is invalid');
         }
-        return { type: 'function_call', ...(id === undefined ? {} : { id }), block: Number(row.block) };
+        return {
+            type: 'function_call', ...(id === undefined ? {} : { id }),
+            ...(namespace === undefined ? {} : { namespace }), block: Number(row.block),
+        };
     }
     throw failure('native Codex replay descriptor type is unsupported');
 }
@@ -220,6 +225,7 @@ export function replayAssistantInput(content, source) {
             const block = blockAt(content, used, item.block, 'tool-call');
             input.push({
                 type: 'function_call', ...(item.id === undefined ? {} : { id: item.id }),
+                ...(item.namespace === undefined ? {} : { namespace: item.namespace }),
                 call_id: String(block.id), name: block.name, arguments: block.arguments,
             });
         }

package/lib/response-usage.d.ts

@@ -1,14 +1,16 @@
 /** Bounded per-response usage metadata emitted by the Codex Responses API. */
 export interface CodexResponseUsageMetadata {
     /** Exact provider representation; never coerce this high-precision value to a number. */
-    amount: string;
+    amount?: string;
+    /** Complete bounded `response.usage` JSON, including fields unknown to this client. */
+    metadata?: unknown;
 }
 export interface CodexResponseUsageObservation {
     accountId: string;
     metadata: CodexResponseUsageMetadata;
 }
 export type CodexResponseUsageCallback = (observation: CodexResponseUsageObservation) => void;
-/** Parse only response.completed usage_metadata.amount and preserve its exact string value. */
+/** Preserve exact billing amount and the complete bounded response.usage payload. */
 export declare function parseCodexResponseUsageMetadata(value: unknown): CodexResponseUsageMetadata | undefined;
 /** Publish optional response usage without allowing diagnostics to fail generation. */
 export declare function publishCodexResponseUsage(accountId: string, metadata: CodexResponseUsageMetadata | undefined, callback: CodexResponseUsageCallback | undefined, warn: ((message: string) => void) | undefined): void;

package/lib/response-usage.js

@@ -1,21 +1,41 @@
 /** Bounded per-response usage metadata emitted by the Codex Responses API. */
 const MAX_AMOUNT_BYTES = 256;
+const MAX_RAW_USAGE_BYTES = 64 * 1024;
 function record(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value)
         ? value : undefined;
 }
-/** Parse only response.completed usage_metadata.amount and preserve its exact string value. */
+function boundedJson(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    try {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined || Buffer.byteLength(encoded) > MAX_RAW_USAGE_BYTES)
+            return undefined;
+        return JSON.parse(encoded);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Preserve exact billing amount and the complete bounded response.usage payload. */
 export function parseCodexResponseUsageMetadata(value) {
     const event = record(value);
     if (event?.type !== 'response.completed')
         return undefined;
     const response = record(event.response);
-    const metadata = record(response?.usage_metadata);
-    const amount = metadata?.amount;
-    if (typeof amount !== 'string' || amount.length === 0
-        || Buffer.byteLength(amount) > MAX_AMOUNT_BYTES)
+    const usageMetadata = record(response?.usage_metadata);
+    const rawAmount = usageMetadata?.amount;
+    const amount = typeof rawAmount === 'string' && rawAmount.length > 0
+        && Buffer.byteLength(rawAmount) <= MAX_AMOUNT_BYTES
+        ? rawAmount : undefined;
+    const metadata = boundedJson(response?.usage);
+    if (amount === undefined && metadata === undefined)
         return undefined;
-    return { amount };
+    return {
+        ...amount === undefined ? {} : { amount },
+        ...metadata === undefined ? {} : { metadata },
+    };
 }
 /** Publish optional response usage without allowing diagnostics to fail generation. */
 export function publishCodexResponseUsage(accountId, metadata, callback, warn) {

package/lib/responses.d.ts

@@ -26,14 +26,20 @@ export interface ResponsesRequestInput {
     input: Record<string, unknown>[];
 }
 export declare function toResponsesTools(tools: readonly ToolSchema[]): Record<string, unknown>[];
+/** Responses Lite loads ordinary DSH functions through one canonical namespace. */
+export declare function toResponsesLiteTools(tools: readonly ToolSchema[]): Record<string, unknown>[];
 /** Convert resolved DSH messages into Responses instructions and ordered input items. */
 export declare function toResponsesInput(messages: readonly ResolvedMessage[], system?: string): ResponsesRequestInput;
 /** Bound call ids while preserving every function call/result correlation. */
 export declare function normalizeCodexCallIds(input: readonly Record<string, unknown>[]): Record<string, unknown>[];
 export interface ResponsesRequestMode {
     serviceTier?: 'priority';
+    responsesLite?: {
+        defaultVerbosity?: string;
+        instructionsTemplate?: string;
+    };
 }
-/** Build the canonical Standard/Fast HTTP Responses body. */
+/** Build the canonical Standard/Fast or model-specific Responses Lite body. */
 export declare function codexRequestBody(options: GenerateOptions, messages: readonly ResolvedMessage[], mode?: ResponsesRequestMode): Record<string, unknown>;
 export interface ResponsesUsage {
     input_tokens: number;
@@ -55,6 +61,7 @@ interface ResponsesOutputItem {
     id?: string;
     call_id?: string;
     name?: string;
+    namespace?: string;
     arguments?: string;
     encrypted_content?: string;
     summary?: unknown[];

package/lib/responses.js

@@ -7,6 +7,15 @@ export const DEFAULT_CODEX_INSTRUCTIONS = 'You are Codex, an AI coding agent. He
 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);
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    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 uuidBytes(value) { return Buffer.from(value.replaceAll('-', ''), 'hex'); }
 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) {
@@ -32,6 +41,13 @@ export function toResponsesTools(tools) {
         type: 'function', name: tool.name, description: tool.description, parameters: tool.parameters,
     }));
 }
+/** Responses Lite loads ordinary DSH functions through one canonical namespace. */
+export function toResponsesLiteTools(tools) {
+    const functions = toResponsesTools(tools);
+    return functions.length === 0 ? [] : [{
+            type: 'namespace', name: 'functions', description: '', tools: functions,
+        }];
+}
 /** Convert resolved DSH messages into Responses instructions and ordered input items. */
 export function toResponsesInput(messages, system) {
     const input = [];
@@ -144,29 +160,72 @@ function assertSupportedOptions(options) {
         throw fixedError('native Codex does not support stop sequences', 'UNSUPPORTED');
     }
 }
-/** Build the canonical Standard/Fast HTTP Responses body. */
+/** Build the canonical Standard/Fast or model-specific Responses Lite body. */
 export function codexRequestBody(options, messages, mode = {}) {
     assertSupportedOptions(options);
     if (mode.serviceTier !== undefined && mode.serviceTier !== 'priority') {
         throw fixedError('native Codex service tier is invalid', 'INVALID_ARGS');
     }
     const resolved = toResponsesInput(messages, options.system);
-    return {
+    const instructions = resolved.instructions ?? DEFAULT_CODEX_INSTRUCTIONS;
+    const input = normalizeCodexCallIds(resolved.input);
+    const common = {
         model: options.model,
-        instructions: resolved.instructions ?? DEFAULT_CODEX_INSTRUCTIONS,
-        input: normalizeCodexCallIds(resolved.input),
-        ...options.tools !== undefined && options.tools.length > 0
-            ? { tools: toResponsesTools(options.tools) } : {},
         tool_choice: 'auto',
-        parallel_tool_calls: true,
-        ...options.reasoningEffort === undefined ? {}
-            : { reasoning: { effort: String(options.reasoningEffort), summary: 'auto' } },
         store: false,
         stream: true,
         include: ['reasoning.encrypted_content'],
         ...mode.serviceTier === undefined ? {} : { service_tier: mode.serviceTier },
         ...options.sessionId === undefined ? {} : { prompt_cache_key: String(options.sessionId) },
     };
+    if (mode.responsesLite === undefined) {
+        return {
+            ...common,
+            instructions,
+            input,
+            ...options.tools !== undefined && options.tools.length > 0
+                ? { tools: toResponsesTools(options.tools) } : {},
+            parallel_tool_calls: true,
+            ...options.reasoningEffort === undefined ? {}
+                : { reasoning: { effort: String(options.reasoningEffort), summary: 'auto' } },
+        };
+    }
+    const tools = toResponsesLiteTools(options.tools ?? []);
+    const baseInstructions = mode.responsesLite.instructionsTemplate ?? instructions;
+    const contextualInstructions = mode.responsesLite.instructionsTemplate !== undefined
+        && resolved.instructions !== undefined && resolved.instructions !== baseInstructions
+        ? [{
+                type: 'message', role: 'developer',
+                content: [{ type: 'input_text', text: resolved.instructions }],
+            }]
+        : [];
+    const prefixNamespace = uuidBytes(uuidV5(UUID_NAMESPACE_OID, String(options.sessionId ?? options.model)));
+    const prefix = [{
+            type: 'additional_tools',
+            id: `at_${uuidV5(prefixNamespace, JSON.stringify(tools))}`,
+            role: 'developer',
+            tools,
+        }, {
+            type: 'message',
+            id: `msg_${uuidV5(prefixNamespace, baseInstructions)}`,
+            role: 'developer',
+            content: [{ type: 'input_text', text: baseInstructions }],
+            internal_chat_message_metadata_passthrough: {
+                content_item_kinds: ['model.base_instructions'],
+            },
+        }];
+    return {
+        ...common,
+        input: [...prefix, ...contextualInstructions, ...input],
+        parallel_tool_calls: false,
+        reasoning: {
+            ...options.reasoningEffort === undefined ? {} : { effort: String(options.reasoningEffort) },
+            summary: 'auto',
+            context: 'all_turns',
+        },
+        ...mode.responsesLite.defaultVerbosity === undefined ? {}
+            : { text: { verbosity: mode.responsesLite.defaultVerbosity } },
+    };
 }
 function tokenCount(value, field, fallback) {
     if (value === undefined && fallback !== undefined)
@@ -371,6 +430,8 @@ export class ResponsesStreamTranslator {
                 if (item.type === 'function_call') {
                     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))
                         || typeof item.arguments !== 'string') {
                         throw fixedError('native Codex function call has invalid content', 'MALFORMED_RESPONSE');
                     }
@@ -391,6 +452,7 @@ export class ResponsesStreamTranslator {
                     if (this.replayContext !== undefined)
                         this.replayCapture?.add({
                             type: 'function_call', ...(replayId === undefined ? {} : { id: replayId }),
+                            ...(item.namespace === undefined ? {} : { namespace: item.namespace }),
                             block: block.index,
                         });
                 }

package/lib/upstream.d.ts

@@ -1,6 +1,6 @@
 /** Single source of truth for the OpenAI Codex revision this adapter tracks. */
 export declare const TRACKED_CODEX_REPOSITORY = "https://github.com/openai/codex.git";
-export declare const TRACKED_CODEX_COMMIT = "6478a751fde8884b2fdc76486fe23175a8e795d4";
-export declare const TRACKED_CODEX_RELEASE = "rust-v0.151.0";
-/** Whole release version sent to the Codex model-catalog endpoint. */
-export declare const CODEX_CLIENT_VERSION = "0.151.0";
+export declare const TRACKED_CODEX_COMMIT = "ddf04ad26789d040f9ef6a96736f76602e35a6cc";
+export declare const TRACKED_CODEX_RELEASE = "main@ddf04ad";
+/** Whole stable release version sent to the Codex model-catalog endpoint. */
+export declare const CODEX_CLIENT_VERSION = "0.153.4";

package/lib/upstream.js

@@ -1,6 +1,6 @@
 /** Single source of truth for the OpenAI Codex revision this adapter tracks. */
 export const TRACKED_CODEX_REPOSITORY = 'https://github.com/openai/codex.git';
-export const TRACKED_CODEX_COMMIT = '6478a751fde8884b2fdc76486fe23175a8e795d4';
-export const TRACKED_CODEX_RELEASE = 'rust-v0.151.0';
-/** Whole release version sent to the Codex model-catalog endpoint. */
-export const CODEX_CLIENT_VERSION = '0.151.0';
+export const TRACKED_CODEX_COMMIT = 'ddf04ad26789d040f9ef6a96736f76602e35a6cc';
+export const TRACKED_CODEX_RELEASE = 'main@ddf04ad';
+/** Whole stable release version sent to the Codex model-catalog endpoint. */
+export const CODEX_CLIENT_VERSION = '0.153.4';

package/lib/usage.d.ts

@@ -8,6 +8,7 @@ export interface UsageWindow {
 export interface UsageLimitSummary {
     id: string;
     name?: string;
+    normalModelSlug?: string;
     primary?: UsageWindow;
     secondary?: UsageWindow;
     limitReached?: boolean;

package/lib/usage.js

@@ -33,9 +33,11 @@ function usageLimit(id, name, value) {
     const row = value;
     const primary = usageWindow(row.primary_window ?? row.primary);
     const secondary = usageWindow(row.secondary_window ?? row.secondary);
-    const limitReached = typeof row.limit_reached === 'boolean'
+    const explicitLimitReached = typeof row.limit_reached === 'boolean'
         ? row.limit_reached
         : typeof row.limitReached === 'boolean' ? row.limitReached : undefined;
+    const allowed = typeof row.allowed === 'boolean' ? row.allowed : undefined;
+    const limitReached = explicitLimitReached ?? (allowed === undefined ? undefined : !allowed);
     if (primary === undefined && secondary === undefined && limitReached === undefined)
         return undefined;
     return {
@@ -71,8 +73,13 @@ export function normalizeUsage(value) {
             if (id === undefined || id === 'codex' || limits.some(limit => limit.id === id))
                 continue;
             const extra = usageLimit(id, boundedUsageText(row.limit_name ?? row.limitName), row.rate_limit ?? row.rateLimit);
-            if (extra !== undefined)
-                limits.push(extra);
+            if (extra !== undefined) {
+                const normalModelSlug = boundedUsageText(row.normal_model_slug ?? row.normalModelSlug);
+                limits.push({
+                    ...extra,
+                    ...normalModelSlug === undefined ? {} : { normalModelSlug },
+                });
+            }
         }
     }
     const sortedLimits = sortedUsageLimits(limits);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "description": "Native ChatGPT Codex provider, device-code-first login, and same-origin Web integration for DeepSeek Harness",
   "license": "MIT",
   "publishConfig": {