@skill-harness/adapters 0.16.0 → 0.18.0

package/dist/codex-model-profile.js

@@ -1,54 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { lstatSync, readFileSync, realpathSync, readlinkSync } from 'node:fs';
-/** Separate from linux-bwrap-digest-v1: this proves only a fixed IPC probe workload.
- * It MUST NOT be used to run arbitrary model/extension code. A model-bearing profile
- * additionally needs aggregate host/descendant memory/CPU/egress limits and token
- * semantics; these are deliberately reported unqualified rather than bypassed. */
-export const CODEX_LOCAL_PROFILE = Object.freeze({ id: 'linux-bwrap-codex-ipc-probe-v1', network: 'unshared-no-egress', credentials: 'none', cpuSeconds: 2, nofile: 64, heapMiB: 32, wallMs: 3000, outputBytes: 4096, arbitraryCode: false, modelExecutionQualified: false });
-const CODE = `const fs=require('node:fs');let rootReadOnly=false;try{fs.writeFileSync('/usr/.codex-profile-write-probe','denied',{flag:'wx'});}catch(e){rootReadOnly=e.code==='EROFS';}const id=process.argv[1];process.stdout.write(JSON.stringify({frame:JSON.stringify({id,sequence:1})+'\\n',netNamespace:fs.readlinkSync('/proc/self/ns/net'),envKeys:Object.keys(process.env),pwd:process.env.PWD,rootReadOnly}));`;
-export async function probeLocalCodexProfile(id) {
-    if (typeof id !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(id))
-        throw Error('bounded invocation identity required');
-    if (process.platform !== 'linux')
-        throw Error('Linux namespaces required; no fallback');
-    const parentNet = readlinkSync('/proc/self/ns/net'), node = realpathSync(process.execPath), fingerprints = {};
-    for (const p of [node, '/usr/bin/bwrap', '/usr/bin/prlimit']) {
-        const s = lstatSync(p);
-        if (!s.isFile() || (s.mode & 0o022) || s.size > 256 * 1024 * 1024)
-            throw Error('untrusted runtime executable');
-        fingerprints[p] = createHash('sha256').update(readFileSync(p)).digest('hex');
-    }
-    const args = ['--unshare-all', '--die-with-parent', '--new-session', '--cap-drop', 'ALL', '--ro-bind', '/usr', '/usr', '--ro-bind', '/lib', '/lib', '--ro-bind', '/lib64', '/lib64', '--dir', '/runtime', '--ro-bind', node, '/runtime/node', '--proc', '/proc', '--dev', '/dev', '--clearenv', '--chdir', '/', '--', '/usr/bin/prlimit', '--cpu=2:2', '--nofile=64:64', '--', '/runtime/node', '--max-old-space-size=32', '-e', CODE, id];
-    const proof = await new Promise((resolve, reject) => {
-        const child = spawn('/usr/bin/bwrap', args, { env: {}, stdio: ['ignore', 'pipe', 'pipe'] });
-        let bytes = 0, failed;
-        const chunks = [];
-        // The original ChildProcess handle is retained. No discovery/PID/title cancellation.
-        const fail = (e) => { failed ??= e; child.kill('SIGKILL'); };
-        const timer = setTimeout(() => fail(Error('local profile deadline')), CODEX_LOCAL_PROFILE.wallMs);
-        child.stdout.on('data', (b) => { bytes += b.length; if (bytes > CODEX_LOCAL_PROFILE.outputBytes)
-            fail(Error('local profile output bound'));
-        else
-            chunks.push(Buffer.from(b)); });
-        child.stderr.on('data', (b) => { bytes += b.length; if (bytes > CODEX_LOCAL_PROFILE.outputBytes)
-            fail(Error('local profile output bound')); });
-        child.once('error', e => { failed = e; });
-        child.once('close', (code, signal) => { clearTimeout(timer); if (failed) {
-            reject(failed);
-            return;
-        } if (code !== 0 || signal) {
-            reject(Error('local namespace probe failed; prerequisite NOT qualified'));
-            return;
-        } try {
-            resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
-        }
-        catch {
-            reject(Error('malformed profile proof'));
-        } });
-    });
-    if (proof.frame !== JSON.stringify({ id, sequence: 1 }) + '\n' || proof.rootReadOnly !== true || !Array.isArray(proof.envKeys) || proof.envKeys.join() !== 'PWD' || proof.pwd !== '/' || (typeof proof.netNamespace !== 'string' || proof.netNamespace === parentNet))
-        throw Error('local profile invariant failed: ' + JSON.stringify(proof));
-    return { ...proof, profile: CODEX_LOCAL_PROFILE, fingerprints, modelExecutionQualified: false, remaining: ['aggregate model/host/descendant resource qualification', 'host-only subscription credential and egress boundary', 'provider output-token cap semantics'] };
-}
-//# sourceMappingURL=codex-model-profile.js.map

