@harapter/adapter-codex 0.1.1

package/dist/adapter.js

@@ -0,0 +1,1033 @@
+import { spawn } from 'node:child_process';
+import { ExtensionRegistry, HarnessError, assertSessionCompatibility, assertSessionOwnership, providerSessionId, runId, } from '@harapter/core';
+import { JsonRpcRemoteError, JsonRpcStdioTransport, JsonRpcTransportError, } from '@harapter/transport-jsonrpc-stdio';
+import { CODEX_PROVIDER_ID, CODEX_SESSION_COMPATIBILITY_REF, codexCompatibilityIdentity, encodeCodexInteractionResponse, mapCodexNotification, mapCodexServerRequest, parseCodexInitializeResponse, parseCodexThreadResponse, parseCodexTurnStartResponse, prepareCodexInput, prepareCodexSessionParams, prepareCodexTurnParams, redactCodexEvent, } from './protocol.js';
+const descriptor = {
+    providerId: CODEX_PROVIDER_ID,
+    displayName: 'Codex App Server',
+    connectionKinds: ['process'],
+    documentationUrl: 'https://developers.openai.com/codex/app-server',
+};
+const defaultMaxRunEvents = 128;
+const defaultCancelSettlementTimeoutMs = 10_000;
+const childTerminationTimeoutMs = 2_000;
+const maximumTimerMilliseconds = 2_147_483_647;
+/** Create a fresh Codex App Server Adapter factory. */
+export function createCodexProviderFactory() {
+    return {
+        descriptor: () => ({
+            ...descriptor,
+            connectionKinds: [...descriptor.connectionKinds],
+        }),
+        connect: async (profile) => connectCodex(profile),
+    };
+}
+async function connectCodex(profile) {
+    validateProfile(profile);
+    const options = connectionOptions(profile.providerOptions);
+    let transport;
+    try {
+        transport = await spawnTransport(profile, options.transport);
+    }
+    catch (error) {
+        throw mapError(error, profile, 'spawn', true);
+    }
+    try {
+        const initialize = await transport.request('initialize', {
+            clientInfo: {
+                name: 'harapter',
+                title: 'Harapter',
+                version: '0.0.0',
+            },
+            capabilities: {
+                experimentalApi: false,
+                requestAttestation: false,
+            },
+        });
+        const runtime = parseCodexInitializeResponse(initialize);
+        await transport.notify('initialized');
+        return new CodexClient(snapshotProfile(profile), transport, runtime, options.cancelSettlementTimeoutMs, options.maxRunEvents);
+    }
+    catch (error) {
+        await transport.close().catch(() => undefined);
+        throw mapError(error, profile, 'initialize', true);
+    }
+}
+class CodexClient {
+    profile;
+    transport;
+    runtime;
+    cancelSettlementTimeoutMs;
+    maxRunEvents;
+    activeByThread = new Map();
+    activeByTurn = new Map();
+    ephemeralThreads = new Set();
+    extensionRegistry = new ExtensionRegistry(CODEX_PROVIDER_ID);
+    nativeClient;
+    pendingByLocalId = new Map();
+    pendingByWireKey = new Map();
+    seenTurnIds = new Set();
+    startingByThread = new Map();
+    unknownListeners = new Set();
+    closePromise;
+    closed = false;
+    interactionSerial = 0;
+    runSerial = 0;
+    constructor(profile, transport, runtime, cancelSettlementTimeoutMs, maxRunEvents) {
+        this.profile = profile;
+        this.transport = transport;
+        this.runtime = runtime;
+        this.cancelSettlementTimeoutMs = cancelSettlementTimeoutMs;
+        this.maxRunEvents = maxRunEvents;
+        this.nativeClient = Object.freeze({
+            runtimeIdentity: this.runtimeIdentity(),
+            request: (method, params, options) => this.nativeRequest(method, params, options),
+            notify: (method, params) => this.nativeNotify(method, params),
+            onUnknownEvent: (listener) => {
+                this.unknownListeners.add(listener);
+                return () => {
+                    this.unknownListeners.delete(listener);
+                };
+            },
+        });
+        void this.pump().catch(() => undefined);
+    }
+    descriptor() {
+        return Promise.resolve({
+            providerId: CODEX_PROVIDER_ID,
+            profileId: this.profile.profileId,
+            displayName: this.profile.displayName,
+            connectionKind: 'process',
+            runtime: {
+                name: 'Codex App Server',
+                version: this.runtime.runtimeVersion,
+                protocol: 'JSONL RPC',
+                protocolVersion: 'stable',
+            },
+            compatibility: 'supported',
+        });
+    }
+    capabilities() {
+        return Promise.resolve(codexCapabilities(this.profile, this.runtimeIdentity()));
+    }
+    async createSession(input = {}) {
+        this.assertOpen();
+        const params = prepareCodexSessionParams(input);
+        try {
+            const response = await this.transport.request('thread/start', params);
+            const threadId = parseCodexThreadResponse(response);
+            if (params['ephemeral'] === true)
+                this.ephemeralThreads.add(threadId);
+            return new CodexSession(this, providerSessionId(threadId), params['ephemeral'] !== true);
+        }
+        catch (error) {
+            throw mapError(error, this.profile, 'thread/start', false, this.transport);
+        }
+    }
+    async resumeSession(ref) {
+        this.assertOpen();
+        assertSessionOwnership(ref, CODEX_PROVIDER_ID, this.profile.profileId);
+        if (this.ephemeralThreads.has(ref.providerSessionId) ||
+            isEphemeralSessionRef(ref)) {
+            throw new HarnessError('unsupported_capability', 'An ephemeral Codex Thread cannot be resumed.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.profile.profileId,
+                details: { capability: 'session.resume' },
+            });
+        }
+        assertSessionCompatibility(ref, CODEX_SESSION_COMPATIBILITY_REF);
+        try {
+            const response = await this.transport.request('thread/resume', {
+                threadId: ref.providerSessionId,
+            });
+            const threadId = parseCodexThreadResponse(response);
+            if (threadId !== ref.providerSessionId) {
+                throw new HarnessError('session_provider_mismatch', 'Codex resumed a different Thread than requested.', {
+                    retryable: false,
+                    providerId: CODEX_PROVIDER_ID,
+                    profileId: this.profile.profileId,
+                });
+            }
+            return new CodexSession(this, providerSessionId(threadId), true);
+        }
+        catch (error) {
+            throw mapError(error, this.profile, 'thread/resume', false, this.transport);
+        }
+    }
+    extensions() {
+        return this.extensionRegistry;
+    }
+    native(guard) {
+        const value = this.nativeClient;
+        return guard !== undefined && !guard(value) ? undefined : value;
+    }
+    close() {
+        this.closePromise ??= this.closeOnce();
+        return this.closePromise;
+    }
+    sessionRef(sessionId, resumable) {
+        return {
+            providerId: CODEX_PROVIDER_ID,
+            profileId: this.profile.profileId,
+            providerSessionId: sessionId,
+            compatibilityRef: CODEX_SESSION_COMPATIBILITY_REF,
+            providerState: {
+                createdRuntimeVersion: this.runtime.runtimeVersion,
+                ...(resumable ? {} : { ephemeral: true }),
+            },
+        };
+    }
+    capabilityManifest(resumable = true) {
+        return codexCapabilities(this.profile, this.runtimeIdentity(), resumable);
+    }
+    hasActiveRun(threadId) {
+        return (this.activeByThread.has(threadId) || this.startingByThread.has(threadId));
+    }
+    async startRun(sessionId, input, options = {}) {
+        this.assertOpen();
+        if (this.hasActiveRun(sessionId)) {
+            throw new HarnessError('run_conflict', 'Codex Thread already has an active Turn.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+        const nativeInput = prepareCodexInput(input);
+        const overrides = prepareCodexTurnParams(options);
+        const starting = createStartingRun();
+        this.startingByThread.set(sessionId, starting);
+        try {
+            const response = await this.transport.request('turn/start', {
+                threadId: sessionId,
+                input: nativeInput,
+                ...overrides,
+            });
+            const turnId = parseCodexTurnStartResponse(response);
+            if (this.seenTurnIds.has(turnId)) {
+                this.abortConnection();
+                throw new HarnessError('provider_api_incompatible', 'Codex reused a Turn identifier on one connection.', {
+                    retryable: false,
+                    providerId: CODEX_PROVIDER_ID,
+                    profileId: this.profile.profileId,
+                });
+            }
+            this.seenTurnIds.add(turnId);
+            const run = new CodexRun({
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.profile.profileId,
+                sessionId,
+                runId: runId(`codex-run-${String(++this.runSerial)}`),
+                providerRunId: turnId,
+            }, turnId, this.maxRunEvents, this.cancelSettlementTimeoutMs, options.timeoutMs, (activeRun) => this.interrupt(activeRun), () => {
+                this.abortConnection();
+            }, (activeRun) => {
+                this.onRunTerminal(activeRun);
+            });
+            this.activeByThread.set(sessionId, run);
+            this.activeByTurn.set(turnId, run);
+            starting.resolve(run);
+            return run;
+        }
+        catch (error) {
+            starting.resolve(undefined);
+            throw mapError(error, this.profile, 'turn/start', false, this.transport);
+        }
+        finally {
+            if (this.startingByThread.get(sessionId) === starting) {
+                this.startingByThread.delete(sessionId);
+            }
+        }
+    }
+    async respond(sessionId, requestId, response) {
+        this.assertOpen();
+        const pending = this.pendingByLocalId.get(requestId);
+        if (pending?.run.ref().sessionId !== sessionId ||
+            pending.run.isTerminal()) {
+            throw new HarnessError('invalid_request', 'The Codex interaction is no longer pending for this Session.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+        const result = encodeCodexInteractionResponse(pending.request, response);
+        try {
+            await this.transport.respond(pending.wireId, result);
+            this.settlePending(pending, 'host');
+        }
+        catch (error) {
+            throw mapError(error, this.profile, 'interaction/respond', false, this.transport);
+        }
+    }
+    async pump() {
+        try {
+            for await (const message of this.transport.incoming()) {
+                if (message.kind === 'request')
+                    await this.handleRequest(message);
+                else
+                    await this.handleNotification(message.method, message.params);
+            }
+        }
+        catch {
+            if (!this.closed)
+                this.abortConnection();
+        }
+    }
+    async handleRequest(message) {
+        const requestId = `codex-interaction-${String(++this.interactionSerial)}`;
+        const mapped = mapCodexServerRequest(message.method, message.params, requestId);
+        const run = await this.routeWhenStarted(mapped.threadId, mapped.turnId);
+        if (run === undefined) {
+            this.emitUnknown(redactCodexEvent(message.method, message.params));
+            await this.transport.respondError(message.id, {
+                code: -32_601,
+                message: 'Harapter has no active Run for this request.',
+            });
+            return;
+        }
+        const pending = {
+            wireId: message.id,
+            wireKey: wireKey(message.id),
+            request: mapped,
+            run,
+        };
+        this.pendingByLocalId.set(mapped.interaction.requestId, pending);
+        this.pendingByWireKey.set(pending.wireKey, pending);
+        run.emit({ type: 'interaction.requested', data: mapped.interaction });
+    }
+    async handleNotification(method, params) {
+        if (method === 'serverRequest/resolved') {
+            const requestId = requestIdFromResolved(params);
+            const pending = requestId === undefined
+                ? undefined
+                : this.pendingByWireKey.get(wireKey(requestId));
+            if (pending !== undefined) {
+                this.settlePending(pending, 'provider', true);
+            }
+            else {
+                this.emitUnknown(redactCodexEvent(method, params));
+            }
+            return;
+        }
+        const mapping = mapCodexNotification(method, params);
+        const run = await this.routeWhenStarted(mapping.threadId, mapping.turnId);
+        if (run === undefined) {
+            let observed = false;
+            for (const event of mapping.events) {
+                if (event.raw === undefined)
+                    continue;
+                observed = true;
+                this.emitUnknown(event.raw);
+            }
+            if (!observed && mapping.turnId !== undefined) {
+                this.emitUnknown(redactCodexEvent(method, params));
+            }
+            return;
+        }
+        if (method === 'turn/started')
+            run.confirmProviderStart();
+        for (const event of mapping.events) {
+            if (event.raw !== undefined)
+                this.emitUnknown(event.raw);
+        }
+        if (mapping.events.some(({ terminalResult }) => terminalResult !== undefined)) {
+            this.resolvePendingForRun(run, 'turn_terminal');
+        }
+        for (const event of mapping.events)
+            run.emit(event);
+    }
+    route(threadId, turnId) {
+        if (turnId === undefined)
+            return undefined;
+        const byTurn = this.activeByTurn.get(turnId);
+        if (byTurn !== undefined &&
+            (threadId === undefined || byTurn.ref().sessionId === threadId)) {
+            return byTurn;
+        }
+        return undefined;
+    }
+    async routeWhenStarted(threadId, turnId) {
+        const active = this.route(threadId, turnId);
+        if (active !== undefined || threadId === undefined)
+            return active;
+        const starting = this.startingByThread.get(threadId);
+        if (starting === undefined)
+            return undefined;
+        await starting.promise;
+        return this.route(threadId, turnId);
+    }
+    async interrupt(run) {
+        this.assertOpen();
+        try {
+            await this.transport.request('turn/interrupt', {
+                threadId: run.ref().sessionId,
+                turnId: run.turnId,
+            });
+        }
+        catch (error) {
+            throw mapError(error, this.profile, 'turn/interrupt', false, this.transport);
+        }
+    }
+    onRunTerminal(run) {
+        const reference = run.ref();
+        if (this.activeByThread.get(reference.sessionId) === run) {
+            this.activeByThread.delete(reference.sessionId);
+        }
+        if (this.activeByTurn.get(run.turnId) === run) {
+            this.activeByTurn.delete(run.turnId);
+        }
+        this.resolvePendingForRun(run, 'turn_terminal');
+    }
+    resolvePendingForRun(run, resolution) {
+        for (const pending of [...this.pendingByLocalId.values()]) {
+            if (pending.run !== run)
+                continue;
+            this.settlePending(pending, resolution, true);
+        }
+    }
+    settlePending(pending, resolution, abandonWire = false) {
+        if (this.pendingByLocalId.get(pending.request.interaction.requestId) !==
+            pending) {
+            return;
+        }
+        if (abandonWire)
+            this.transport.abandonInboundRequest(pending.wireId);
+        this.removePending(pending);
+        pending.run.emit({
+            type: 'interaction.resolved',
+            data: {
+                requestId: pending.request.interaction.requestId,
+                resolution,
+            },
+        });
+    }
+    removePending(pending) {
+        this.pendingByLocalId.delete(pending.request.interaction.requestId);
+        this.pendingByWireKey.delete(pending.wireKey);
+    }
+    emitUnknown(event) {
+        for (const listener of [...this.unknownListeners]) {
+            try {
+                listener(structuredClone(event));
+            }
+            catch {
+                // Native observers cannot break Provider lifecycle processing.
+            }
+        }
+    }
+    nativeRequest(method, params, options = {}) {
+        this.assertOpen();
+        return this.transport.request(method, params, options);
+    }
+    nativeNotify(method, params) {
+        this.assertOpen();
+        return this.transport.notify(method, params);
+    }
+    abortConnection() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const run of [...this.activeByTurn.values()]) {
+            this.resolvePendingForRun(run, 'connection_aborted');
+            run.abortConnection();
+        }
+        this.pendingByLocalId.clear();
+        this.pendingByWireKey.clear();
+        void this.transport.close().catch(() => undefined);
+    }
+    async closeOnce() {
+        if (!this.closed) {
+            this.closed = true;
+            for (const run of [...this.activeByTurn.values()]) {
+                this.resolvePendingForRun(run, 'connection_aborted');
+                run.abortConnection();
+            }
+            this.pendingByLocalId.clear();
+            this.pendingByWireKey.clear();
+        }
+        try {
+            await this.transport.close();
+        }
+        catch (error) {
+            throw mapError(error, this.profile, 'close', false, this.transport);
+        }
+    }
+    runtimeIdentity() {
+        return codexCompatibilityIdentity(this.runtime.runtimeVersion);
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new HarnessError('connection_aborted', 'Codex App Server is closed.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+    }
+}
+class CodexSession {
+    client;
+    sessionId;
+    resumable;
+    closed = false;
+    constructor(client, sessionId, resumable) {
+        this.client = client;
+        this.sessionId = sessionId;
+        this.resumable = resumable;
+    }
+    ref() {
+        return this.client.sessionRef(this.sessionId, this.resumable);
+    }
+    capabilities() {
+        return Promise.resolve(this.client.capabilityManifest(this.resumable));
+    }
+    start(input, options) {
+        this.assertOpen();
+        return this.client.startRun(this.sessionId, input, options);
+    }
+    respond(requestId, response) {
+        this.assertOpen();
+        return this.client.respond(this.sessionId, requestId, response);
+    }
+    close() {
+        if (this.closed)
+            return Promise.resolve();
+        if (this.client.hasActiveRun(this.sessionId)) {
+            return Promise.reject(new HarnessError('run_conflict', 'Cannot close a Codex Session with an active Run.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.ref().profileId,
+            }));
+        }
+        this.closed = true;
+        return Promise.resolve();
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new HarnessError('session_not_found', 'Codex Session is closed.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+                profileId: this.ref().profileId,
+            });
+        }
+    }
+}
+class CodexRun {
+    reference;
+    turnId;
+    cancelSettlementTimeoutMs;
+    interrupt;
+    abortOwnerConnection;
+    onTerminal;
+    eventQueue;
+    providerStart;
+    settlement;
+    timeout;
+    cancelPromise;
+    finalMessage;
+    finalResult;
+    resolveProviderStart;
+    resolveSettlement;
+    sequence = 0;
+    timeoutTriggered = false;
+    usage;
+    constructor(reference, turnId, maxRunEvents, cancelSettlementTimeoutMs, timeoutMs, interrupt, abortOwnerConnection, onTerminal) {
+        this.reference = reference;
+        this.turnId = turnId;
+        this.cancelSettlementTimeoutMs = cancelSettlementTimeoutMs;
+        this.interrupt = interrupt;
+        this.abortOwnerConnection = abortOwnerConnection;
+        this.onTerminal = onTerminal;
+        this.eventQueue = new EventQueue(maxRunEvents);
+        this.providerStart = new Promise((resolve) => {
+            this.resolveProviderStart = resolve;
+        });
+        this.settlement = new Promise((resolve) => {
+            this.resolveSettlement = resolve;
+        });
+        this.timeout =
+            timeoutMs === undefined
+                ? undefined
+                : setTimeout(() => {
+                    this.timeoutTriggered = true;
+                    void this.cancel().catch(() => {
+                        this.abortOwnerConnection();
+                    });
+                }, timeoutMs);
+        this.timeout?.unref();
+        this.emit({ type: 'run.started', data: {} });
+    }
+    ref() {
+        return { ...this.reference };
+    }
+    events() {
+        return this.eventQueue.iterable();
+    }
+    cancel() {
+        if (this.isTerminal())
+            return Promise.resolve({ mode: 'already_terminal' });
+        this.cancelPromise ??= this.cancelOnce();
+        return this.cancelPromise;
+    }
+    result() {
+        return this.settlement;
+    }
+    isTerminal() {
+        return this.finalResult !== undefined;
+    }
+    confirmProviderStart() {
+        if (!this.isTerminal())
+            this.resolveProviderStart(true);
+    }
+    emit(mapped) {
+        if (this.isTerminal())
+            return;
+        if (mapped.finalMessage !== undefined)
+            this.finalMessage = mapped.finalMessage;
+        if (mapped.usage !== undefined)
+            this.usage = mapped.usage;
+        if (mapped.terminalResult !== undefined) {
+            const result = {
+                ...mapped.terminalResult,
+                ...(mapped.terminalResult.status === 'completed' &&
+                    this.finalMessage !== undefined
+                    ? { finalMessage: this.finalMessage }
+                    : {}),
+                ...(this.usage === undefined ? {} : { usage: this.usage }),
+                ...(this.timeoutTriggered &&
+                    mapped.terminalResult.status === 'cancelled'
+                    ? { providerResult: { reason: 'timeout' } }
+                    : {}),
+            };
+            this.finish(result, mapped.type, {
+                ...mapped,
+                data: result,
+            });
+            return;
+        }
+        const event = this.portableEvent(mapped);
+        if (!this.eventQueue.push(event))
+            this.abortOwnerConnection();
+    }
+    abortConnection() {
+        if (this.isTerminal())
+            return;
+        const result = { status: 'connection_aborted' };
+        this.finish(result, 'connection.aborted', {
+            type: 'connection.aborted',
+            data: result,
+        });
+    }
+    async cancelOnce() {
+        const watchdog = setTimeout(() => {
+            this.abortOwnerConnection();
+        }, this.cancelSettlementTimeoutMs);
+        watchdog.unref();
+        try {
+            const providerStarted = await this.providerStart;
+            let interruptAcknowledged = false;
+            if (providerStarted && !this.isTerminal()) {
+                try {
+                    await this.interrupt(this);
+                }
+                catch (error) {
+                    if (this.finalResult?.status === 'connection_aborted')
+                        return { mode: 'connection_aborted' };
+                    throw error;
+                }
+                interruptAcknowledged = true;
+            }
+            const result = await this.settlement;
+            if (result.status === 'cancelled' && interruptAcknowledged)
+                return { mode: 'native' };
+            return result.status === 'connection_aborted'
+                ? { mode: 'connection_aborted' }
+                : { mode: 'already_terminal' };
+        }
+        finally {
+            clearTimeout(watchdog);
+        }
+    }
+    finish(result, terminalType, mapped) {
+        if (this.isTerminal())
+            return;
+        this.finalResult = result;
+        this.resolveProviderStart(false);
+        if (this.timeout !== undefined)
+            clearTimeout(this.timeout);
+        this.eventQueue.pushTerminal(this.portableEvent({ ...mapped, type: terminalType, data: result }));
+        this.eventQueue.close();
+        this.onTerminal(this);
+        this.resolveSettlement(result);
+    }
+    portableEvent(mapped) {
+        const sequence = this.sequence++;
+        return {
+            id: `${this.reference.runId}:event:${String(sequence)}`,
+            type: mapped.type,
+            providerId: this.reference.providerId,
+            profileId: this.reference.profileId,
+            sessionId: this.reference.sessionId,
+            runId: this.reference.runId,
+            sequence,
+            timestamp: new Date().toISOString(),
+            data: mapped.data,
+            ...(mapped.providerEventType === undefined
+                ? {}
+                : { providerEventType: mapped.providerEventType }),
+            ...(mapped.raw === undefined ? {} : { raw: mapped.raw }),
+        };
+    }
+}
+class EventQueue {
+    capacity;
+    values = [];
+    closed = false;
+    consumed = false;
+    waiter;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    push(event) {
+        if (this.closed)
+            return false;
+        if (this.waiter !== undefined) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter({ done: false, value: event });
+            return true;
+        }
+        if (this.values.length >= this.capacity - 1)
+            return false;
+        this.values.push(event);
+        return true;
+    }
+    pushTerminal(event) {
+        if (this.waiter !== undefined) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter({ done: false, value: event });
+            return;
+        }
+        this.values.push(event);
+    }
+    close() {
+        this.closed = true;
+    }
+    iterable() {
+        if (this.consumed) {
+            return {
+                [Symbol.asyncIterator]: () => ({
+                    next: () => Promise.reject(new HarnessError('run_conflict', 'Codex Run events already have a consumer.', { retryable: false, providerId: CODEX_PROVIDER_ID })),
+                }),
+            };
+        }
+        this.consumed = true;
+        return {
+            [Symbol.asyncIterator]: () => ({
+                next: () => this.next(),
+            }),
+        };
+    }
+    next() {
+        const event = this.values.shift();
+        if (event !== undefined)
+            return Promise.resolve({ done: false, value: event });
+        if (this.closed)
+            return Promise.resolve({ done: true, value: undefined });
+        if (this.waiter !== undefined) {
+            return Promise.reject(new HarnessError('run_conflict', 'A Codex event read is already pending.', {
+                retryable: false,
+                providerId: CODEX_PROVIDER_ID,
+            }));
+        }
+        return new Promise((resolve) => {
+            this.waiter = resolve;
+        });
+    }
+}
+async function spawnTransport(profile, options) {
+    if (profile.connection.kind !== 'process')
+        throw profileInvalid(profile);
+    const child = spawn(profile.connection.command, [...(profile.connection.args ?? [])], {
+        cwd: profile.connection.cwd,
+        shell: false,
+        stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    await processStarted(child);
+    try {
+        return new JsonRpcStdioTransport({
+            ...options,
+            readable: child.stdout,
+            writable: child.stdin,
+            cleanup: () => terminateChild(child),
+        });
+    }
+    catch (error) {
+        await terminateChild(child);
+        throw error;
+    }
+}
+function processStarted(child) {
+    return new Promise((resolve, reject) => {
+        const onSpawn = () => {
+            child.off('error', onError);
+            child.on('error', () => undefined);
+            resolve();
+        };
+        const onError = (error) => {
+            child.off('spawn', onSpawn);
+            reject(error);
+        };
+        child.once('spawn', onSpawn);
+        child.once('error', onError);
+    });
+}
+async function terminateChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    child.kill();
+    if (await waitForChildExit(child, childTerminationTimeoutMs))
+        return;
+    child.kill('SIGKILL');
+    if (await waitForChildExit(child, childTerminationTimeoutMs))
+        return;
+    throw new Error('Codex child process did not exit after forced termination.');
+}
+function waitForChildExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const onExit = () => {
+            finish(true);
+        };
+        const timer = setTimeout(() => {
+            finish(false);
+        }, timeoutMs);
+        function finish(exited) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.off('exit', onExit);
+            resolve(exited);
+        }
+        child.once('exit', onExit);
+        if (child.exitCode !== null || child.signalCode !== null)
+            finish(true);
+    });
+}
+function codexCapabilities(profile, runtimeIdentity, resumable = true) {
+    const native = { mode: 'native', source: 'schema' };
+    const unsupported = {
+        mode: 'unsupported',
+        source: 'schema',
+    };
+    const sessionResume = resumable
+        ? native
+        : {
+            mode: 'unsupported',
+            reason: 'Ephemeral Codex Threads are not persisted for resume.',
+            source: 'configuration',
+        };
+    return {
+        providerId: CODEX_PROVIDER_ID,
+        profileId: profile.profileId,
+        capabilities: {
+            'session.create': native,
+            'session.resume': sessionResume,
+            'session.fork': unsupported,
+            'session.close': { mode: 'adapter_controlled', source: 'configuration' },
+            'run.stream': native,
+            'run.cancel': native,
+            'connection.abort': {
+                mode: 'adapter_controlled',
+                source: 'configuration',
+            },
+            'input.text': native,
+            'input.image': native,
+            'input.file': unsupported,
+            'interaction.approval': native,
+            'interaction.user_input': {
+                mode: 'unsupported',
+                reason: 'Codex user-input requests require the experimental API.',
+                source: 'schema',
+            },
+            'interaction.provider': native,
+            'event.raw': { mode: 'adapter_controlled', source: 'configuration' },
+            'native.client': native,
+        },
+        observedAt: new Date().toISOString(),
+        runtimeIdentity,
+    };
+}
+function connectionOptions(value) {
+    const options = value ?? {};
+    const allowed = new Set([
+        'cancelSettlementTimeoutMs',
+        'maxBufferedMessages',
+        'maxMessageBytes',
+        'maxPendingInboundRequests',
+        'maxPendingRequests',
+        'maxPendingWrites',
+        'maxRunEvents',
+        'requestTimeoutMs',
+    ]);
+    const unknown = Object.keys(options).find((key) => !allowed.has(key));
+    if (unknown !== undefined) {
+        throw new HarnessError('profile_invalid', 'Unsupported Codex Profile option.', { retryable: false, providerId: CODEX_PROVIDER_ID });
+    }
+    const transport = {};
+    for (const name of [
+        'maxBufferedMessages',
+        'maxMessageBytes',
+        'maxPendingInboundRequests',
+        'maxPendingRequests',
+        'maxPendingWrites',
+    ]) {
+        if (options[name] !== undefined) {
+            transport[name] = positiveProfileInteger(options[name], name);
+        }
+    }
+    if (options['requestTimeoutMs'] !== undefined) {
+        transport['requestTimeoutMs'] = positiveProfileTimer(options['requestTimeoutMs'], 'requestTimeoutMs');
+    }
+    return {
+        cancelSettlementTimeoutMs: options['cancelSettlementTimeoutMs'] === undefined
+            ? defaultCancelSettlementTimeoutMs
+            : positiveProfileTimer(options['cancelSettlementTimeoutMs'], 'cancelSettlementTimeoutMs'),
+        maxRunEvents: runEventCapacity(options['maxRunEvents']),
+        transport,
+    };
+}
+function runEventCapacity(value) {
+    if (value === undefined)
+        return defaultMaxRunEvents;
+    const capacity = positiveProfileInteger(value, 'maxRunEvents');
+    if (capacity < 2) {
+        throw new HarnessError('profile_invalid', 'Codex maxRunEvents must reserve space for a terminal event.', { retryable: false, providerId: CODEX_PROVIDER_ID });
+    }
+    return capacity;
+}
+function validateProfile(profile) {
+    if (profile.providerId !== CODEX_PROVIDER_ID ||
+        profile.connection.kind !== 'process' ||
+        profile.connection.ownership !== 'adapter' ||
+        profile.connection.command.length === 0 ||
+        profile.connection.envRefs !== undefined) {
+        throw profileInvalid(profile);
+    }
+}
+function profileInvalid(profile) {
+    return new HarnessError('profile_invalid', 'Codex requires an adapter-owned process Profile without unresolved Secret references.', {
+        retryable: false,
+        providerId: CODEX_PROVIDER_ID,
+        profileId: profile.profileId,
+    });
+}
+function positiveProfileInteger(value, label) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+        throw new HarnessError('profile_invalid', `Codex ${label} must be a positive integer.`, {
+            retryable: false,
+            providerId: CODEX_PROVIDER_ID,
+        });
+    }
+    return value;
+}
+function positiveProfileTimer(value, label) {
+    const timeout = positiveProfileInteger(value, label);
+    if (timeout > maximumTimerMilliseconds) {
+        throw new HarnessError('profile_invalid', `Codex ${label} exceeds the supported timer range.`, {
+            retryable: false,
+            providerId: CODEX_PROVIDER_ID,
+        });
+    }
+    return timeout;
+}
+function snapshotProfile(profile) {
+    return {
+        ...profile,
+        connection: {
+            ...profile.connection,
+            ...(profile.connection.kind === 'process' && profile.connection.args
+                ? { args: [...profile.connection.args] }
+                : {}),
+        },
+        ...(profile.providerOptions === undefined
+            ? {}
+            : { providerOptions: { ...profile.providerOptions } }),
+    };
+}
+function requestIdFromResolved(params) {
+    if (typeof params !== 'object' || params === null || Array.isArray(params)) {
+        return undefined;
+    }
+    const value = params['requestId'];
+    return typeof value === 'string' || typeof value === 'number'
+        ? value
+        : undefined;
+}
+function isEphemeralSessionRef(ref) {
+    return (typeof ref.providerState === 'object' &&
+        ref.providerState !== null &&
+        !Array.isArray(ref.providerState) &&
+        ref.providerState['ephemeral'] === true);
+}
+function wireKey(id) {
+    return `${typeof id}:${String(id)}`;
+}
+function createStartingRun() {
+    let resolve;
+    const promise = new Promise((settle) => {
+        resolve = settle;
+    });
+    return { promise, resolve };
+}
+function mapError(error, profile, phase, connecting = false, transport) {
+    if (error instanceof HarnessError)
+        return error;
+    if (error instanceof JsonRpcRemoteError) {
+        const remote = error.getRemoteError();
+        const code = remote.code === -32_601 ? 'provider_api_incompatible' : 'provider_error';
+        return new HarnessError(code, `Codex App Server rejected ${phase}.`, {
+            retryable: false,
+            providerId: CODEX_PROVIDER_ID,
+            profileId: profile.profileId,
+            providerCode: String(remote.code),
+        });
+    }
+    if (error instanceof JsonRpcTransportError) {
+        const code = error.code === 'request_timeout'
+            ? 'timeout'
+            : connecting
+                ? 'connection_failed'
+                : transport?.isOpen() === false
+                    ? 'connection_aborted'
+                    : 'provider_error';
+        return new HarnessError(code, `Codex App Server ${phase} did not complete.`, {
+            retryable: error.code === 'request_timeout' ||
+                error.code === 'capacity_exceeded',
+            providerId: CODEX_PROVIDER_ID,
+            profileId: profile.profileId,
+            providerCode: error.code,
+        });
+    }
+    const systemCode = typeof error === 'object' && error !== null && 'code' in error
+        ? error.code
+        : undefined;
+    if (connecting && systemCode === 'ENOENT') {
+        return new HarnessError('runtime_not_found', 'The configured Codex runtime was not found.', {
+            retryable: false,
+            providerId: CODEX_PROVIDER_ID,
+            profileId: profile.profileId,
+        });
+    }
+    return new HarnessError(connecting ? 'connection_failed' : 'provider_error', `Codex App Server ${phase} failed.`, {
+        retryable: false,
+        providerId: CODEX_PROVIDER_ID,
+        profileId: profile.profileId,
+    });
+}
+//# sourceMappingURL=adapter.js.map