@vibelet/cli 0.1.35 → 0.1.36

package/dist/drivers/codex.js

@@ -0,0 +1,771 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { config } from '../config.js';
+import { logger as rootLogger } from '../logger.js';
+import { metrics } from '../metrics.js';
+import { audit } from '../audit.js';
+import { CLI_VERSION } from '../cli-version.js';
+const log = rootLogger.child({ module: 'codex' });
+function serializeApprovalContext(request) {
+    switch (request.kind) {
+        case 'request-user-input-approval':
+            return {
+                provider: 'codex',
+                kind: request.kind,
+                rpcId: request.rpcId,
+                questionId: request.questionId,
+                approveLabel: request.approveLabel,
+                denyLabel: request.denyLabel,
+            };
+        default:
+            return {
+                provider: 'codex',
+                kind: request.kind,
+                rpcId: request.rpcId,
+            };
+    }
+}
+function restoreApprovalRequest(approval) {
+    const context = approval.approvalContext;
+    if (!context || context.provider !== 'codex') {
+        return null;
+    }
+    switch (context.kind) {
+        case 'command-execution':
+            return {
+                kind: context.kind,
+                responseKind: 'v2',
+                rpcId: context.rpcId,
+                toolName: approval.toolName,
+                input: approval.input,
+            };
+        case 'file-change':
+            return {
+                kind: context.kind,
+                responseKind: 'v2',
+                rpcId: context.rpcId,
+                toolName: approval.toolName,
+                input: approval.input,
+            };
+        case 'request-user-input-approval':
+            if (!context.questionId || !context.approveLabel || !context.denyLabel) {
+                return null;
+            }
+            return {
+                kind: context.kind,
+                rpcId: context.rpcId,
+                questionId: context.questionId,
+                approveLabel: context.approveLabel,
+                denyLabel: context.denyLabel,
+                toolName: approval.toolName,
+                input: approval.input,
+            };
+        case 'exec-command-legacy':
+            return {
+                kind: context.kind,
+                rpcId: context.rpcId,
+                toolName: approval.toolName,
+                input: approval.input,
+            };
+        case 'apply-patch-legacy':
+            return {
+                kind: context.kind,
+                rpcId: context.rpcId,
+                toolName: approval.toolName,
+                input: approval.input,
+            };
+        default:
+            return null;
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    return value;
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+const INTERRUPTED_TURN_STATUSES = new Set(['aborted', 'interrupted', 'cancelled', 'canceled']);
+function normalizeTurnStatus(value) {
+    const text = readString(value);
+    return text ? text.toLowerCase() : null;
+}
+function normalizeItemType(value) {
+    const text = readString(value);
+    return text ? text.replace(/[^a-z0-9]/gi, '').toLowerCase() : null;
+}
+function readItemId(record) {
+    if (!record)
+        return null;
+    return readString(record.itemId) ?? readString(record.id) ?? readString(record.callId) ?? readString(record.call_id);
+}
+function omitKeys(record, keys) {
+    const next = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (!keys.includes(key))
+            next[key] = value;
+    }
+    return next;
+}
+function isApproveLabel(label) {
+    return /\bapprove\b|\ballow\b|\baccept\b|\byes\b|\bcontinue\b|\bproceed\b|\brun\b|\bapply\b/i.test(label);
+}
+function isDenyLabel(label) {
+    return /\bdeny\b|\breject\b|\bdecline\b|\bno\b|\bcancel\b|\babort\b|\bstop\b/i.test(label);
+}
+function resolveApprovalQuestion(questions) {
+    if (!Array.isArray(questions))
+        return null;
+    for (const question of questions) {
+        const record = asRecord(question);
+        if (!record)
+            continue;
+        const questionId = readString(record.id);
+        const options = Array.isArray(record.options)
+            ? record.options.map((option) => asRecord(option)).filter((option) => Boolean(option))
+            : [];
+        if (!questionId || options.length === 0)
+            continue;
+        const labels = options
+            .map((option) => readString(option.label))
+            .filter((label) => Boolean(label));
+        if (labels.length < 2)
+            continue;
+        const approveLabel = labels.find((label) => isApproveLabel(label)) ?? labels[0];
+        const denyLabel = labels.find((label) => isDenyLabel(label)) ?? labels[labels.length - 1];
+        if (!approveLabel || !denyLabel || approveLabel === denyLabel) {
+            continue;
+        }
+        return {
+            questionId,
+            approveLabel,
+            denyLabel,
+        };
+    }
+    return null;
+}
+function looksLikeApprovalRequestUserInput(questions) {
+    if (!Array.isArray(questions) || questions.length === 0)
+        return false;
+    const labels = questions
+        .map((question) => asRecord(question))
+        .filter((question) => Boolean(question))
+        .flatMap((question) => {
+        const options = Array.isArray(question.options) ? question.options : [];
+        return options
+            .map((option) => asRecord(option))
+            .filter((option) => Boolean(option))
+            .map((option) => readString(option.label))
+            .filter((label) => Boolean(label));
+    });
+    const hasApproval = labels.some((label) => isApproveLabel(label));
+    const hasDeny = labels.some((label) => isDenyLabel(label));
+    return hasApproval && hasDeny;
+}
+function extractToolContext(item) {
+    const itemType = normalizeItemType(item.type ?? item.itemType);
+    if (itemType === 'commandexecution') {
+        return {
+            toolName: 'Bash',
+            input: omitKeys(item, ['id', 'itemId', 'type', 'itemType', 'stdout', 'stderr', 'exitCode', 'exit_code', 'status', 'success', 'error']),
+        };
+    }
+    if (itemType === 'filechange') {
+        return {
+            toolName: 'Patch',
+            input: omitKeys(item, ['id', 'itemId', 'type', 'itemType', 'stdout', 'stderr', 'exitCode', 'exit_code', 'status', 'success', 'error']),
+        };
+    }
+    if (itemType === 'mcptoolcall') {
+        const server = readString(item.server);
+        const tool = readString(item.tool) ?? readString(item.name);
+        if (!tool)
+            return null;
+        return {
+            toolName: server ? `mcp__${server}__${tool}` : tool,
+            input: (asRecord(item.arguments) ?? asRecord(item.input) ?? {}),
+        };
+    }
+    return null;
+}
+function readRequestUserInputDescription(questions) {
+    if (!Array.isArray(questions))
+        return '';
+    for (const question of questions) {
+        const record = asRecord(question);
+        if (!record)
+            continue;
+        const questionText = readString(record.question) ?? readString(record.header);
+        if (questionText)
+            return questionText;
+    }
+    return '';
+}
+function resolveCodexPolicy(approvalMode, cwd) {
+    if (approvalMode === 'autoApprove') {
+        return {
+            approvalPolicy: 'never',
+            sandbox: 'danger-full-access',
+            sandboxPolicy: { type: 'dangerFullAccess' },
+        };
+    }
+    if (approvalMode === 'plan') {
+        return {
+            approvalPolicy: 'on-request',
+            sandbox: 'workspace-write',
+            sandboxPolicy: {
+                type: 'workspaceWrite',
+                writableRoots: [],
+                readOnlyAccess: { type: 'fullAccess' },
+                networkAccess: true,
+                excludeTmpdirEnvVar: false,
+                excludeSlashTmp: false,
+            },
+        };
+    }
+    return {
+        approvalPolicy: 'on-request',
+        sandbox: 'workspace-write',
+        sandboxPolicy: {
+            type: 'workspaceWrite',
+            writableRoots: [cwd],
+            readOnlyAccess: { type: 'fullAccess' },
+            networkAccess: true,
+            excludeTmpdirEnvVar: false,
+            excludeSlashTmp: false,
+        },
+    };
+}
+export class CodexDriver {
+    proc = null;
+    handler = null;
+    exitHandler = null;
+    buffer = '';
+    rpcId = 0;
+    pending = new Map();
+    threadId = '';
+    lastStderr = [];
+    approvalRequests = new Map();
+    toolContextByCallId = new Map();
+    turnStartInFlight = false;
+    interruptRequestedDuringTurnStart = false;
+    approvalMode;
+    cwd = '';
+    async start(cwd, resumeSessionId, approvalMode) {
+        this.approvalMode = approvalMode;
+        this.cwd = cwd;
+        this.approvalRequests.clear();
+        this.toolContextByCallId.clear();
+        this.turnStartInFlight = false;
+        this.interruptRequestedDuringTurnStart = false;
+        const codexPath = config.codexPath;
+        let spawnCmd;
+        let spawnArgs = this.buildSpawnArgs();
+        if (config.isTransientPath(codexPath)) {
+            const resolved = config.execViaLoginShell('codex', spawnArgs);
+            spawnCmd = resolved.command;
+            spawnArgs = resolved.args;
+            log.info({ spawnCmd, argsPreview: spawnArgs.slice(0, 2) }, 'spawning via login shell');
+        }
+        else {
+            spawnCmd = codexPath;
+            log.info({ spawnCmd, args: spawnArgs }, 'spawning');
+        }
+        audit.emit('driver.spawn', { agent: 'codex', cwd, resumeSessionId });
+        this.lastStderr = [];
+        this.proc = spawn(spawnCmd, spawnArgs, {
+            cwd: cwd || undefined,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: config.buildSanitizedEnv(),
+            ...(process.platform === 'win32' ? { shell: true } : {}),
+        });
+        this.proc.on('error', (err) => {
+            let message = err.message;
+            if (err.code === 'ENOENT' && cwd && !existsSync(cwd)) {
+                message = `Working directory does not exist: ${cwd}`;
+            }
+            log.error({ error: message, cwd }, 'spawn error');
+            audit.emit('driver.error', { agent: 'codex', error: message });
+        });
+        this.proc.stdout.on('data', (chunk) => {
+            this.buffer += chunk.toString();
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop();
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    this.handleRaw(JSON.parse(line));
+                }
+                catch {
+                    log.warn({ linePreview: line.slice(0, 200) }, 'failed to parse stdout line');
+                }
+            }
+        });
+        this.proc.stderr.on('data', (chunk) => {
+            const text = chunk.toString().trim();
+            if (text) {
+                log.debug({ stderr: text }, 'stderr');
+                this.lastStderr.push(text);
+                if (this.lastStderr.length > 10)
+                    this.lastStderr.shift();
+            }
+        });
+        this.proc.on('exit', (code) => {
+            log.info({ threadId: this.threadId, exitCode: code }, 'process exited');
+            if (code && code !== 0) {
+                log.error({ threadId: this.threadId, exitCode: code, lastStderr: this.lastStderr.slice(-3) }, 'abnormal exit');
+            }
+            this.proc = null;
+            this.approvalRequests.clear();
+            this.toolContextByCallId.clear();
+            this.turnStartInFlight = false;
+            this.interruptRequestedDuringTurnStart = false;
+            for (const [, { reject }] of this.pending) {
+                reject(new Error(`Codex process exited with code ${code}`));
+            }
+            this.pending.clear();
+            this.exitHandler?.(code);
+            if (code && this.handler && this.threadId) {
+                this.handler({ type: 'error', sessionId: this.threadId, message: `Codex process exited with code ${code}` });
+            }
+        });
+        const endInit = metrics.startTimer('rpc.duration');
+        await this.rpc('initialize', {
+            clientInfo: { name: '@vibelet/cli', version: CLI_VERSION },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        endInit();
+        this.rpcNotify('initialized', {});
+        const policy = resolveCodexPolicy(this.approvalMode, cwd);
+        if (resumeSessionId) {
+            const res = await this.rpc('thread/resume', {
+                threadId: resumeSessionId,
+                approvalPolicy: policy.approvalPolicy,
+                sandbox: policy.sandbox,
+                persistExtendedHistory: true,
+            });
+            this.threadId = res?.thread?.id ?? resumeSessionId;
+            log.info({ threadId: this.threadId }, 'thread resumed');
+            audit.emit('driver.init', { agent: 'codex', sessionId: this.threadId });
+        }
+        else {
+            const res = await this.rpc('thread/start', {
+                cwd,
+                approvalPolicy: policy.approvalPolicy,
+                sandbox: policy.sandbox,
+                experimentalRawEvents: true,
+                persistExtendedHistory: true,
+            });
+            this.threadId = res?.thread?.id ?? res?.threadId ?? '';
+            log.info({ threadId: this.threadId }, 'thread created');
+            audit.emit('driver.init', { agent: 'codex', sessionId: this.threadId });
+        }
+        return this.threadId;
+    }
+    buildSpawnArgs() {
+        return ['app-server', '--listen', 'stdio://'];
+    }
+    sendPrompt(text) {
+        const policy = resolveCodexPolicy(this.approvalMode, this.cwd || process.cwd());
+        this.turnStartInFlight = true;
+        this.interruptRequestedDuringTurnStart = false;
+        log.info({ threadId: this.threadId, promptPreview: text.slice(0, 50) }, 'turn/start');
+        this.rpc('turn/start', {
+            threadId: this.threadId,
+            input: [{ type: 'text', text }],
+            approvalPolicy: policy.approvalPolicy,
+            sandboxPolicy: policy.sandboxPolicy,
+        })
+            .then((res) => {
+            log.debug({ resultPreview: JSON.stringify(res).slice(0, 200) }, 'turn/start result');
+            this.turnStartInFlight = false;
+            if (this.interruptRequestedDuringTurnStart) {
+                this.interruptRequestedDuringTurnStart = false;
+                this.requestTurnInterrupt();
+            }
+        })
+            .catch((e) => {
+            this.turnStartInFlight = false;
+            this.interruptRequestedDuringTurnStart = false;
+            log.error({ threadId: this.threadId, error: e.message }, 'sendPrompt error');
+            this.handler?.({ type: 'error', sessionId: this.threadId, message: e.message });
+        });
+    }
+    respondApproval(requestId, approved) {
+        if (!this.proc?.stdin?.writable)
+            return false;
+        const tracked = this.approvalRequests.get(requestId);
+        const rpcId = tracked?.rpcId ?? Number(requestId);
+        if (!Number.isFinite(rpcId))
+            return false;
+        let result;
+        if (!tracked) {
+            result = approved
+                ? { decision: 'approve' }
+                : { decision: 'deny', reason: 'User denied from Vibelet' };
+        }
+        else {
+            switch (tracked.kind) {
+                case 'command-execution':
+                case 'file-change':
+                    result = { decision: approved ? 'accept' : 'decline' };
+                    break;
+                case 'request-user-input-approval':
+                    result = {
+                        answers: {
+                            [tracked.questionId]: {
+                                answers: [approved ? tracked.approveLabel : tracked.denyLabel],
+                            },
+                        },
+                    };
+                    break;
+                case 'exec-command-legacy':
+                case 'apply-patch-legacy':
+                    result = { decision: approved ? 'approved' : 'denied' };
+                    break;
+                default:
+                    result = { decision: approved ? 'accept' : 'decline' };
+                    break;
+            }
+            this.approvalRequests.delete(requestId);
+        }
+        log.info({ threadId: this.threadId, rpcId, approved }, 'approval response');
+        this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: rpcId, result }) + '\n');
+        return true;
+    }
+    restorePendingApproval(approval) {
+        const request = restoreApprovalRequest(approval);
+        if (!request) {
+            return;
+        }
+        this.approvalRequests.set(approval.requestId, request);
+    }
+    interrupt() {
+        if (this.turnStartInFlight) {
+            this.interruptRequestedDuringTurnStart = true;
+        }
+        this.requestTurnInterrupt();
+    }
+    setApprovalMode(mode) {
+        this.approvalMode = mode;
+        log.info({ approvalMode: mode }, 'approval mode updated (takes effect on subsequent turns)');
+    }
+    stop() {
+        if (!this.proc)
+            return;
+        this.proc.kill('SIGTERM');
+        const p = this.proc;
+        setTimeout(() => {
+            if (!p.killed)
+                p.kill('SIGKILL');
+        }, 5000).unref();
+        this.proc = null;
+        this.approvalRequests.clear();
+        this.toolContextByCallId.clear();
+        this.turnStartInFlight = false;
+        this.interruptRequestedDuringTurnStart = false;
+        for (const [, { reject }] of this.pending) {
+            reject(new Error('Process stopped'));
+        }
+        this.pending.clear();
+    }
+    onMessage(handler) {
+        this.handler = handler;
+    }
+    onExit(handler) {
+        this.exitHandler = handler;
+    }
+    rpc(method, params) {
+        const id = ++this.rpcId;
+        const endTimer = metrics.startTimer('rpc.duration');
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: (v) => { endTimer(); resolve(v); },
+                reject: (e) => { endTimer(); reject(e); },
+            });
+            if (!this.proc?.stdin?.writable) {
+                this.pending.delete(id);
+                endTimer();
+                reject(new Error('Process not available'));
+                return;
+            }
+            this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, id, params }) + '\n');
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    log.error({ method, rpcId: id, threadId: this.threadId }, 'RPC timeout');
+                    endTimer();
+                    reject(new Error(`RPC timeout: ${method}`));
+                }
+            }, 30000).unref();
+        });
+    }
+    requestTurnInterrupt() {
+        this.rpc('turn/interrupt', { threadId: this.threadId }).catch(() => { });
+    }
+    rpcNotify(method, params) {
+        if (!this.proc?.stdin?.writable)
+            return;
+        this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+    }
+    writeServerRequestError(rpcId, message) {
+        if (!this.proc?.stdin?.writable)
+            return;
+        this.proc.stdin.write(JSON.stringify({
+            jsonrpc: '2.0',
+            id: rpcId,
+            error: { code: -32601, message },
+        }) + '\n');
+    }
+    resolveToolContext(params) {
+        const item = asRecord(params?.item) ?? params ?? null;
+        const callId = readItemId(item);
+        if (!callId)
+            return null;
+        const extracted = item ? extractToolContext(item) : null;
+        if (extracted) {
+            this.toolContextByCallId.set(callId, extracted);
+            return { callId, toolContext: extracted };
+        }
+        const remembered = this.toolContextByCallId.get(callId);
+        if (!remembered)
+            return null;
+        return { callId, toolContext: remembered };
+    }
+    createFallbackInput(params, excludedKeys) {
+        return params ? omitKeys(params, ['threadId', 'turnId', ...excludedKeys]) : {};
+    }
+    queueApprovalRequest(requestId, request, description) {
+        this.approvalRequests.set(requestId, request);
+        audit.emit('approval.request', { agent: 'codex', sessionId: this.threadId, toolName: request.toolName });
+        if (!this.handler) {
+            log.warn({ threadId: this.threadId, requestId, toolName: request.toolName }, 'approval request received without handler');
+            if (!this.respondApproval(requestId, false)) {
+                this.writeServerRequestError(request.rpcId, 'Approval handler unavailable');
+            }
+            return;
+        }
+        this.handler({
+            type: 'approval.request',
+            sessionId: this.threadId,
+            requestId,
+            toolName: request.toolName,
+            input: request.input,
+            description,
+            approvalContext: serializeApprovalContext(request),
+        });
+    }
+    handleServerRequest(method, rpcId, params) {
+        const requestId = String(rpcId);
+        const resolved = this.resolveToolContext(params);
+        if (method === 'item/commandExecution/requestApproval') {
+            this.queueApprovalRequest(requestId, {
+                kind: 'command-execution',
+                responseKind: 'v2',
+                rpcId,
+                toolName: resolved?.toolContext.toolName ?? 'Bash',
+                input: resolved?.toolContext.input ?? this.createFallbackInput(params, ['itemId', 'reason', 'description']),
+            }, readString(params?.reason) ?? readString(params?.description) ?? '');
+            return;
+        }
+        if (method === 'item/fileChange/requestApproval') {
+            this.queueApprovalRequest(requestId, {
+                kind: 'file-change',
+                responseKind: 'v2',
+                rpcId,
+                toolName: resolved?.toolContext.toolName ?? 'Patch',
+                input: resolved?.toolContext.input ?? this.createFallbackInput(params, ['itemId', 'reason', 'description']),
+            }, readString(params?.reason) ?? readString(params?.description) ?? '');
+            return;
+        }
+        if (method === 'item/tool/requestUserInput') {
+            const questions = params?.questions;
+            if (!looksLikeApprovalRequestUserInput(questions)) {
+                log.warn({ threadId: this.threadId, rpcId }, 'unsupported requestUserInput request');
+                this.writeServerRequestError(rpcId, 'Unsupported interactive request from Codex');
+                return;
+            }
+            const question = resolveApprovalQuestion(questions);
+            if (!question) {
+                this.writeServerRequestError(rpcId, 'Malformed requestUserInput approval request');
+                return;
+            }
+            this.queueApprovalRequest(requestId, {
+                kind: 'request-user-input-approval',
+                rpcId,
+                questionId: question.questionId,
+                approveLabel: question.approveLabel,
+                denyLabel: question.denyLabel,
+                toolName: resolved?.toolContext.toolName ?? 'Bash',
+                input: resolved?.toolContext.input ?? this.createFallbackInput(params, ['itemId', 'questions']),
+            }, readRequestUserInputDescription(questions));
+            return;
+        }
+        if (method === 'execCommandApproval') {
+            this.queueApprovalRequest(requestId, {
+                kind: 'exec-command-legacy',
+                rpcId,
+                toolName: resolved?.toolContext.toolName ?? 'Bash',
+                input: resolved?.toolContext.input ?? this.createFallbackInput(params, []),
+            }, readString(params?.reason) ?? readString(params?.description) ?? '');
+            return;
+        }
+        if (method === 'applyPatchApproval') {
+            this.queueApprovalRequest(requestId, {
+                kind: 'apply-patch-legacy',
+                rpcId,
+                toolName: resolved?.toolContext.toolName ?? 'Patch',
+                input: resolved?.toolContext.input ?? this.createFallbackInput(params, []),
+            }, readString(params?.reason) ?? readString(params?.description) ?? '');
+            return;
+        }
+        if (method === 'item/permissions/requestApproval') {
+            log.warn({ threadId: this.threadId, rpcId }, 'unsupported permissions approval request');
+            this.writeServerRequestError(rpcId, 'Unsupported permissions approval request');
+            return;
+        }
+        log.warn({ threadId: this.threadId, rpcId, method }, 'unsupported server request');
+        this.writeServerRequestError(rpcId, `Unsupported server request: ${method}`);
+    }
+    handleRaw(msg) {
+        log.debug({ method: msg.method ?? '(response)', rpcId: msg.id ?? '-' }, 'handleRaw');
+        if (msg.id != null && !msg.method && this.pending.has(msg.id)) {
+            const p = this.pending.get(msg.id);
+            this.pending.delete(msg.id);
+            if (msg.error) {
+                p.reject(new Error(msg.error.message ?? 'RPC error'));
+            }
+            else {
+                p.resolve(msg.result);
+            }
+            return;
+        }
+        const method = typeof msg.method === 'string' ? msg.method : undefined;
+        const params = asRecord(msg.params);
+        if (method && msg.id != null) {
+            this.handleServerRequest(method, msg.id, params ?? undefined);
+            return;
+        }
+        if (method) {
+            log.debug({ method, paramsPreview: JSON.stringify(params ?? {}).slice(0, 300) }, 'notification');
+        }
+        switch (method) {
+            case 'item/agentMessage/delta': {
+                const deltaText = (params?.text ?? params?.delta ?? params?.content ?? '');
+                if (deltaText && this.handler) {
+                    this.handler({
+                        type: 'text.delta',
+                        sessionId: this.threadId,
+                        content: deltaText,
+                    });
+                }
+                else if (!deltaText) {
+                    log.debug({ paramsKeys: Object.keys(params ?? {}) }, 'agentMessage/delta with empty text');
+                }
+                break;
+            }
+            case 'item/commandExecution/outputDelta':
+                if (params?.output && this.handler) {
+                    this.handler({
+                        type: 'tool.result',
+                        sessionId: this.threadId,
+                        toolCallId: params.itemId ?? '',
+                        output: String(params.output),
+                    });
+                }
+                break;
+            case 'item/started': {
+                const item = asRecord(params?.item);
+                const callId = readItemId(item);
+                const toolContext = item ? extractToolContext(item) : null;
+                if (callId && toolContext) {
+                    this.toolContextByCallId.set(callId, toolContext);
+                    if (this.handler) {
+                        this.handler({
+                            type: 'tool.call',
+                            sessionId: this.threadId,
+                            toolName: toolContext.toolName,
+                            input: toolContext.input,
+                            toolCallId: callId,
+                        });
+                    }
+                }
+                break;
+            }
+            case 'item/completed': {
+                const item = asRecord(params?.item) ?? params;
+                const callId = readItemId(item);
+                if (callId)
+                    this.toolContextByCallId.delete(callId);
+                break;
+            }
+            case 'turn/aborted': {
+                this.turnStartInFlight = false;
+                this.interruptRequestedDuringTurnStart = false;
+                const reason = readString(params?.reason) ?? readString(asRecord(params?.turn)?.reason);
+                log.info({ threadId: this.threadId, reason }, 'turn interrupted');
+                audit.emit('session.interrupted', {
+                    agent: 'codex',
+                    sessionId: this.threadId,
+                    ...(reason ? { reason } : {}),
+                });
+                if (this.handler) {
+                    this.handler({
+                        type: 'session.interrupted',
+                        sessionId: this.threadId,
+                    });
+                }
+                break;
+            }
+            case 'turn/completed': {
+                this.turnStartInFlight = false;
+                this.interruptRequestedDuringTurnStart = false;
+                const turn = asRecord(params?.turn);
+                const turnStatus = normalizeTurnStatus(turn?.status);
+                const rawUsage = asRecord(params?.usage);
+                const usage = rawUsage
+                    ? {
+                        inputTokens: Number(rawUsage.input_tokens ?? rawUsage.inputTokens ?? 0),
+                        outputTokens: Number(rawUsage.output_tokens ?? rawUsage.outputTokens ?? 0),
+                    }
+                    : undefined;
+                if (turnStatus && INTERRUPTED_TURN_STATUSES.has(turnStatus)) {
+                    log.info({ threadId: this.threadId, status: turnStatus }, 'turn interrupted');
+                    audit.emit('session.interrupted', {
+                        agent: 'codex',
+                        sessionId: this.threadId,
+                        status: turnStatus,
+                        ...(usage ? { usage } : {}),
+                    });
+                    if (this.handler) {
+                        this.handler({
+                            type: 'session.interrupted',
+                            sessionId: this.threadId,
+                        });
+                    }
+                    break;
+                }
+                log.info({ threadId: this.threadId, status: turnStatus ?? 'completed' }, 'turn completed');
+                audit.emit('session.done', { agent: 'codex', sessionId: this.threadId, usage });
+                if (this.handler) {
+                    this.handler({
+                        type: 'session.done',
+                        sessionId: this.threadId,
+                        usage,
+                    });
+                }
+                break;
+            }
+            default:
+                if (method) {
+                    log.debug({ method }, 'unhandled notification');
+                }
+                break;
+        }
+    }
+}
+//# sourceMappingURL=codex.js.map