@pure01fx/dsh-openai-codex-auth 0.5.0 → 0.6.1

package/lib/rate-limits.js

@@ -0,0 +1,189 @@
+/** Bounded parsing for Codex subscription quota side channels. */
+const MAX_TEXT_LENGTH = 128;
+const MAX_LIMITS = 32;
+const DEFAULT_LIMIT_ID = 'codex';
+function boundedText(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    return text.length > 0 && text.length <= MAX_TEXT_LENGTH ? text : undefined;
+}
+function finiteNumber(value) {
+    const number = typeof value === 'number' ? value
+        : typeof value === 'string' && value.trim() !== '' ? Number(value) : undefined;
+    return number !== undefined && Number.isFinite(number) ? number : undefined;
+}
+function safeNonNegativeInteger(value) {
+    const number = finiteNumber(value);
+    return number !== undefined && Number.isSafeInteger(number) && number >= 0 ? number : undefined;
+}
+function optionalBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (value === '1' || (typeof value === 'string' && value.toLowerCase() === 'true'))
+        return true;
+    if (value === '0' || (typeof value === 'string' && value.toLowerCase() === 'false'))
+        return false;
+    return undefined;
+}
+function normalizedLimitId(value) {
+    if (value === undefined || value === null)
+        return DEFAULT_LIMIT_ID;
+    const text = boundedText(value);
+    return text?.toLowerCase().replaceAll('-', '_');
+}
+function rateLimitWindow(value, duration) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const row = value;
+    const used = finiteNumber(row.used_percent ?? row.usedPercent);
+    if (used === undefined)
+        return undefined;
+    const rawWindow = duration === 'minutes'
+        ? safeNonNegativeInteger(row.window_minutes ?? row.windowMinutes)
+        : safeNonNegativeInteger(row.limit_window_seconds ?? row.windowDurationSecs);
+    const windowSeconds = rawWindow === undefined ? undefined
+        : duration === 'minutes' && rawWindow <= Math.floor(Number.MAX_SAFE_INTEGER / 60)
+            ? rawWindow * 60
+            : duration === 'seconds' ? rawWindow : undefined;
+    const resetAt = safeNonNegativeInteger(row.reset_at ?? row.resetsAt);
+    return {
+        usedPercent: Math.max(0, Math.min(100, used)),
+        ...windowSeconds === undefined ? {} : { windowSeconds },
+        ...resetAt === undefined ? {} : { resetAt },
+    };
+}
+export function parseCodexRateLimitCredits(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const row = value;
+    const hasCredits = optionalBoolean(row.has_credits ?? row.hasCredits);
+    const unlimited = optionalBoolean(row.unlimited);
+    if (hasCredits === undefined || unlimited === undefined)
+        return undefined;
+    const balance = boundedText(row.balance);
+    return {
+        hasCredits,
+        unlimited,
+        ...balance === undefined ? {} : { balance },
+    };
+}
+/** Parse a `codex.rate_limits` WebSocket v2 event without trusting provider text. */
+export function parseCodexRateLimitEvent(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const event = value;
+    if (event.type !== 'codex.rate_limits')
+        return undefined;
+    const limits = event.rate_limits !== null && typeof event.rate_limits === 'object'
+        && !Array.isArray(event.rate_limits)
+        ? event.rate_limits : {};
+    const primary = limits.primary === null ? null : rateLimitWindow(limits.primary, 'minutes');
+    const secondary = limits.secondary === null ? null : rateLimitWindow(limits.secondary, 'minutes');
+    const parsedCredits = parseCodexRateLimitCredits(event.credits);
+    const planType = boundedText(event.plan_type ?? event.planType);
+    const explicitReached = optionalBoolean(limits.limit_reached ?? limits.limitReached);
+    const allowed = optionalBoolean(limits.allowed);
+    const derivedReached = primary === undefined && secondary === undefined
+        ? undefined : [primary, secondary].some(window => window?.usedPercent === 100);
+    const limitReached = explicitReached
+        ?? (allowed === undefined ? derivedReached : !allowed);
+    if (primary === undefined && secondary === undefined && parsedCredits === undefined
+        && planType === undefined && limitReached === undefined)
+        return undefined;
+    const rawLimitId = event.metered_limit_name ?? event.meteredLimitName
+        ?? event.limit_name ?? event.limitName;
+    const limitId = normalizedLimitId(rawLimitId);
+    if (limitId === undefined)
+        return undefined;
+    const limitName = boundedText(event.limit_name ?? event.limitName);
+    return {
+        limitId,
+        ...limitName === undefined ? {} : { limitName },
+        ...planType === undefined ? {} : { planType },
+        ...primary === undefined ? {} : { primary },
+        ...secondary === undefined ? {} : { secondary },
+        ...limitReached === undefined ? {} : { limitReached },
+        ...parsedCredits === undefined ? {} : { credits: parsedCredits },
+    };
+}
+function headerEntries(source) {
+    if (source instanceof Headers) {
+        const entries = [];
+        source.forEach((value, name) => { entries.push([name.toLowerCase(), value]); });
+        return entries;
+    }
+    return Object.entries(source).flatMap(([name, raw]) => {
+        const value = Array.isArray(raw) ? raw[0] : raw;
+        return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+            ? [[name.toLowerCase(), String(value)]] : [];
+    });
+}
+/** Parse every `x-<limit>-primary-*` quota header family on an HTTP or wrapped WS response. */
+export function parseCodexRateLimitHeaders(source) {
+    if (source === undefined)
+        return [];
+    const headers = new Map(headerEntries(source));
+    const globalCredits = parseCodexRateLimitCredits({
+        has_credits: headers.get('x-codex-credits-has-credits'),
+        unlimited: headers.get('x-codex-credits-unlimited'),
+        balance: headers.get('x-codex-credits-balance'),
+    });
+    const prefixes = new Set();
+    for (const name of headers.keys()) {
+        for (const suffix of ['-primary-used-percent', '-secondary-used-percent']) {
+            if (name.startsWith('x-') && name.endsWith(suffix)) {
+                prefixes.add(name.slice(0, -suffix.length));
+            }
+        }
+    }
+    if (globalCredits !== undefined)
+        prefixes.add('x-codex');
+    const updates = [];
+    for (const prefix of [...prefixes].sort().slice(0, MAX_LIMITS)) {
+        const primary = rateLimitWindow({
+            used_percent: headers.get(`${prefix}-primary-used-percent`),
+            window_minutes: headers.get(`${prefix}-primary-window-minutes`),
+            reset_at: headers.get(`${prefix}-primary-reset-at`),
+        }, 'minutes');
+        const secondary = rateLimitWindow({
+            used_percent: headers.get(`${prefix}-secondary-used-percent`),
+            window_minutes: headers.get(`${prefix}-secondary-window-minutes`),
+            reset_at: headers.get(`${prefix}-secondary-reset-at`),
+        }, 'minutes');
+        const parsedCredits = prefix === 'x-codex' ? globalCredits : undefined;
+        if (primary === undefined && secondary === undefined && parsedCredits === undefined)
+            continue;
+        const limitId = normalizedLimitId(prefix.slice(2));
+        if (limitId === undefined)
+            continue;
+        const limitName = boundedText(headers.get(`${prefix}-limit-name`));
+        const limitReached = primary === undefined && secondary === undefined
+            ? undefined : [primary, secondary].some(window => window?.usedPercent === 100);
+        updates.push({
+            limitId,
+            ...limitName === undefined ? {} : { limitName },
+            ...primary === undefined ? {} : { primary },
+            ...secondary === undefined ? {} : { secondary },
+            ...limitReached === undefined ? {} : { limitReached },
+            ...parsedCredits === undefined ? {} : { credits: parsedCredits },
+        });
+    }
+    return updates;
+}
+/** Publish optional quota metadata without letting diagnostics break a model stream. */
+export function publishCodexRateLimits(accountId, updates, callback, warn) {
+    if (updates.length === 0 || callback === undefined)
+        return;
+    try {
+        callback({ accountId, updates });
+    }
+    catch {
+        try {
+            warn?.('native Codex rate-limit update could not be published');
+        }
+        catch {
+            // Quota diagnostics are observational and must never fail generation.
+        }
+    }
+}