package/dist/codex-producer-ipc.d.ts

@@ -1,55 +0,0 @@
-import type { Readable } from 'node:stream';
-import type { CodexSdkBinding, CodexWireTransport } from './codex-sdk-transport.js';
-export interface CodexProducerBinding {
-    version: string;
-    budgetDigest: string;
-    orderId: string;
-    experimentId: string;
-    executionId: string;
-    charterSha256: string;
-    invocationId: string;
-}
-/** These are trusted producer-module capabilities, not caller-provided source attestation.
- * The launcher must pin the actual producer module; this adapter never loads credentials. */
-export interface CodexProducerApi {
-    createProducerIpcHost(input: {
-        owner: unknown;
-        binding: CodexProducerBinding;
-        exchange: (frames: Readable, context: {
-            binding: CodexProducerBinding;
-            signal: AbortSignal;
-        }) => Promise<{
-            claimRef: string;
-            responseRef: string;
-        }>;
-    }): unknown;
-    startProducerIpc(input: {
-        owner: unknown;
-        permit: unknown;
-        binding: CodexProducerBinding;
-        host: unknown;
-        signal: AbortSignal;
-        timeoutMs: number;
-    }): Promise<{
-        completion: Promise<any>;
-        result: Promise<any>;
-        inspect(): any;
-        [key: string]: unknown;
-    }>;
-}
-export declare function startCodexProducerIpc(input: {
-    path: string;
-    binding: CodexProducerBinding;
-    sdk: CodexSdkBinding;
-    transport: CodexWireTransport;
-    producer: CodexProducerApi;
-    owner: unknown;
-    permit: unknown;
-    signal: AbortSignal;
-    timeoutMs: number;
-}): Promise<Readonly<{
-    completion: Promise<any>;
-    result: Promise<any>;
-    inspect(): any;
-}>>;
-export declare function validateCodexProducerBinding(raw: CodexProducerBinding): CodexProducerBinding;

package/dist/codex-producer-ipc.js

