@modelprofile.com/mcp-crossharness 5.0.0

package/dist_ts/classes.connection.codex.js

@@ -0,0 +1,941 @@
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+import { commitinfo } from './00_commitinfo_data.js';
+const appServerVersion = '0.146.0';
+const maxSocketMessageBytes = 4 * 1024 * 1024;
+const maxSocketBufferedBytes = 4 * 1024 * 1024;
+const maxTurnTextChars = 1024 * 1024;
+const maxTurnDeltaChunks = 4096;
+const maxEarlyNotifications = 100;
+const maxQueuedSends = 100;
+const maxQueuedSendsPerThread = 10;
+export class CodexConnection {
+    connectionId;
+    serverUrl;
+    directory;
+    onClosing;
+    onClosed;
+    harness = 'codex';
+    state = 'connecting';
+    connectedAt = new Date().toISOString();
+    serverVersion;
+    socket;
+    requestCounter = 0;
+    pendingRequests = new Map();
+    pendingTurns = new Set();
+    threadQueues = new Map();
+    activeThreads = new Set();
+    queuedSends = 0;
+    queuedSendsByThread = new Map();
+    connectStarted = false;
+    constructor(connectionId, serverUrl, directory, onClosing, onClosed) {
+        this.connectionId = connectionId;
+        this.serverUrl = serverUrl;
+        this.directory = directory;
+        this.onClosing = onClosing;
+        this.onClosed = onClosed;
+    }
+    async connect() {
+        if (this.connectStarted) {
+            throw new Error(`Codex connection ${this.connectionId} has already been started`);
+        }
+        this.connectStarted = true;
+        const headers = {};
+        const token = process.env.CODEX_REMOTE_TOKEN;
+        if (token)
+            headers.authorization = `Bearer ${token}`;
+        const socket = new plugins.WsWebSocket(this.serverUrl, {
+            perMessageDeflate: false,
+            headers,
+            followRedirects: false,
+            maxPayload: maxSocketMessageBytes,
+        });
+        this.socket = socket;
+        socket.on('message', (data) => this.handleMessage(data.toString()));
+        socket.on('error', (error) => this.handleSocketFailure(error));
+        socket.on('close', () => this.handleSocketClose());
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timer);
+                socket.off('open', handleOpen);
+                socket.off('error', handleError);
+                socket.off('close', handleClose);
+            };
+            const handleOpen = () => {
+                cleanup();
+                resolve();
+            };
+            const handleError = (errorArg) => {
+                cleanup();
+                reject(errorArg);
+            };
+            const handleClose = () => {
+                cleanup();
+                reject(new Error('Codex server WebSocket closed during handshake'));
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                socket.terminate();
+                reject(new Error('Codex server WebSocket handshake timed out'));
+            }, 5000);
+            socket.once('open', handleOpen);
+            socket.once('error', handleError);
+            socket.once('close', handleClose);
+        });
+        try {
+            const initialized = await this.request('initialize', {
+                clientInfo: {
+                    name: 'mcp-crossharness',
+                    title: 'mcp-crossharness',
+                    version: commitinfo.version,
+                },
+                capabilities: {
+                    experimentalApi: false,
+                    requestAttestation: false,
+                },
+            }, 5000, true);
+            if (!helpers.isRecord(initialized) || typeof initialized.userAgent !== 'string') {
+                throw new Error(`Codex server returned an invalid initialize response (expected app-server ${appServerVersion})`);
+            }
+            this.serverVersion = initialized.userAgent.match(/\/(\d+\.\d+\.\d+[^\s]*)/)?.[1];
+            if (this.state !== 'connecting' || socket.readyState !== plugins.WsWebSocket.OPEN) {
+                throw new Error('Codex server connection closed during initialization');
+            }
+            this.sendNotification('initialized');
+            this.state = 'connected';
+        }
+        catch (error) {
+            socket.terminate();
+            throw error;
+        }
+    }
+    getInfo() {
+        return {
+            connectionId: this.connectionId,
+            harness: this.harness,
+            serverUrl: this.serverUrl,
+            directory: this.directory,
+            state: this.state,
+            connectedAt: this.connectedAt,
+            serverVersion: this.serverVersion,
+        };
+    }
+    async getStatus() {
+        if (this.state !== 'connected') {
+            return { ...this.getInfo(), healthy: false, detail: `connection is ${this.state}` };
+        }
+        try {
+            const response = await this.request('thread/loaded/list', {}, 5000);
+            const healthy = helpers.isRecord(response) && Array.isArray(response.data);
+            return {
+                ...this.getInfo(),
+                healthy,
+                detail: healthy ? 'Codex app-server answered thread/loaded/list' : 'invalid health response',
+            };
+        }
+        catch (error) {
+            return { ...this.getInfo(), healthy: false, detail: helpers.errorMessage(error) };
+        }
+    }
+    async listChats(limitArg) {
+        const payload = await this.request('thread/list', {
+            limit: limitArg,
+            sortKey: 'updated_at',
+            sortDirection: 'desc',
+            archived: false,
+            cwd: this.directory,
+        });
+        if (!helpers.isRecord(payload) || !Array.isArray(payload.data)) {
+            throw new Error('Codex server returned an invalid thread list');
+        }
+        return payload.data.map((entry) => {
+            const thread = this.parseThread(entry);
+            this.assertThreadIdentity(thread, thread.id);
+            return {
+                harness: this.harness,
+                chatId: thread.id,
+                title: thread.name ?? thread.preview ?? '(untitled)',
+                directory: thread.cwd,
+                updatedAt: new Date(thread.updatedAt * 1000).toISOString(),
+                isActive: helpers.isRecord(thread.status) && thread.status.type === 'active',
+                meta: thread.modelProvider ? { modelProvider: thread.modelProvider } : undefined,
+            };
+        });
+    }
+    async readChat(chatIdArg, limitArg, maxCharsArg) {
+        this.assertChatId(chatIdArg);
+        const thread = await this.readThread(chatIdArg, true);
+        const messages = [];
+        for (const turn of thread.turns) {
+            if (!helpers.isRecord(turn) || !Array.isArray(turn.items))
+                continue;
+            for (const item of turn.items) {
+                if (!helpers.isRecord(item) || typeof item.type !== 'string')
+                    continue;
+                if (item.type === 'userMessage' && Array.isArray(item.content)) {
+                    const text = item.content
+                        .filter((content) => helpers.isRecord(content) && content.type === 'text')
+                        .map((content) => String(content.text ?? ''))
+                        .join('\n')
+                        .trim();
+                    if (text)
+                        messages.push({ role: 'user', text: helpers.truncateText(text, maxCharsArg) });
+                }
+                else if (item.type === 'agentMessage' && typeof item.text === 'string') {
+                    messages.push({ role: 'assistant', text: helpers.truncateText(item.text, maxCharsArg) });
+                }
+            }
+        }
+        const limited = messages.slice(-limitArg);
+        return {
+            harness: this.harness,
+            chatId: chatIdArg,
+            title: thread.name ?? thread.preview ?? '(untitled)',
+            directory: thread.cwd,
+            totalMessages: messages.length,
+            messages: limited,
+        };
+    }
+    async sendMessage(chatIdArg, messageArg, timeoutSecondsArg, signalArg) {
+        this.assertChatId(chatIdArg);
+        if (messageArg.length > maxTurnTextChars) {
+            throw new Error('Codex message exceeds the 1 MiB character limit');
+        }
+        const threadQueueSize = this.queuedSendsByThread.get(chatIdArg) ?? 0;
+        if (this.queuedSends >= maxQueuedSends || threadQueueSize >= maxQueuedSendsPerThread) {
+            throw new Error('Codex send queue is full');
+        }
+        this.queuedSends++;
+        this.queuedSendsByThread.set(chatIdArg, threadQueueSize + 1);
+        const deadline = Date.now() + timeoutSecondsArg * 1000;
+        try {
+            return await this.enqueueThreadSend(chatIdArg, deadline, timeoutSecondsArg, signalArg, () => this.sendMessageInner(chatIdArg, messageArg, deadline, timeoutSecondsArg, signalArg));
+        }
+        finally {
+            this.queuedSends--;
+            const remainingForThread = (this.queuedSendsByThread.get(chatIdArg) ?? 1) - 1;
+            if (remainingForThread > 0)
+                this.queuedSendsByThread.set(chatIdArg, remainingForThread);
+            else
+                this.queuedSendsByThread.delete(chatIdArg);
+        }
+    }
+    async sendMessageInner(chatIdArg, messageArg, deadlineArg, timeoutSecondsArg, signalArg) {
+        await this.readThread(chatIdArg, false, this.remainingSendMs(deadlineArg, timeoutSecondsArg), signalArg);
+        const resumed = await this.request('thread/resume', { threadId: chatIdArg }, this.remainingSendMs(deadlineArg, timeoutSecondsArg), false, signalArg);
+        if (!helpers.isRecord(resumed) ||
+            !helpers.isRecord(resumed.thread) ||
+            typeof resumed.cwd !== 'string') {
+            throw new Error('Codex server returned an invalid thread/resume response');
+        }
+        const resumedThread = this.parseThread(resumed.thread);
+        this.assertThreadIdentity(resumedThread, chatIdArg);
+        if (resumed.cwd !== this.directory) {
+            throw new Error(`Codex thread ${chatIdArg} resumed outside the connection directory`);
+        }
+        const turnTimeoutMs = this.remainingSendMs(deadlineArg, timeoutSecondsArg);
+        if (signalArg?.aborted)
+            throw this.abortError(signalArg.reason);
+        return new Promise((resolve, reject) => {
+            const turn = {
+                threadId: chatIdArg,
+                agentText: '',
+                deltaChunks: [],
+                deltaChars: 0,
+                earlyNotifications: new Map(),
+                earlyNotificationCount: 0,
+                earlyNotificationChars: 0,
+                resolve,
+                reject,
+                timer: setTimeout(() => void this.timeoutTurn(turn, timeoutSecondsArg), turnTimeoutMs),
+            };
+            this.pendingTurns.add(turn);
+            void this.request('turn/start', {
+                threadId: chatIdArg,
+                clientUserMessageId: plugins.crypto.randomUUID(),
+                input: [{ type: 'text', text: messageArg, text_elements: [] }],
+                cwd: this.directory,
+            }, turnTimeoutMs)
+                .then((result) => {
+                if (!this.pendingTurns.has(turn))
+                    return;
+                let turnId;
+                try {
+                    turnId = this.extractTurnId(result);
+                }
+                catch (error) {
+                    this.failUncertainTurnStart(turn, error);
+                    return;
+                }
+                this.bindTurnId(turn, turnId);
+            })
+                .catch((error) => this.failUncertainTurnStart(turn, error));
+        });
+    }
+    enqueueThreadSend(threadIdArg, deadlineArg, timeoutSecondsArg, signalArg, taskArg) {
+        return new Promise((resolve, reject) => {
+            const entry = {
+                deadline: deadlineArg,
+                timeoutSeconds: timeoutSecondsArg,
+                task: taskArg,
+                resolve,
+                reject,
+                signal: signalArg,
+            };
+            if (signalArg?.aborted) {
+                reject(this.abortError(signalArg.reason));
+                return;
+            }
+            const queue = this.threadQueues.get(threadIdArg) ?? [];
+            queue.push(entry);
+            this.threadQueues.set(threadIdArg, queue);
+            entry.timer = setTimeout(() => this.timeoutQueuedSend(threadIdArg, entry), Math.max(0, deadlineArg - Date.now()));
+            if (signalArg) {
+                entry.abortHandler = () => this.cancelThreadSend(threadIdArg, entry);
+                signalArg.addEventListener('abort', entry.abortHandler, { once: true });
+            }
+            this.drainThreadQueue(threadIdArg);
+        });
+    }
+    async close(reasonArg = 'connection disconnected') {
+        if (this.state === 'closed')
+            return;
+        if (this.state !== 'closing') {
+            this.state = 'closing';
+            this.rejectAll(new Error(reasonArg));
+            this.onClosing?.();
+            this.onClosing = undefined;
+        }
+        await this.closeSocket();
+        this.finishClosed();
+    }
+    async readThread(chatIdArg, includeTurnsArg, timeoutMsArg = 30000, signalArg) {
+        const payload = await this.request('thread/read', {
+            threadId: chatIdArg,
+            includeTurns: includeTurnsArg,
+        }, timeoutMsArg, false, signalArg);
+        if (!helpers.isRecord(payload) || !helpers.isRecord(payload.thread)) {
+            throw new Error('Codex server returned an invalid thread');
+        }
+        const thread = this.parseThread(payload.thread);
+        this.assertThreadIdentity(thread, chatIdArg);
+        return thread;
+    }
+    parseThread(valueArg) {
+        if (!helpers.isRecord(valueArg) ||
+            typeof valueArg.id !== 'string' ||
+            typeof valueArg.cwd !== 'string' ||
+            typeof valueArg.updatedAt !== 'number' ||
+            !Array.isArray(valueArg.turns)) {
+            throw new Error('Codex server returned an invalid thread');
+        }
+        return {
+            id: valueArg.id,
+            cwd: valueArg.cwd,
+            updatedAt: valueArg.updatedAt,
+            turns: valueArg.turns,
+            preview: typeof valueArg.preview === 'string' ? valueArg.preview : undefined,
+            name: typeof valueArg.name === 'string' || valueArg.name === null ? valueArg.name : undefined,
+            modelProvider: typeof valueArg.modelProvider === 'string' ? valueArg.modelProvider : undefined,
+            status: valueArg.status,
+        };
+    }
+    assertThreadIdentity(threadArg, chatIdArg) {
+        if (threadArg.id !== chatIdArg) {
+            throw new Error(`Codex server returned a different thread for ${chatIdArg}`);
+        }
+        if (threadArg.cwd !== this.directory) {
+            throw new Error(`Codex thread ${chatIdArg} is outside the connection directory`);
+        }
+    }
+    request(methodArg, paramsArg, timeoutMsArg = 30000, allowConnectingArg = false, signalArg) {
+        if (!allowConnectingArg && this.state !== 'connected') {
+            return Promise.reject(new Error(`Codex connection ${this.connectionId} is ${this.state}`));
+        }
+        const socket = this.socket;
+        if (!socket || socket.readyState !== plugins.WsWebSocket.OPEN) {
+            return Promise.reject(new Error('Codex server WebSocket is not open'));
+        }
+        if (this.pendingRequests.size >= 256) {
+            return Promise.reject(new Error('Codex connection has too many active requests'));
+        }
+        if (signalArg?.aborted)
+            return Promise.reject(this.abortError(signalArg.reason));
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestCounter;
+            const timer = setTimeout(() => {
+                const pending = this.pendingRequests.get(id);
+                if (!pending)
+                    return;
+                this.pendingRequests.delete(id);
+                this.clearPendingRequestResources(pending);
+                reject(new Error(`Codex request timed out: ${methodArg}`));
+            }, timeoutMsArg);
+            const pending = { resolve, reject, timer, signal: signalArg };
+            if (signalArg) {
+                pending.abortHandler = () => {
+                    if (!this.pendingRequests.delete(id))
+                        return;
+                    this.clearPendingRequestResources(pending);
+                    reject(this.abortError(signalArg.reason));
+                };
+                signalArg.addEventListener('abort', pending.abortHandler, { once: true });
+            }
+            this.pendingRequests.set(id, pending);
+            const failSend = (errorArg) => {
+                const current = this.pendingRequests.get(id);
+                if (!current)
+                    return;
+                this.pendingRequests.delete(id);
+                this.clearPendingRequestResources(current);
+                current.reject(errorArg);
+            };
+            try {
+                this.sendFrame({ id, method: methodArg, params: paramsArg });
+            }
+            catch (error) {
+                failSend(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    sendNotification(methodArg, paramsArg) {
+        this.sendFrame(paramsArg === undefined
+            ? { method: methodArg }
+            : { method: methodArg, params: paramsArg });
+    }
+    sendFrame(frameArg) {
+        const socket = this.socket;
+        const payload = JSON.stringify(frameArg);
+        const payloadBytes = Buffer.byteLength(payload, 'utf8');
+        if (!socket || socket.readyState !== plugins.WsWebSocket.OPEN) {
+            const error = new Error('Codex server WebSocket is not open');
+            this.handleSocketFailure(error);
+            throw error;
+        }
+        if (socket.bufferedAmount + payloadBytes > maxSocketBufferedBytes) {
+            const error = new Error('Codex WebSocket send buffer exceeded the 4 MiB limit');
+            this.handleSocketFailure(error);
+            throw error;
+        }
+        try {
+            socket.send(payload, (error) => {
+                if (error)
+                    this.handleSocketFailure(error);
+            });
+        }
+        catch (error) {
+            const sendError = error instanceof Error ? error : new Error(String(error));
+            this.handleSocketFailure(sendError);
+            throw sendError;
+        }
+    }
+    handleMessage(rawArg) {
+        const message = helpers.parseJson(rawArg);
+        if (!helpers.isRecord(message))
+            return;
+        if (message.id !== undefined && typeof message.method === 'string') {
+            this.respondToServerRequest(message);
+            return;
+        }
+        if (typeof message.id === 'number' && this.pendingRequests.has(message.id)) {
+            const pending = this.pendingRequests.get(message.id);
+            this.pendingRequests.delete(message.id);
+            this.clearPendingRequestResources(pending);
+            if (message.error !== undefined) {
+                pending.reject(new Error(`Codex server rejected request: ${JSON.stringify(message.error).slice(0, 4000)}`));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (typeof message.method === 'string') {
+            if (!helpers.isRecord(message.params)) {
+                if (message.method === 'turn/completed') {
+                    this.handleSocketFailure(new Error('Codex returned malformed turn/completed params'));
+                }
+                return;
+            }
+            this.handleNotification(message.method, message.params);
+        }
+    }
+    handleNotification(methodArg, paramsArg) {
+        if (methodArg === 'turn/completed') {
+            if (!helpers.isRecord(paramsArg.turn) ||
+                typeof paramsArg.turn.id !== 'string' ||
+                (paramsArg.turnId !== undefined && paramsArg.turnId !== paramsArg.turn.id)) {
+                this.handleSocketFailure(new Error('Codex returned malformed turn/completed identity'));
+                return;
+            }
+        }
+        const threadId = typeof paramsArg.threadId === 'string' ? paramsArg.threadId : undefined;
+        const turnId = typeof paramsArg.turnId === 'string'
+            ? paramsArg.turnId
+            : helpers.isRecord(paramsArg.turn) && typeof paramsArg.turn.id === 'string'
+                ? paramsArg.turn.id
+                : undefined;
+        if (!threadId || !turnId) {
+            if (methodArg === 'turn/completed') {
+                this.handleSocketFailure(new Error('Codex returned malformed turn/completed identity'));
+            }
+            return;
+        }
+        const turn = [...this.pendingTurns].find((candidate) => candidate.threadId === threadId && candidate.turnId === turnId);
+        if (!turn) {
+            const unbound = [...this.pendingTurns].filter((candidate) => candidate.threadId === threadId && !candidate.turnId);
+            if (unbound.length === 1)
+                this.bufferEarlyNotification(unbound[0], turnId, methodArg, paramsArg);
+            return;
+        }
+        this.handleTurnNotification(turn, methodArg, paramsArg);
+    }
+    handleTurnNotification(turnArg, methodArg, paramsArg) {
+        if (methodArg === 'turn/completed' && !helpers.isRecord(paramsArg.turn)) {
+            this.handleSocketFailure(new Error('Codex returned malformed turn/completed payload'));
+            return;
+        }
+        if (methodArg === 'item/agentMessage/delta' && typeof paramsArg.delta === 'string') {
+            this.appendTurnDelta(turnArg, paramsArg.delta);
+        }
+        else if (methodArg === 'item/completed' && helpers.isRecord(paramsArg.item)) {
+            if (paramsArg.item.type === 'agentMessage' && typeof paramsArg.item.text === 'string') {
+                if (paramsArg.item.text.length > maxTurnTextChars) {
+                    this.handleSocketFailure(new Error('Codex turn output exceeded the response limit'));
+                    return;
+                }
+                turnArg.agentText = paramsArg.item.text;
+            }
+        }
+        else if (methodArg === 'turn/completed' && helpers.isRecord(paramsArg.turn)) {
+            const status = paramsArg.turn.status;
+            if (turnArg.timeoutError) {
+                if (status !== 'completed' && status !== 'interrupted' && status !== 'failed') {
+                    this.handleSocketFailure(new Error('Codex returned a non-terminal status in turn/completed'));
+                    return;
+                }
+                turnArg.terminalObserved = true;
+                this.rejectTimedOutTurnIfSafe(turnArg);
+                return;
+            }
+            if (status === 'completed') {
+                this.completeTurn(turnArg);
+            }
+            else if (status === 'interrupted' || status === 'failed') {
+                const turnError = helpers.isRecord(paramsArg.turn.error)
+                    ? String(paramsArg.turn.error.message ?? status)
+                    : String(status);
+                this.failTurn(turnArg, new Error(`Codex turn ${status}: ${turnError}`));
+            }
+            else {
+                this.handleSocketFailure(new Error('Codex returned a non-terminal status in turn/completed'));
+            }
+        }
+    }
+    bindTurnId(turnArg, turnIdArg) {
+        if (!this.pendingTurns.has(turnArg))
+            return;
+        if (turnArg.turnId && turnArg.turnId !== turnIdArg) {
+            this.failTurn(turnArg, new Error('Codex turn identity changed during dispatch'));
+            return;
+        }
+        const collision = [...this.pendingTurns].find((candidate) => candidate !== turnArg && candidate.turnId === turnIdArg);
+        if (collision) {
+            this.handleSocketFailure(new Error('Codex reused a turn id across concurrent sends'));
+            return;
+        }
+        turnArg.turnId = turnIdArg;
+        const buffered = turnArg.earlyNotifications.get(turnIdArg) ?? [];
+        turnArg.earlyNotifications.clear();
+        turnArg.earlyNotificationCount = 0;
+        turnArg.earlyNotificationChars = 0;
+        for (const notification of buffered) {
+            if (!this.pendingTurns.has(turnArg))
+                break;
+            this.handleTurnNotification(turnArg, notification.method, notification.params);
+        }
+    }
+    extractTurnId(valueArg) {
+        if (!helpers.isRecord(valueArg) || !helpers.isRecord(valueArg.turn) || typeof valueArg.turn.id !== 'string') {
+            throw new Error('Codex server returned an invalid turn/start response');
+        }
+        return valueArg.turn.id;
+    }
+    completeTurn(turnArg) {
+        if (!this.settleTurn(turnArg))
+            return;
+        const reply = (turnArg.agentText || turnArg.deltaChunks.join('')).trim();
+        if (!reply) {
+            turnArg.reject(new Error('Codex turn completed without assistant text'));
+            return;
+        }
+        turnArg.resolve({
+            harness: this.harness,
+            chatId: turnArg.threadId,
+            reply,
+            via: `ws:${this.serverUrl}`,
+        });
+    }
+    failTurn(turnArg, errorArg) {
+        if (!this.settleTurn(turnArg))
+            return;
+        turnArg.reject(errorArg instanceof Error ? errorArg : new Error(String(errorArg)));
+    }
+    async timeoutTurn(turnArg, timeoutSecondsArg) {
+        if (!this.pendingTurns.has(turnArg) || turnArg.timeoutError)
+            return;
+        const timeoutError = new Error(`Codex turn timed out after ${timeoutSecondsArg}s; Crossharness did not retry`);
+        turnArg.timeoutError = timeoutError;
+        const turnId = turnArg.turnId;
+        if (!turnId) {
+            const fatalError = new Error(`${timeoutError.message}; no turn id was available to interrupt safely, so the connection was closed`);
+            this.handleSocketFailure(fatalError);
+            return;
+        }
+        try {
+            await this.request('turn/interrupt', { threadId: turnArg.threadId, turnId }, 3000);
+            if (!this.pendingTurns.has(turnArg))
+                return;
+            turnArg.interruptAcknowledged = true;
+            if (turnArg.terminalObserved) {
+                this.rejectTimedOutTurnIfSafe(turnArg);
+                return;
+            }
+            turnArg.terminalTimer = setTimeout(() => {
+                if (!this.pendingTurns.has(turnArg))
+                    return;
+                this.handleSocketFailure(new Error(`${timeoutError.message}; the interrupted turn did not report terminal completion, so the connection was closed`));
+            }, 3000);
+            turnArg.terminalTimer.unref();
+        }
+        catch (error) {
+            const fatalError = new Error(`${timeoutError.message}; turn/interrupt was not acknowledged, so the connection was closed: ${helpers.errorMessage(error)}`, { cause: error });
+            this.handleSocketFailure(fatalError);
+        }
+    }
+    async cancelActiveTurn(turnArg, errorArg) {
+        if (!this.pendingTurns.has(turnArg) || turnArg.timeoutError)
+            return;
+        turnArg.timeoutError = errorArg;
+        const turnId = turnArg.turnId;
+        if (!turnId) {
+            this.handleSocketFailure(new Error(`${errorArg.message}; no turn id was available to interrupt safely, so the connection was closed`));
+            return;
+        }
+        try {
+            await this.request('turn/interrupt', { threadId: turnArg.threadId, turnId }, 3000);
+            if (!this.pendingTurns.has(turnArg))
+                return;
+            turnArg.interruptAcknowledged = true;
+            if (turnArg.terminalObserved) {
+                this.rejectTimedOutTurnIfSafe(turnArg);
+                return;
+            }
+            turnArg.terminalTimer = setTimeout(() => {
+                if (!this.pendingTurns.has(turnArg))
+                    return;
+                this.handleSocketFailure(new Error(`${errorArg.message}; the interrupted turn did not report terminal completion, so the connection was closed`));
+            }, 3000);
+            turnArg.terminalTimer.unref();
+        }
+        catch (error) {
+            this.handleSocketFailure(new Error(`${errorArg.message}; turn/interrupt was not acknowledged, so the connection was closed: ${helpers.errorMessage(error)}`, { cause: error }));
+        }
+    }
+    timeoutQueuedSend(threadIdArg, entryArg) {
+        if (this.activeThreads.has(threadIdArg)) {
+            const queue = this.threadQueues.get(threadIdArg);
+            if (queue?.[0] === entryArg)
+                return;
+        }
+        const queue = this.threadQueues.get(threadIdArg);
+        if (!queue)
+            return;
+        const index = queue.indexOf(entryArg);
+        if (index < 0)
+            return;
+        queue.splice(index, 1);
+        this.clearQueueEntryResources(entryArg);
+        entryArg.reject(new Error(`Codex send timed out after ${entryArg.timeoutSeconds}s while queued; no message was delivered`));
+        if (queue.length === 0 && !this.activeThreads.has(threadIdArg)) {
+            this.threadQueues.delete(threadIdArg);
+        }
+    }
+    cancelThreadSend(threadIdArg, entryArg) {
+        const queue = this.threadQueues.get(threadIdArg);
+        if (!queue)
+            return;
+        const index = queue.indexOf(entryArg);
+        if (index < 0)
+            return;
+        if (index === 0 && this.activeThreads.has(threadIdArg)) {
+            const turn = [...this.pendingTurns].find((candidate) => candidate.threadId === threadIdArg);
+            if (turn)
+                void this.cancelActiveTurn(turn, this.abortError(entryArg.signal?.reason));
+            return;
+        }
+        queue.splice(index, 1);
+        this.clearQueueEntryResources(entryArg);
+        entryArg.reject(this.abortError(entryArg.signal?.reason));
+        if (queue.length === 0 && !this.activeThreads.has(threadIdArg)) {
+            this.threadQueues.delete(threadIdArg);
+        }
+    }
+    drainThreadQueue(threadIdArg) {
+        if (this.activeThreads.has(threadIdArg))
+            return;
+        const queue = this.threadQueues.get(threadIdArg);
+        const entry = queue?.[0];
+        if (!queue || !entry) {
+            this.threadQueues.delete(threadIdArg);
+            return;
+        }
+        if (entry.deadline <= Date.now()) {
+            this.timeoutQueuedSend(threadIdArg, entry);
+            this.drainThreadQueue(threadIdArg);
+            return;
+        }
+        this.activeThreads.add(threadIdArg);
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        void entry.task().then(entry.resolve, entry.reject).finally(() => {
+            this.clearQueueEntryResources(entry);
+            this.activeThreads.delete(threadIdArg);
+            const currentQueue = this.threadQueues.get(threadIdArg);
+            if (currentQueue?.[0] === entry)
+                currentQueue.shift();
+            if (currentQueue?.length === 0)
+                this.threadQueues.delete(threadIdArg);
+            this.drainThreadQueue(threadIdArg);
+        });
+    }
+    appendTurnDelta(turnArg, deltaArg) {
+        if (turnArg.deltaChunks.length >= maxTurnDeltaChunks) {
+            this.handleSocketFailure(new Error('Codex turn output exceeded the delta chunk limit'));
+            return;
+        }
+        if (turnArg.deltaChars + deltaArg.length > maxTurnTextChars) {
+            this.handleSocketFailure(new Error('Codex turn output exceeded the response limit'));
+            return;
+        }
+        turnArg.deltaChunks.push(deltaArg);
+        turnArg.deltaChars += deltaArg.length;
+    }
+    remainingSendMs(deadlineArg, timeoutSecondsArg) {
+        const remainingMs = deadlineArg - Date.now();
+        if (remainingMs <= 0) {
+            throw new Error(`Codex send timed out after ${timeoutSecondsArg}s before turn/start; no message was delivered`);
+        }
+        return remainingMs;
+    }
+    clearQueueEntryResources(entryArg) {
+        if (entryArg.timer)
+            clearTimeout(entryArg.timer);
+        if (entryArg.abortHandler) {
+            entryArg.signal?.removeEventListener('abort', entryArg.abortHandler);
+        }
+    }
+    clearPendingRequestResources(pendingArg) {
+        clearTimeout(pendingArg.timer);
+        if (pendingArg.abortHandler) {
+            pendingArg.signal?.removeEventListener('abort', pendingArg.abortHandler);
+        }
+    }
+    abortError(reasonArg) {
+        return reasonArg instanceof Error ? reasonArg : new Error('operation cancelled');
+    }
+    assertChatId(chatIdArg) {
+        if (!chatIdArg || chatIdArg.length > 1024) {
+            throw new Error('Codex chatId must contain 1-1024 characters');
+        }
+    }
+    bufferEarlyNotification(turnArg, turnIdArg, methodArg, paramsArg) {
+        const notification = this.normalizeEarlyNotification(methodArg, paramsArg);
+        if (!notification)
+            return;
+        turnArg.earlyNotificationCount++;
+        if (turnArg.earlyNotificationCount > maxEarlyNotifications) {
+            this.handleSocketFailure(new Error('Codex sent too many turn notifications before acknowledging turn/start'));
+            return;
+        }
+        const notificationChars = JSON.stringify(notification).length;
+        turnArg.earlyNotificationChars += notificationChars;
+        if (turnArg.earlyNotificationChars > maxTurnTextChars) {
+            this.handleSocketFailure(new Error('Codex buffered turn notifications exceeded the response limit'));
+            return;
+        }
+        const notifications = turnArg.earlyNotifications.get(turnIdArg) ?? [];
+        notifications.push(notification);
+        turnArg.earlyNotifications.set(turnIdArg, notifications);
+    }
+    normalizeEarlyNotification(methodArg, paramsArg) {
+        if (methodArg === 'item/agentMessage/delta' && typeof paramsArg.delta === 'string') {
+            return { method: methodArg, params: { delta: paramsArg.delta } };
+        }
+        if (methodArg === 'item/completed' && helpers.isRecord(paramsArg.item)) {
+            const item = paramsArg.item;
+            if (item.type === 'agentMessage' && typeof item.text === 'string') {
+                return { method: methodArg, params: { item: { type: item.type, text: item.text } } };
+            }
+            return undefined;
+        }
+        if (methodArg === 'turn/completed' && helpers.isRecord(paramsArg.turn)) {
+            const turn = paramsArg.turn;
+            return {
+                method: methodArg,
+                params: {
+                    turn: {
+                        status: turn.status,
+                        error: helpers.isRecord(turn.error) ? { message: turn.error.message } : turn.error,
+                    },
+                },
+            };
+        }
+        return undefined;
+    }
+    failUncertainTurnStart(turnArg, errorArg) {
+        if (!this.pendingTurns.has(turnArg))
+            return;
+        const fatalError = new Error(`Codex turn/start outcome is uncertain, so the connection was closed: ${helpers.errorMessage(errorArg)}`, { cause: errorArg });
+        this.handleSocketFailure(fatalError);
+    }
+    rejectTimedOutTurnIfSafe(turnArg) {
+        const error = turnArg.timeoutError;
+        if (!error ||
+            !turnArg.interruptAcknowledged ||
+            !turnArg.terminalObserved ||
+            !this.settleTurn(turnArg)) {
+            return;
+        }
+        turnArg.reject(error);
+    }
+    settleTurn(turnArg) {
+        if (!this.pendingTurns.delete(turnArg))
+            return false;
+        clearTimeout(turnArg.timer);
+        if (turnArg.terminalTimer)
+            clearTimeout(turnArg.terminalTimer);
+        turnArg.earlyNotifications.clear();
+        return true;
+    }
+    respondToServerRequest(messageArg) {
+        const method = String(messageArg.method);
+        let result;
+        switch (method) {
+            case 'item/commandExecution/requestApproval':
+            case 'item/fileChange/requestApproval':
+                result = { decision: 'decline' };
+                break;
+            case 'item/tool/requestUserInput':
+                result = { answers: {} };
+                break;
+            case 'mcpServer/elicitation/request':
+                result = { action: 'decline', content: null, _meta: null };
+                break;
+            case 'item/permissions/requestApproval':
+                result = { permissions: {}, scope: 'turn' };
+                break;
+            case 'applyPatchApproval':
+            case 'execCommandApproval':
+                result = { decision: 'abort' };
+                break;
+            default:
+                try {
+                    this.sendFrame({
+                        id: messageArg.id,
+                        error: { code: -32601, message: `Crossharness does not implement ${method}` },
+                    });
+                }
+                catch { }
+                return;
+        }
+        try {
+            this.sendFrame({ id: messageArg.id, result });
+        }
+        catch { }
+    }
+    handleSocketFailure(errorArg) {
+        if (this.state === 'closed')
+            return;
+        if (this.state !== 'closing') {
+            this.state = 'closing';
+            this.rejectAll(errorArg);
+            this.onClosing?.();
+            this.onClosing = undefined;
+        }
+        const socket = this.socket;
+        if (socket && socket.readyState !== plugins.WsWebSocket.CLOSED) {
+            socket.terminate();
+        }
+        else {
+            this.finishClosed();
+        }
+    }
+    handleSocketClose() {
+        if (this.state !== 'closing' && this.state !== 'closed') {
+            this.state = 'closing';
+            this.rejectAll(new Error('Codex server connection closed'));
+            this.onClosing?.();
+            this.onClosing = undefined;
+        }
+        this.finishClosed();
+    }
+    finishClosed() {
+        if (this.state === 'closed')
+            return;
+        this.state = 'closed';
+        this.onClosed?.();
+        this.onClosing = undefined;
+        this.onClosed = undefined;
+    }
+    rejectAll(errorArg) {
+        for (const pending of this.pendingRequests.values()) {
+            this.clearPendingRequestResources(pending);
+            pending.reject(errorArg);
+        }
+        this.pendingRequests.clear();
+        for (const turn of [...this.pendingTurns])
+            this.failTurn(turn, errorArg);
+        for (const [threadId, queue] of this.threadQueues) {
+            const activeOffset = this.activeThreads.has(threadId) ? 1 : 0;
+            for (const entry of queue.slice(activeOffset)) {
+                this.clearQueueEntryResources(entry);
+                entry.reject(errorArg);
+            }
+        }
+        this.threadQueues.clear();
+    }
+    async closeSocket() {
+        const socket = this.socket;
+        if (!socket || socket.readyState === plugins.WsWebSocket.CLOSED)
+            return;
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                socket.off('close', finish);
+                resolve();
+            };
+            const timer = setTimeout(() => {
+                socket.terminate();
+                finish();
+            }, 1000);
+            socket.once('close', finish);
+            try {
+                if (socket.readyState === plugins.WsWebSocket.CONNECTING) {
+                    socket.terminate();
+                }
+                else {
+                    socket.close();
+                }
+            }
+            catch {
+                socket.terminate();
+                finish();
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.connection.codex.js","sourceRoot":"","sources":["../ts/classes.connection.codex.ts"],"names":[],"mappings":"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"}