package/lib/replay.d.ts

@@ -0,0 +1,49 @@
+/** Bounded, 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;
+export type NativeCodexReplayDescriptor = {
+    type: 'message';
+    id?: string;
+    blocks: number[];
+} | {
+    type: 'reasoning';
+    id?: string;
+    blocks: number[];
+    encryptedContent?: string;
+} | {
+    type: 'function_call';
+    id?: string;
+    block: number;
+};
+export interface NativeCodexReplayState {
+    kind: typeof NATIVE_CODEX_REPLAY_KIND;
+    version: typeof NATIVE_CODEX_REPLAY_VERSION;
+    provider: string;
+    model: string;
+    items: NativeCodexReplayDescriptor[];
+}
+export interface NativeCodexReplaySource {
+    provider: string;
+    model: string;
+    replayState: unknown;
+}
+/** Preserve only server item IDs that Codex itself would replay. */
+export declare function replayableItemId(value: string | undefined): string | undefined;
+/** True only for state emitted by this package; foreign adapters degrade to visible history. */
+export declare function hasNativeCodexReplayKind(value: unknown): boolean;
+/** Attempt-local 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;
+    finish(): NativeCodexReplayState | undefined;
+}
+/** Create state only for a successful response with completed replay descriptors. */
+export declare function createNativeCodexReplayState(provider: string, model: string, items: readonly NativeCodexReplayDescriptor[]): NativeCodexReplayState | undefined;
+/** Reconstruct provider items without duplicating durable visible block payloads in state. */
+export declare function replayAssistantInput(content: readonly ContentBlock[], source: NativeCodexReplaySource): Record<string, unknown>[];