@@ -1,67 +0,0 @@
-import { createHash } from 'node:crypto';
-import { learningCopy, learningHash, learningJournal } from './learning-journal.js';
-import { openLocalCodexHost, inspectCodexRoleSeparation } from './codex-host-observer.js';
-export async function startCodexProducerIpc(input) {
-    const binding = validateCodexProducerBinding(input.binding);
-    return startValidatedProducer(input, binding);
-}
-export function validateCodexProducerBinding(raw) {
-    const binding = learningCopy(raw), keys = ['version', 'budgetDigest', 'orderId', 'experimentId', 'executionId', 'charterSha256', 'invocationId'];
-    if (!binding || Object.keys(binding).sort().join() !== keys.sort().join() || binding.version !== 'producer-ipc-v1' || ![binding.budgetDigest, binding.charterSha256].every(h => /^[a-f0-9]{64}$/.test(h)) || ![binding.orderId, binding.experimentId, binding.executionId, binding.invocationId].every(v => typeof v === 'string' && /^[a-zA-Z0-9:_-]{1,128}$/.test(v)))
-        throw Error('closed producer source binding required');
-    return binding;
-}
-async function startValidatedProducer(input, binding) {
-    const store = learningJournal(input.path), rows = store.read(), first = rows[0].value, host = openLocalCodexHost(input.path);
-    const invocation = first.spec.invocations.find((i) => i.id === binding.invocationId), reservation = first.subscription, model = input.sdk.model;
-    if (!reservation || reservation.charterSha256 !== binding.charterSha256 || input.transport.kind !== (reservation.mode === 'fixture' ? 'fixture-http' : 'subscription-http') || !first.rolePolicy || inspectCodexRoleSeparation(first.rolePolicy).state === 'BLOCKED' || !invocation || model.id !== invocation.model || model.provider !== 'openai-codex' || model.api !== 'openai-codex-responses' || model.baseUrl !== 'https://chatgpt.com/backend-api' || model.headers && Object.keys(model.headers).length || typeof input.sdk.stream !== 'function')
-        throw Error('unbound producer/host charter or SDK policy');
-    if (!(input.signal instanceof AbortSignal) || !Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 50 || input.timeoutMs > 30000)
-        throw Error('bounded original source signal/deadline required');
-    if (host.inspect().aborted || rows.some(e => e.value.id === binding.invocationId && ['claim', 'producer-ipc-bound'].includes(String(e.value.type))))
-        throw Error('source already bound/claimed or aborted; no retry');
-    const bindingHash = learningHash(binding), append = (value) => store.append(store.read().at(-1).id, value);
-    let invoked = false, references = null;
-    const port = input.producer.createProducerIpcHost({ owner: input.owner, binding, exchange: async (frames, context) => {
-            if (invoked) {
-                frames.destroy();
-                throw Error('repeated producer exchange refused');
-            }
-            invoked = true;
-            if (learningHash(context.binding) !== bindingHash || !(context.signal instanceof AbortSignal)) {
-                frames.destroy();
-                throw Error('original source context mismatch');
-            }
-            const observation = await host.exchangeSubscriptionSdk(frames, input.sdk, input.transport, binding.charterSha256, context.signal);
-            const records = store.read(), claim = records.find(e => e.value.type === 'claim' && e.value.id === observation.id), response = records.find(e => e.value.type === 'observation' && e.value.id === observation.id);
-            if (!claim || !response)
-                throw Error('host observation references missing');
-            references = { claimRef: claim.id, responseRef: response.id };
-            return { ...references };
-        } });
-    append({ type: 'producer-ipc-bound', id: binding.invocationId, bindingHash, binding, liveQualified: false });
-    let run;
-    try {
-        run = await input.producer.startProducerIpc({ owner: input.owner, permit: input.permit, binding, host: port, signal: input.signal, timeoutMs: input.timeoutMs });
-    }
-    catch {
-        append({ type: 'abort', reason: 'producer source start failed; no retry', id: binding.invocationId });
-        throw Error('producer source start failed');
-    }
-    const completion = run.completion.then(snapshot => {
-        const frameSha256 = createHash('sha256').update(JSON.stringify({ id: binding.invocationId, sequence: 1 }) + '\n').digest('hex');
-        const acknowledged = invoked && references !== null && learningHash(snapshot.binding) === bindingHash && snapshot.outcome === 'completed' && snapshot.settlement === 'acknowledged' && snapshot.childState === 'settled' && snapshot.hostState === 'acknowledged' && snapshot.frameSha256 === frameSha256 && snapshot.acceptance === 'not-assessed' && learningHash(snapshot.references) === learningHash(references);
-        if (acknowledged)
-            append({ type: 'producer-ipc-settled', id: binding.invocationId, bindingHash, references, frameSha256, liveQualified: false, acceptance: 'not-assessed' });
-        else {
-            append({ type: 'abort', reason: 'producer source did not acknowledge completed ownership', id: binding.invocationId });
-            if (snapshot.outcome === 'completed')
-                throw Error('producer source completion mismatch');
-        }
-        return snapshot;
-    }, () => { append({ type: 'abort', reason: 'producer source completion rejected', id: binding.invocationId }); throw Error('producer source completion rejected'); });
-    // Preserve original bounded result/child/readiness/inspect handles. Only original completion
-    // can unlock host eligibility; an observer timeout never substitutes for that completion.
-    return Object.freeze({ ...run, completion });
-}
-//# sourceMappingURL=codex-producer-ipc.js.map

package/dist/codex-sdk-transport.d.ts

@@ -1,50 +0,0 @@
-import { PassThrough, Writable } from 'node:stream';
-/** Trusted installed SDK dependency, NOT an extension/caller capability. No auth loader or
- * network implementation is imported here. The sole credential is deliberately invalid.
- * Inert execution additionally requires the documented network-unshared, no-home mount. */
-export interface CodexSdkBinding {
-    model: {
-        id: string;
-        provider: string;
-        api: string;
-        baseUrl: string;
-        [key: string]: unknown;
-    };
-    stream: (model: any, context: any, options: any) => {
-        result(): Promise<any>;
-    };
-}
-/** Public result is final text only; reasoning metadata never leaves the private validator. */
-export declare function validateCodexTextSse(bytes: Buffer, model: string): {
-    text: string;
-    responseId: string;
-};
-export interface CodexWire {
-    destination: string;
-    method: 'POST';
-    body: Buffer;
-    encoding: string | null;
-}
-export interface CodexWireTransport {
-    kind: 'fixture-http' | 'subscription-http';
-    exchange(wire: CodexWire, signal: AbortSignal, record: (value: Record<string, unknown>) => void): Promise<Response>;
-}
-export declare function inertCodexSdkStreams(binding: CodexSdkBinding, fixture: () => Promise<Response>, record: (value: Record<string, unknown>) => void): {
-    transport: Writable;
-    response: PassThrough;
-};
-export declare function boundCodexSdkStreams(binding: CodexSdkBinding, transport: CodexWireTransport, record: (value: Record<string, unknown>) => void, caps: {
-    requestBytes: number;
-    responseBytes: number;
-}): {
-    transport: Writable;
-    response: PassThrough;
-};
-/** Separate review request profile; historical exact-output transport retains its 4096-byte cap. */
-export declare function boundCodexReviewSdkStreams(binding: CodexSdkBinding, transport: CodexWireTransport, record: (value: Record<string, unknown>) => void, caps: {
-    requestBytes: number;
-    responseBytes: number;
-}): {
-    transport: Writable;
-    response: PassThrough;
-};

