@vibelet/cli 0.1.37 → 1.0.0

package/dist/drivers/codex.js

@@ -1,771 +0,0 @@
-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