package/lib/replay.js

@@ -0,0 +1,240 @@
+/** Bounded, 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_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;
+function failure(message, code = 'INVALID_REPLAY_STATE') {
+    return new LlmError(message, code);
+}
+function object(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+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;
+}
+/** 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;
+    try {
+        serialized = 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);
+    }
+}
+function validateBlockArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const blocks = [];
+    for (const item of value) {
+        if (!Number.isSafeInteger(item) || Number(item) < 0)
+            return undefined;
+        blocks.push(Number(item));
+    }
+    return blocks;
+}
+function parseDescriptor(value) {
+    const row = object(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 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');
+    }
+    if (row.type === 'message') {
+        const blocks = validateBlockArray(row.blocks);
+        if (blocks === undefined || !onlyKeys(row, ['type', 'id', 'blocks'])) {
+            throw failure('native Codex message replay descriptor is invalid');
+        }
+        return { type: 'message', ...(id === undefined ? {} : { id }), blocks };
+    }
+    if (row.type === 'reasoning') {
+        const blocks = validateBlockArray(row.blocks);
+        const encryptedContent = row.encryptedContent === undefined
+            ? undefined : boundedString(row.encryptedContent, MAX_REPLAY_CIPHERTEXT_BYTES);
+        if (blocks === undefined
+            || (row.encryptedContent !== undefined && encryptedContent === undefined)
+            || !onlyKeys(row, ['type', 'id', 'blocks', 'encryptedContent'])) {
+            throw failure('native Codex reasoning replay descriptor is invalid');
+        }
+        return {
+            type: 'reasoning', ...(id === undefined ? {} : { id }), blocks,
+            ...(encryptedContent === undefined ? {} : { encryptedContent }),
+        };
+    }
+    if (row.type === 'function_call') {
+        if (!Number.isSafeInteger(row.block) || Number(row.block) < 0
+            || !onlyKeys(row, ['type', 'id', 'block'])) {
+            throw failure('native Codex function replay descriptor is invalid');
+        }
+        return { type: 'function_call', ...(id === undefined ? {} : { id }), block: Number(row.block) };
+    }
+    throw failure('native Codex replay descriptor type is unsupported');
+}
+/** True only for state emitted by this package; foreign adapters degrade to visible history. */
+export function hasNativeCodexReplayKind(value) {
+    return object(value)?.kind === NATIVE_CODEX_REPLAY_KIND;
+}
+function parseState(value) {
+    safeStateSize(value, 'INVALID_REPLAY_STATE');
+    const row = object(value);
+    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);
+    if (provider === undefined || model === undefined || !Array.isArray(row.items)
+        || row.items.length === 0 || row.items.length > MAX_REPLAY_DESCRIPTORS) {
+        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,
+        provider,
+        model,
+        items,
+    };
+}
+/** Attempt-local bounded accumulator; no ciphertext can grow unchecked before completion. */
+export class NativeCodexReplayCapture {
+    provider;
+    model;
+    descriptors = [];
+    references = 0;
+    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 (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');
+        }
+        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.references += addedReferences;
+        this.stateBytes = nextBytes;
+    }
+    finish() {
+        return createNativeCodexReplayState(this.provider, this.model, this.descriptors);
+    }
+}
+/** Create state only for a successful response with completed replay descriptors. */
+export function createNativeCodexReplayState(provider, model, items) {
+    if (items.length === 0)
+        return undefined;
+    const state = {
+        kind: NATIVE_CODEX_REPLAY_KIND,
+        version: NATIVE_CODEX_REPLAY_VERSION,
+        provider,
+        model,
+        items: items.map(item => ({ ...item })),
+    };
+    safeStateSize(state, 'REPLAY_STATE_TOO_LARGE');
+    try {
+        return parseState(state);
+    }
+    catch {
+        throw failure('native Codex completed items cannot form replay state', 'MALFORMED_RESPONSE');
+    }
+}
+function blockAt(content, used, index, expected) {
+    const block = content[index];
+    if (block === undefined || block.type !== expected || used.has(index)) {
+        throw failure('native Codex replay block reference is invalid');
+    }
+    used.add(index);
+    return block;
+}
+/** Reconstruct provider items without duplicating durable visible block payloads in state. */
+export function replayAssistantInput(content, source) {
+    const state = parseState(source.replayState);
+    if (state.provider !== source.provider || state.model !== source.model) {
+        throw failure('native Codex replay provenance does not match its assistant message');
+    }
+    const used = new Set();
+    const input = [];
+    for (const item of state.items) {
+        if (item.type === 'message') {
+            const parts = item.blocks.map((index) => {
+                const block = blockAt(content, used, index, 'text');
+                return { type: 'output_text', text: block.text };
+            });
+            input.push({
+                type: 'message', ...(item.id === undefined ? {} : { id: item.id }),
+                role: 'assistant', content: parts,
+            });
+        }
+        else if (item.type === 'reasoning') {
+            const summary = item.blocks.map((index) => {
+                const block = blockAt(content, used, index, 'reasoning');
+                return { type: 'summary_text', text: block.text };
+            });
+            input.push({
+                type: 'reasoning', ...(item.id === undefined ? {} : { id: item.id }), summary,
+                ...(item.encryptedContent === undefined ? {} : { encrypted_content: item.encryptedContent }),
+            });
+        }
+        else {
+            const block = blockAt(content, used, item.block, 'tool-call');
+            input.push({
+                type: 'function_call', ...(item.id === undefined ? {} : { id: item.id }),
+                call_id: String(block.id), name: block.name, arguments: block.arguments,
+            });
+        }
+    }
+    if (used.size !== content.length) {
+        throw failure('native Codex replay state does not cover every assistant block');
+    }
+    return input;
+}