package/dist/codex-sdk-transport.js

@@ -1,294 +0,0 @@
-import { createHash } from 'node:crypto';
-import { PassThrough, Writable } from 'node:stream';
-import { isDeepStrictEqual } from 'node:util';
-import * as zlib from 'node:zlib';
-const destination = 'https://chatgpt.com/backend-api/codex/responses';
-const hash = (b) => createHash('sha256').update(b).digest('hex');
-const fixtureCredential = 'fixture.' + Buffer.from(JSON.stringify({ 'https://api.openai.com/auth': { chatgpt_account_id: 'fixture-no-account' } })).toString('base64url') + '.invalid';
-/** Public result is final text only; reasoning metadata never leaves the private validator. */
-export function validateCodexTextSse(bytes, model) {
-    const v = validateResponseProfile(bytes, model);
-    return { text: v.text, responseId: v.responseId };
-}
-function profileKeys(v, required, optional = []) { if (!v || typeof v !== 'object' || Array.isArray(v) || required.some(k => !Object.hasOwn(v, k)) || Object.keys(v).some(k => ![...required, ...optional].includes(k)))
-    throw Error('unsupported reasoning profile fields'); }
-function reasoningShape(item) { profileKeys(item, ['id', 'type', 'summary', 'content', 'encrypted_content']); if (item.type !== 'reasoning' || typeof item.id !== 'string' || !item.id || item.id.length > 128 || !isDeepStrictEqual(item.content, []) || typeof item.encrypted_content !== 'string' || !item.encrypted_content || Buffer.byteLength(item.encrypted_content) > 8192)
-    throw Error('unsupported reasoning item'); }
-function textPart(part) { profileKeys(part, ['type', 'text'], ['annotations', 'logprobs']); if (part.type !== 'output_text' || typeof part.text !== 'string' || ['annotations', 'logprobs'].some(k => Object.hasOwn(part, k) && !isDeepStrictEqual(part[k], [])))
-    throw Error('unsupported final text part'); }
-function validateResponseProfile(bytes, model) {
-    const text = new TextDecoder('utf8', { fatal: true }).decode(bytes).replace(/\r\n/g, '\n');
-    if (!text.endsWith('\n\n'))
-        throw Error('truncated SSE framing');
-    let sequence = 0, phase = 0, responseId = '', itemId = '', output = '', completedItem;
-    let partOpen = false, partDone = false, textDone = false, progress = false;
-    let reasoningId = '', summary = '', summaryPhase = 0, summaryBytes = 0, reasoningItem, answerIndex = 0;
-    const summaries = []; // At most16 sequential parts;4096 aggregate text bytes.
-    for (const block of text.slice(0, -2).split('\n\n')) {
-        const lines = block.split('\n').filter(l => l && !l.startsWith(':'));
-        if (!lines.length)
-            continue;
-        const types = lines.filter(l => l.startsWith('event:')).map(l => l.slice(6).trim()), data = lines.filter(l => l.startsWith('data:')).map(l => l.slice(5).replace(/^ /, ''));
-        if (types.length > 1 || !data.length || types.length + data.length !== lines.length)
-            throw Error('unsupported SSE framing');
-        const e = JSON.parse(data.join('\n'));
-        if (types.length && e.type !== types[0] || e.sequence_number !== sequence++)
-            throw Error('SSE sequence or event mismatch');
-        if (reasoningItem && e.type !== 'response.completed') {
-            const fields = { 'response.output_item.added': ['output_index', 'item'], 'response.output_item.done': ['output_index', 'item'], 'response.content_part.added': ['output_index', 'content_index', 'item_id', 'part'], 'response.content_part.done': ['output_index', 'content_index', 'item_id', 'part'], 'response.output_text.delta': ['output_index', 'content_index', 'item_id', 'delta'], 'response.output_text.done': ['output_index', 'content_index', 'item_id', 'text'] };
-            if (!fields[e.type])
-                throw Error('unsupported reasoning/final event');
-            profileKeys(e, ['type', 'sequence_number', ...fields[e.type]], e.type === 'response.output_text.delta' ? ['obfuscation', 'logprobs'] : e.type === 'response.output_text.done' ? ['logprobs'] : []);
-            if (Object.hasOwn(e, 'logprobs') && !isDeepStrictEqual(e.logprobs, []) || Object.hasOwn(e, 'obfuscation') && (typeof e.obfuscation !== 'string' || Buffer.byteLength(e.obfuscation) > 4096))
-                throw Error('unsupported final metadata');
-            if (e.item) {
-                profileKeys(e.item, ['id', 'type', 'role', 'status', 'phase', 'content']);
-                if (e.item.phase !== 'final_answer')
-                    throw Error('unsupported final phase');
-                if (e.type === 'response.output_item.done') {
-                    if (!Array.isArray(e.item.content) || e.item.content.length !== 1)
-                        throw Error('final text cardinality');
-                    textPart(e.item.content[0]);
-                }
-            }
-            if (e.part)
-                textPart(e.part);
-        }
-        if (e.type === 'response.created' && phase === 0) {
-            responseId = e.response?.id;
-            if (typeof responseId !== 'string' || !responseId || responseId.length > 128 || e.response.status !== 'in_progress')
-                throw Error('response identity missing');
-            phase = 1;
-        }
-        else if (e.type === 'response.in_progress' && phase === 1 && !progress && !reasoningId) {
-            if (e.response?.id !== responseId || e.response.status !== 'in_progress')
-                throw Error('progress correlation');
-            progress = true;
-        }
-        else if (e.type === 'response.output_item.added' && phase === 1 && e.item?.type === 'reasoning' && !reasoningId) {
-            profileKeys(e, ['type', 'sequence_number', 'output_index', 'item']);
-            reasoningShape(e.item);
-            if (e.output_index !== 0 || !isDeepStrictEqual(e.item.summary, []))
-                throw Error('reasoning start mismatch');
-            reasoningId = e.item.id;
-            phase = 5;
-        }
-        else if (phase === 5) {
-            if (e.type === 'response.output_item.done') {
-                profileKeys(e, ['type', 'sequence_number', 'output_index', 'item']);
-                reasoningShape(e.item);
-                if (e.output_index !== 0 || e.item.id !== reasoningId || summaryPhase !== 0 || !isDeepStrictEqual(e.item.summary, summaries))
-                    throw Error('reasoning completion mismatch');
-                reasoningItem = e.item;
-                answerIndex = 1;
-                phase = 1;
-            }
-            else {
-                const kind = e.type, field = kind === 'response.reasoning_summary_text.delta' ? 'delta' : kind === 'response.reasoning_summary_text.done' ? 'text' : 'part';
-                profileKeys(e, ['type', 'sequence_number', 'output_index', 'item_id', 'summary_index', field], field === 'delta' ? ['obfuscation'] : []);
-                if (e.output_index !== 0 || e.item_id !== reasoningId || e.summary_index !== summaries.length || Object.hasOwn(e, 'obfuscation') && (typeof e.obfuscation !== 'string' || Buffer.byteLength(e.obfuscation) > 4096))
-                    throw Error('reasoning summary correlation');
-                if (field === 'part') {
-                    profileKeys(e.part, ['type', 'text']);
-                    if (e.part.type !== 'summary_text' || typeof e.part.text !== 'string')
-                        throw Error('reasoning summary part');
-                }
-                if (kind === 'response.reasoning_summary_part.added' && summaryPhase === 0 && e.part.text === '' && summaries.length < 16)
-                    summaryPhase = 1;
-                else if (kind === 'response.reasoning_summary_text.delta' && summaryPhase === 1 && typeof e.delta === 'string') {
-                    summary += e.delta;
-                    if (summaryBytes + Buffer.byteLength(summary) > 4096)
-                        throw Error('reasoning summary byte bound');
-                }
-                else if (kind === 'response.reasoning_summary_text.done' && summaryPhase === 1 && e.text === summary)
-                    summaryPhase = 2;
-                else if (kind === 'response.reasoning_summary_part.done' && summaryPhase === 2 && e.part.text === summary) {
-                    summaries.push({ type: 'summary_text', text: summary });
-                    summaryBytes += Buffer.byteLength(summary);
-                    summary = '';
-                    summaryPhase = 0;
-                }
-                else
-                    throw Error('unsupported or reordered reasoning event');
-            }
-        }
-        else if (e.type === 'response.output_item.added' && phase === 1) {
-            itemId = e.item?.id;
-            if (typeof itemId !== 'string' || !itemId || itemId === reasoningId || itemId.length > 128 || e.output_index !== answerIndex || e.item.type !== 'message' || e.item.role !== 'assistant' || e.item.status !== 'in_progress' || !isDeepStrictEqual(e.item.content, []))
-                throw Error('unsupported output item');
-            phase = 2;
-        }
-        else if (e.type === 'response.content_part.added' && phase === 2 && !partOpen && !textDone) {
-            if (e.item_id !== itemId || e.output_index !== answerIndex || e.content_index !== 0 || e.part?.type !== 'output_text' || e.part.text !== '')
-                throw Error('content part correlation');
-            partOpen = true;
-        }
-        else if (e.type === 'response.output_text.done' && phase === 2 && !textDone) {
-            if (e.item_id !== itemId || e.output_index !== answerIndex || e.content_index !== 0 || e.text !== output)
-                throw Error('text completion mismatch');
-            textDone = true;
-        }
-        else if (e.type === 'response.content_part.done' && phase === 2 && partOpen && !partDone && textDone) {
-            if (e.item_id !== itemId || e.output_index !== answerIndex || e.content_index !== 0 || e.part?.type !== 'output_text' || e.part.text !== output)
-                throw Error('content part completion mismatch');
-            partDone = true;
-        }
-        else if (e.type === 'response.output_text.delta' && phase === 2 && !textDone) {
-            if (e.item_id !== itemId || e.output_index !== answerIndex || e.content_index !== 0 || typeof e.delta !== 'string')
-                throw Error('delta correlation');
-            output += e.delta;
-        }
-        else if (e.type === 'response.output_item.done' && phase === 2) {
-            if (reasoningItem && !(partOpen && partDone && textDone) || partOpen && !partDone || e.output_index !== answerIndex || e.item?.id !== itemId || e.item.type !== 'message' || e.item.role !== 'assistant' || e.item.status !== 'completed' || !Array.isArray(e.item.content) || e.item.content.length !== 1 || e.item.content[0].type !== 'output_text' || e.item.content[0].text !== output)
-                throw Error('completed item mismatch');
-            completedItem = e.item;
-            phase = 3;
-        }
-        else if (e.type === 'response.completed' && phase === 3) {
-            // Compact terminals omit duplicated items, not their preceding completion evidence.
-            const terminal = e.response?.output, compact = Array.isArray(terminal) && terminal.length === 0 && partOpen && partDone && textDone;
-            if (e.response?.id !== responseId || e.response.model !== model || e.response.status !== 'completed' || !Array.isArray(terminal) || (!compact && !isDeepStrictEqual(terminal, reasoningItem ? [reasoningItem, completedItem] : [completedItem])))
-                throw Error('completed response mismatch');
-            phase = 4;
-        }
-        else
-            throw Error('unsupported or reordered SSE event');
-    }
-    if (phase !== 4)
-        throw Error('truncated SSE response');
-    return { text: output, responseId, reasoning: reasoningItem ? { item: reasoningItem, sdkText: summaries.map(p => p.text).join('\n\n') || '\n\n'.repeat(summaries.length) } : undefined };
-}
-export function inertCodexSdkStreams(binding, fixture, record) {
-    return sdkStreams(binding, async () => fixture(), record, 'inert-sdk-fetch');
-}
-export function boundCodexSdkStreams(binding, transport, record, caps) {
-    if (!['fixture-http', 'subscription-http'].includes(transport.kind) || ![caps.requestBytes, caps.responseBytes].every(n => Number.isSafeInteger(n) && n > 0) || caps.requestBytes > 4096 || caps.responseBytes > 16384)
-        throw Error('unsupported SDK transport binding');
-    return sdkStreams(binding, transport.exchange, record, transport.kind, caps);
-}
-/** Separate review request profile; historical exact-output transport retains its 4096-byte cap. */
-export function boundCodexReviewSdkStreams(binding, transport, record, caps) {
-    if (!['fixture-http', 'subscription-http'].includes(transport.kind) || ![caps.requestBytes, caps.responseBytes].every(n => Number.isSafeInteger(n) && n > 0) || caps.requestBytes > 65536 || caps.responseBytes > 262144)
-        throw Error('unsupported review SDK transport binding');
-    return sdkStreams(binding, transport.exchange, record, transport.kind, caps);
-}
-function sdkStreams(binding, send, record, mode, caps = { requestBytes: 4096, responseBytes: 16384 }) {
-    const response = new PassThrough(), controller = new AbortController();
-    let started = false;
-    const transport = new Writable({ autoDestroy: false, write(chunk, _encoding, done) {
-            void (async () => {
-                if (started)
-                    throw Error('SDK transport single use; no retry');
-                started = true;
-                const expected = JSON.parse(Buffer.from(chunk).toString('utf8')), model = binding.model;
-                if (model.id !== expected.model || model.provider !== 'openai-codex' || model.api !== 'openai-codex-responses' || model.baseUrl !== 'https://chatgpt.com/backend-api')
-                    throw Error('SDK model binding mismatch');
-                let fetches = 0, expectedOutput, profile;
-                const result = await binding.stream(model, { systemPrompt: expected.instructions, messages: [{ role: 'user', content: expected.input[0].content[0].text, timestamp: 0 }] }, { apiKey: fixtureCredential, transport: 'sse', maxRetries: 0, cacheRetention: 'none', reasoningEffort: expected.reasoning.effort, reasoningSummary: 'auto', textVerbosity: 'low', toolChoice: 'none', timeoutMs: 30000, signal: controller.signal,
-                    onPayload: (payload) => { const normalized = { ...payload, parallel_tool_calls: false }; if (!isDeepStrictEqual(JSON.parse(JSON.stringify(normalized)), expected))
-                        throw Error('SDK request settings tampered'); return normalized; },
-                    fetch: async (url, init) => {
-                        if (++fetches !== 1)
-                            throw Error('SDK retry refused');
-                        if (url !== destination || init.method !== 'POST' || init.redirect && init.redirect !== 'error' || controller.signal.aborted)
-                            throw Error('SDK destination/redirect refused');
-                        const wire = typeof init.body === 'string' ? Buffer.from(init.body) : init.body instanceof Uint8Array ? Buffer.from(init.body) : null;
-                        if (!wire || wire.length > (mode === 'inert-sdk-fetch' ? 16384 : caps.requestBytes))
-                            throw Error('SDK wire byte bound');
-                        const encoding = new Headers(init.headers).get('content-encoding');
-                        if (encoding !== null && encoding !== 'zstd')
-                            throw Error('unsupported request encoding');
-                        if (encoding === 'zstd' && typeof zlib.zstdDecompressSync !== 'function')
-                            throw Error('zstd decoding unavailable');
-                        const serialized = encoding === 'zstd' ? Buffer.from(zlib.zstdDecompressSync(wire, { maxOutputLength: caps.requestBytes })) : wire;
-                        if (serialized.length > caps.requestBytes || !isDeepStrictEqual(JSON.parse(new TextDecoder('utf8', { fatal: true }).decode(serialized)), expected))
-                            throw Error('SDK final request tampered');
-                        record({ type: 'sdk-wire-observed', requestSha256: hash(chunk), serializedSha256: hash(serialized), serializedBase64: serialized.toString('base64'), wireBase64: wire.toString('base64'), wireSha256: hash(wire), encoding, destination, method: 'POST', authenticationHeadersRetained: false, transport: mode, networkCalls: mode === 'subscription-http' ? null : 0, liveQualified: false });
-                        const reply = await send({ destination, method: 'POST', body: wire, encoding }, controller.signal, value => { if (!['http-request-started', 'http-response-observed', 'http-request-failed'].includes(String(value.type)))
-                            throw Error('unbound transport observation'); record({ ...value, transport: mode, liveQualified: false }); });
-                        if (controller.signal.aborted)
-                            throw Error('SDK response deadline');
-                        if (reply.redirected || reply.status >= 300 && reply.status < 400)
-                            throw Error('fixture redirects refused');
-                        if (!reply.body)
-                            throw Error('missing response body');
-                        const reader = reply.body.getReader(), parts = [];
-                        let size = 0, cancellationError;
-                        const abort = () => { void reader.cancel().catch(error => { cancellationError = error; }); };
-                        controller.signal.addEventListener('abort', abort, { once: true });
-                        try {
-                            for (;;) {
-                                if (controller.signal.aborted)
-                                    throw Error('SDK response deadline');
-                                const next = await reader.read();
-                                if (next.done)
-                                    break;
-                                size += next.value.length;
-                                if (size > caps.responseBytes)
-                                    throw Error('SDK response byte bound');
-                                parts.push(Buffer.from(next.value));
-                            }
-                        }
-                        finally {
-                            controller.signal.removeEventListener('abort', abort);
-                            await reader.cancel();
-                            reader.releaseLock();
-                        }
-                        if (cancellationError || controller.signal.aborted)
-                            throw Error('SDK response cancellation failed or deadline expired');
-                        const raw = Buffer.concat(parts);
-                        record({ type: 'sdk-response-observed', status: reply.status, responseBase64: raw.toString('base64'), responseSha256: hash(raw), liveQualified: false });
-                        let decoderBody = raw;
-                        const decoderHeaders = new Headers(reply.headers);
-                        if (reply.ok) {
-                            const contentType = reply.headers.get('content-type'), mediaType = contentType === null || contentType === '' ? 'missing' : contentType.startsWith('text/event-stream') ? 'event-stream' : 'other';
-                            let category = 'media-type-invalid';
-                            try {
-                                if (mediaType === 'other' || mediaType === 'missing' && reply.status !== 200)
-                                    throw Error('unsupported response content type');
-                                category = 'SSE-validation-failed';
-                                const validated = validateResponseProfile(raw, expected.model);
-                                profile = validated;
-                                expectedOutput = validated.text;
-                                decoderBody = Buffer.from(new TextDecoder('utf8', { fatal: true }).decode(raw).replace(/\r\n/g, '\n'));
-                                // Only HTTP200 + validated, correlated model-bound text may supply a missing
-                                // decoder media type. Preserve reply.headers; this is not an upstream header claim.
-                                if (mediaType === 'missing')
-                                    decoderHeaders.set('content-type', 'text/event-stream');
-                                category = 'validation-record-failed';
-                                record({ type: 'sdk-response-validated', responseId: validated.responseId, decoderInputSha256: hash(decoderBody), decoderNormalization: 'SSE CRLF to LF; original response retained', originalMediaType: mediaType, decoderMediaType: 'event-stream', mediaTypeDerived: mediaType === 'missing', profile: validated.reasoning ? 'reasoning-plus-text' : 'text-only', liveQualified: false });
-                            }
-                            catch (error) {
-                                // Diagnostic persistence is best effort only; it must never replace the initiating
-                                // exception or turn a refused response into success. No raw header/body/error text.
-                                try {
-                                    record({ type: 'sdk-response-failed', category, mediaType, liveQualified: false });
-                                }
-                                catch { /* Original error remains authoritative even when this recorder also fails. */ }
-                                throw error;
-                            }
-                        }
-                        return new Response(decoderBody, { status: reply.status, headers: decoderHeaders });
-                    } }).result();
-                let contentMatches = false;
-                if (profile?.reasoning) {
-                    const blocks = result.content, thinking = blocks?.[0];
-                    if (blocks?.length === 2 && thinking.type === 'thinking' && thinking.thinking === profile.reasoning.sdkText && typeof thinking.thinkingSignature === 'string' && Buffer.byteLength(thinking.thinkingSignature) <= 16384 && blocks[1].type === 'text' && blocks[1].text === expectedOutput && result.responseId === profile.responseId) {
-                        try {
-                            contentMatches = isDeepStrictEqual(JSON.parse(thinking.thinkingSignature), profile.reasoning.item);
-                        }
-                        catch { /* Malformed private SDK signature is a mismatch, never logged or decoded as ciphertext. */ }
-                    }
-                }
-                else
-                    contentMatches = result.content?.length === 1 && result.content[0].type === 'text' && result.content[0].text === expectedOutput;
-                if (controller.signal.aborted || fetches !== 1 || result.stopReason !== 'stop' || result.model !== expected.model || result.provider !== 'openai-codex' || result.api !== 'openai-codex-responses' || !contentMatches)
-                    throw Error(mode === 'inert-sdk-fetch' ? 'SDK response decoding failed: ' + String(result.errorMessage ?? 'decoded output mismatch').slice(0, 512) : 'subscription-exchange-failed');
-                record({ type: 'sdk-decoded', outputSha256: hash(expectedOutput), model: result.model, provider: result.provider, api: result.api, scoredContent: 'final-text-only', thinkingMetadataVerified: !!profile?.reasoning, providerInternalFacts: null, transport: mode, liveQualified: false });
-                response.end(expectedOutput);
-                done();
-            })().catch(e => done(e instanceof Error ? e : Error(String(e))));
-        }, destroy(error, done) { controller.abort(); response.destroy(); done(error); } });
-    return { transport, response };
-}
-//# sourceMappingURL=codex-sdk-transport.js.map