package/lib/response-usage.d.ts

@@ -0,0 +1,14 @@
+/** 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;
+}
+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. */
+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

@@ -0,0 +1,35 @@
+/** Bounded per-response usage metadata emitted by the Codex Responses API. */
+const MAX_AMOUNT_BYTES = 256;
+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. */
+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)
+        return undefined;
+    return { amount };
+}
+/** Publish optional response usage without allowing diagnostics to fail generation. */
+export function publishCodexResponseUsage(accountId, metadata, callback, warn) {
+    if (metadata === undefined || callback === undefined)
+        return;
+    try {
+        callback({ accountId, metadata });
+    }
+    catch {
+        try {
+            warn?.('native Codex response usage metadata could not be published');
+        }
+        catch {
+            // Per-response usage is observational and must never fail generation.
+        }
+    }
+}

package/lib/responses.d.ts

@@ -0,0 +1,126 @@
+import { CallId, 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.";
+export interface ResolvedImagePart {
+    type: 'image';
+    mediaType: string;
+    dataBase64: string;
+}
+export interface ResolvedToolResultPart {
+    type: 'tool-result';
+    toolCallId: CallId;
+    content: readonly ResolvedContentPart[];
+    isError?: boolean;
+}
+export type ResolvedContentPart = Exclude<ContentBlock, {
+    type: 'image' | 'tool-result';
+}> | ResolvedImagePart | ResolvedToolResultPart;
+export interface ResolvedMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: readonly ResolvedContentPart[];
+    replaySource?: NativeCodexReplaySource;
+}
+export interface ResponsesRequestInput {
+    instructions?: string;
+    input: Record<string, unknown>[];
+}
+export declare function toResponsesTools(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';
+}
+/** Build the canonical Standard/Fast HTTP Responses body. */
+export declare function codexRequestBody(options: GenerateOptions, messages: readonly ResolvedMessage[], mode?: ResponsesRequestMode): Record<string, unknown>;
+export interface ResponsesUsage {
+    input_tokens: number;
+    output_tokens: number;
+    input_tokens_details?: {
+        cached_tokens?: number;
+        cache_write_tokens?: number;
+    };
+    output_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+}
+/** Map provider totals to DSH's strict disjoint token counts. */
+export declare function mapResponsesUsage(usage: ResponsesUsage): TokenUsage;
+/** Classify in-band failure data without reflecting provider text. */
+export declare function responsesFailure(code?: string, message?: string): LlmError;
+interface ResponsesOutputItem {
+    type?: string;
+    id?: string;
+    call_id?: string;
+    name?: string;
+    arguments?: string;
+    encrypted_content?: string;
+    summary?: unknown[];
+    status?: string;
+    content?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+}
+export interface ResponsesStreamEvent {
+    type: string;
+    item_id?: string;
+    output_index?: number;
+    content_index?: number;
+    summary_index?: number;
+    delta?: string;
+    text?: string;
+    call_id?: string;
+    name?: string;
+    item?: ResponsesOutputItem;
+    response?: {
+        status?: string;
+        usage?: ResponsesUsage;
+        error?: {
+            code?: string;
+            message?: string;
+        };
+        incomplete_details?: {
+            reason?: string;
+        };
+    };
+    code?: string;
+    message?: string;
+}
+export interface ResponsesReplayContext {
+    provider: string;
+    model: string;
+}
+/** Stateful, transport-free Responses event to DSH chunk translator. */
+export declare class ResponsesStreamTranslator {
+    private readonly replayContext?;
+    private readonly blocks;
+    private readonly order;
+    private readonly replayCapture;
+    private nextIndex;
+    private sawToolCall;
+    terminated: boolean;
+    constructor(replayContext?: ResponsesReplayContext | undefined);
+    private open;
+    private close;
+    private closeItem;
+    private closeAll;
+    push(event: ResponsesStreamEvent): StreamChunk[];
+    endOfStream(): never;
+}
+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;
+/** Extract the bounded sticky turn token from provider metadata/event shapes. */
+export declare function codexResponseTurnState(event: ResponsesStreamEvent): string | undefined;
+/** Consume framed SSE JSON into DSH chunks. */
+export declare function streamResponses(stream: ReadableStream<Uint8Array>, options?: StreamResponsesOptions): AsyncGenerator<StreamChunk>;
+export {};