agents-bridge 0.1.1 → 0.1.3

package/dist/agents/codex-app-server-runtime.js

@@ -0,0 +1,772 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { isSessionExpiredError } from './cli-output.js';
+class CodexAppServerProcessError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CodexAppServerProcessError';
+    }
+}
+class CodexAppServerRpcError extends Error {
+    method;
+    code;
+    constructor(method, code, message) {
+        super(message);
+        this.method = method;
+        this.code = code;
+        this.name = 'CodexAppServerRpcError';
+    }
+}
+class CodexAppServerTurnTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CodexAppServerTurnTimeoutError';
+    }
+}
+export class CodexAppServerRuntime {
+    options;
+    connection;
+    loadedThreads = new Map();
+    activeTurnsByThread = new Map();
+    activeTurnsByTurn = new Map();
+    constructor(options) {
+        this.options = options;
+        this.connection = options.connection ?? new DefaultCodexAppServerConnection({
+            backend: options.backend,
+            logger: options.logger,
+        });
+        this.connection.onNotification((notification) => {
+            this.handleNotification(notification);
+        });
+        this.connection.onFatalError((error) => {
+            this.handleFatalError(error);
+        });
+    }
+    async run(params) {
+        const restartCountBefore = this.connection.getRestartCount();
+        await this.connection.ensureReady();
+        try {
+            const prepared = await this.ensureThread(params);
+            const completed = await this.runTurn({
+                sessionId: params.sessionId,
+                threadId: prepared.threadId,
+                model: params.model,
+                prompt: params.prompt,
+                imagePaths: params.imagePaths,
+                workspaceDir: params.workspaceDir,
+                timeoutMs: params.timeoutMs,
+                noProgressTimeoutMs: params.noProgressTimeoutMs,
+            });
+            const runtimeRestartCount = this.connection.getRestartCount() - restartCountBefore;
+            return {
+                text: completed.text,
+                cliSessionId: prepared.threadId,
+                isResume: prepared.isResume,
+                usage: completed.usage,
+                diagnostics: {
+                    queueWaitMs: 0,
+                    commandElapsedMs: completed.turnCompletedMs ?? Date.now() - completed.startedAt,
+                    totalElapsedMs: prepared.threadOperationElapsedMs + (completed.turnCompletedMs ?? Date.now() - completed.startedAt),
+                    outputMode: 'app-server',
+                    runtimeMode: 'app-server',
+                    hadStdout: false,
+                    hadStderr: false,
+                    firstAgentMessageMs: completed.firstAgentMessageMs,
+                    threadStartedMs: prepared.threadOperation === 'start' ? prepared.threadOperationElapsedMs : undefined,
+                    turnCompletedMs: completed.turnCompletedMs,
+                    reconnectCount: completed.reconnectCount,
+                    fellBackToHttps: completed.fellBackToHttps,
+                    runtimeRestartCount: runtimeRestartCount > 0 ? runtimeRestartCount : undefined,
+                    threadOperation: prepared.threadOperation,
+                    threadOperationElapsedMs: prepared.threadOperationElapsedMs,
+                    cliSessionIdSource: prepared.threadOperation === 'start' ? 'parsed' : 'existing',
+                },
+            };
+        }
+        catch (error) {
+            if (isSessionExpiredError(error)) {
+                this.loadedThreads.delete(params.sessionId);
+            }
+            throw error;
+        }
+    }
+    async teardown() {
+        this.loadedThreads.clear();
+        this.activeTurnsByThread.clear();
+        this.activeTurnsByTurn.clear();
+        await this.connection.dispose();
+    }
+    async ensureThread(params) {
+        const existingThreadId = params.existingThreadId?.trim() || undefined;
+        const loaded = this.loadedThreads.get(params.sessionId);
+        if (!existingThreadId && loaded) {
+            this.loadedThreads.delete(params.sessionId);
+        }
+        if (loaded && existingThreadId && loaded.threadId === existingThreadId) {
+            return {
+                threadId: existingThreadId,
+                isResume: true,
+                threadOperation: 'reuse',
+                threadOperationElapsedMs: 0,
+            };
+        }
+        const requestTimeoutMs = this.resolveRequestTimeout(params.timeoutMs);
+        if (existingThreadId) {
+            const startedAt = Date.now();
+            const response = await this.connection.request('thread/resume', buildThreadResumeParams({
+                backend: this.options.backend,
+                threadId: existingThreadId,
+                model: params.model,
+                workspaceDir: params.workspaceDir,
+            }), requestTimeoutMs);
+            const threadId = getThreadIdFromResponse(response) ?? existingThreadId;
+            this.loadedThreads.set(params.sessionId, { threadId });
+            return {
+                threadId,
+                isResume: true,
+                threadOperation: 'resume',
+                threadOperationElapsedMs: Date.now() - startedAt,
+            };
+        }
+        const startedAt = Date.now();
+        const response = await this.connection.request('thread/start', buildThreadStartParams({
+            backend: this.options.backend,
+            model: params.model,
+            workspaceDir: params.workspaceDir,
+            systemPrompt: params.systemPrompt,
+        }), requestTimeoutMs);
+        const threadId = getThreadIdFromResponse(response);
+        if (!threadId) {
+            throw new Error('thread/start succeeded but did not return a thread id');
+        }
+        this.loadedThreads.set(params.sessionId, { threadId });
+        return {
+            threadId,
+            isResume: false,
+            threadOperation: 'start',
+            threadOperationElapsedMs: Date.now() - startedAt,
+        };
+    }
+    async runTurn(params) {
+        const startedAt = Date.now();
+        const state = this.createActiveTurnState({
+            sessionId: params.sessionId,
+            threadId: params.threadId,
+            timeoutMs: params.timeoutMs,
+            noProgressTimeoutMs: params.noProgressTimeoutMs,
+            startedAt,
+        });
+        this.activeTurnsByThread.set(params.threadId, state);
+        try {
+            const response = await this.connection.request('turn/start', buildTurnStartParams({
+                backend: this.options.backend,
+                threadId: params.threadId,
+                model: params.model,
+                prompt: params.prompt,
+                imagePaths: params.imagePaths,
+                workspaceDir: params.workspaceDir,
+            }), this.resolveRequestTimeout(params.timeoutMs));
+            const turnId = getTurnIdFromResponse(response);
+            if (!state.settled && turnId) {
+                this.bindTurnId(state, turnId);
+            }
+            if (!state.settled && params.noProgressTimeoutMs > 0) {
+                this.armNoProgressTimer(state, params.noProgressTimeoutMs);
+            }
+            const completed = await state.completion;
+            return {
+                ...completed,
+                startedAt,
+            };
+        }
+        catch (error) {
+            this.cleanupTurnState(state);
+            throw error;
+        }
+    }
+    createActiveTurnState(params) {
+        let state;
+        let resolve;
+        let reject;
+        const completion = new Promise((resolvePromise, rejectPromise) => {
+            resolve = resolvePromise;
+            reject = rejectPromise;
+        });
+        void completion.catch(() => undefined);
+        state = {
+            sessionId: params.sessionId,
+            threadId: params.threadId,
+            startedAt: params.startedAt,
+            reconnectCount: 0,
+            fellBackToHttps: false,
+            settled: false,
+            noProgressTimeoutMs: params.noProgressTimeoutMs > 0 ? params.noProgressTimeoutMs : undefined,
+            overallTimer: setTimeout(() => {
+                this.rejectTurn(state, new CodexAppServerTurnTimeoutError(`Codex turn exceeded timeout (${Math.round(params.timeoutMs / 1000)}s).`));
+                if (state.turnId) {
+                    this.interruptTurn(state.turnId).catch(() => undefined);
+                }
+            }, params.timeoutMs),
+            completion,
+            resolve,
+            reject,
+        };
+        return state;
+    }
+    armNoProgressTimer(state, noProgressTimeoutMs) {
+        clearTimeout(state.noProgressTimer);
+        state.noProgressTimer = setTimeout(() => {
+            this.rejectTurn(state, new CodexAppServerTurnTimeoutError(`Codex turn produced no progress for ${Math.round(noProgressTimeoutMs / 1000)}s.`));
+            if (state.turnId) {
+                this.interruptTurn(state.turnId).catch(() => undefined);
+            }
+        }, noProgressTimeoutMs);
+    }
+    bindTurnId(state, turnId) {
+        if (state.turnId === turnId) {
+            return;
+        }
+        if (state.turnId) {
+            this.activeTurnsByTurn.delete(state.turnId);
+        }
+        state.turnId = turnId;
+        this.activeTurnsByTurn.set(turnId, state);
+    }
+    handleNotification(notification) {
+        switch (notification.method) {
+            case 'turn/started':
+                this.handleTurnStarted(notification.params);
+                break;
+            case 'item/completed':
+                this.handleItemCompleted(notification.params);
+                break;
+            case 'thread/tokenUsage/updated':
+                this.handleTokenUsageUpdated(notification.params);
+                break;
+            case 'turn/completed':
+                this.handleTurnCompleted(notification.params);
+                break;
+            case 'error':
+                this.handleTurnError(notification.params);
+                break;
+            default:
+                break;
+        }
+    }
+    handleTurnStarted(params) {
+        const record = asRecord(params);
+        const threadId = getString(record?.threadId);
+        const turn = asRecord(record?.turn);
+        const turnId = getString(turn?.id);
+        const state = this.findTurnState(threadId, turnId);
+        if (!state) {
+            return;
+        }
+        if (turnId) {
+            this.bindTurnId(state, turnId);
+        }
+        this.noteTurnProgress(state);
+    }
+    handleItemCompleted(params) {
+        const record = asRecord(params);
+        const threadId = getString(record?.threadId);
+        const turnId = getString(record?.turnId);
+        const state = this.findTurnState(threadId, turnId);
+        if (!state) {
+            return;
+        }
+        if (turnId) {
+            this.bindTurnId(state, turnId);
+        }
+        this.noteTurnProgress(state);
+        const item = asRecord(record?.item);
+        if (getString(item?.type) !== 'agentMessage') {
+            return;
+        }
+        const text = getString(item?.text);
+        if (!text) {
+            return;
+        }
+        state.lastText = text;
+        if (state.firstAgentMessageMs === undefined) {
+            state.firstAgentMessageMs = Date.now() - state.startedAt;
+        }
+    }
+    handleTokenUsageUpdated(params) {
+        const record = asRecord(params);
+        const threadId = getString(record?.threadId);
+        const turnId = getString(record?.turnId);
+        const state = this.findTurnState(threadId, turnId);
+        if (!state) {
+            return;
+        }
+        if (turnId) {
+            this.bindTurnId(state, turnId);
+        }
+        state.usage = toCliUsage(asRecord(record?.tokenUsage));
+    }
+    handleTurnCompleted(params) {
+        const record = asRecord(params);
+        const threadId = getString(record?.threadId);
+        const turn = asRecord(record?.turn);
+        const turnId = getString(turn?.id);
+        const state = this.findTurnState(threadId, turnId);
+        if (!state) {
+            return;
+        }
+        if (turnId) {
+            this.bindTurnId(state, turnId);
+        }
+        this.noteTurnProgress(state);
+        state.turnCompletedMs = Date.now() - state.startedAt;
+        const failureMessage = getTurnFailureMessage(turn);
+        if (failureMessage) {
+            this.rejectTurn(state, new Error(failureMessage));
+            return;
+        }
+        this.resolveTurn(state, {
+            text: state.lastText ?? '',
+            usage: state.usage,
+            reconnectCount: state.reconnectCount,
+            fellBackToHttps: state.fellBackToHttps,
+            firstAgentMessageMs: state.firstAgentMessageMs,
+            turnCompletedMs: state.turnCompletedMs,
+        });
+    }
+    handleTurnError(params) {
+        const record = asRecord(params);
+        const threadId = getString(record?.threadId);
+        const turnId = getString(record?.turnId);
+        const state = this.findTurnState(threadId, turnId);
+        if (!state) {
+            return;
+        }
+        if (turnId) {
+            this.bindTurnId(state, turnId);
+        }
+        this.noteTurnProgress(state);
+        const error = asRecord(record?.error);
+        const message = `${getString(error?.message) ?? ''}\n${getString(error?.additionalDetails) ?? ''}`.trim();
+        if (RECONNECT_PATTERN.test(message)) {
+            state.reconnectCount += 1;
+        }
+        if (HTTPS_FALLBACK_PATTERN.test(message)) {
+            state.fellBackToHttps = true;
+        }
+        const willRetry = Boolean(record?.willRetry);
+        if (!willRetry) {
+            this.rejectTurn(state, new Error(getString(error?.message) ?? 'Codex turn failed'));
+        }
+    }
+    handleFatalError(error) {
+        this.loadedThreads.clear();
+        const states = new Set(this.activeTurnsByThread.values());
+        for (const state of states) {
+            this.rejectTurn(state, error);
+        }
+    }
+    noteTurnProgress(state) {
+        if (state.noProgressTimeoutMs) {
+            this.armNoProgressTimer(state, state.noProgressTimeoutMs);
+        }
+    }
+    findTurnState(threadId, turnId) {
+        if (turnId) {
+            const byTurn = this.activeTurnsByTurn.get(turnId);
+            if (byTurn) {
+                return byTurn;
+            }
+        }
+        if (threadId) {
+            return this.activeTurnsByThread.get(threadId);
+        }
+        return undefined;
+    }
+    resolveTurn(state, value) {
+        if (state.settled) {
+            return;
+        }
+        state.settled = true;
+        this.cleanupTurnState(state);
+        state.resolve(value);
+    }
+    rejectTurn(state, error) {
+        if (state.settled) {
+            return;
+        }
+        state.settled = true;
+        this.cleanupTurnState(state);
+        state.reject(error);
+    }
+    cleanupTurnState(state) {
+        clearTimeout(state.overallTimer);
+        clearTimeout(state.noProgressTimer);
+        this.activeTurnsByThread.delete(state.threadId);
+        if (state.turnId) {
+            this.activeTurnsByTurn.delete(state.turnId);
+        }
+    }
+    async interruptTurn(turnId) {
+        await this.connection.request('turn/interrupt', { turnId }, Math.max(5_000, Math.min(this.resolveRequestTimeout(15_000), 15_000))).catch(() => undefined);
+    }
+    resolveRequestTimeout(timeoutMs) {
+        const configured = this.options.backend.appServer?.requestTimeoutMs ?? 30_000;
+        return Math.max(1_000, Math.min(timeoutMs, configured));
+    }
+}
+class DefaultCodexAppServerConnection {
+    options;
+    child = null;
+    stdoutReader = null;
+    stderrReader = null;
+    readyPromise = null;
+    pending = new Map();
+    nextId = 1;
+    initialized = false;
+    disposed = false;
+    notificationListeners = new Set();
+    fatalListeners = new Set();
+    restartCount = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    async ensureReady() {
+        if (this.disposed) {
+            throw new CodexAppServerProcessError('Codex app-server runtime is already shut down');
+        }
+        if (this.child && this.initialized) {
+            return;
+        }
+        if (this.readyPromise) {
+            return this.readyPromise;
+        }
+        this.readyPromise = this.startAndInitialize().finally(() => {
+            this.readyPromise = null;
+        });
+        return this.readyPromise;
+    }
+    async request(method, params, timeoutMs) {
+        return this.sendRequest(method, params, timeoutMs, true);
+    }
+    async sendRequest(method, params, timeoutMs, ensureReady) {
+        if (ensureReady) {
+            await this.ensureReady();
+        }
+        if (!this.child?.stdin.writable) {
+            throw new CodexAppServerProcessError('Codex app-server stdin is not writable');
+        }
+        const id = this.nextId++;
+        const payload = JSON.stringify({
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new CodexAppServerRpcError(method, undefined, `${method} timed out after ${Math.round(timeoutMs / 1000)}s`));
+            }, timeoutMs);
+            this.pending.set(id, {
+                method,
+                timer,
+                resolve: resolve,
+                reject,
+            });
+            this.child?.stdin.write(`${payload}\n`);
+        });
+    }
+    notify(method, params) {
+        if (!this.child?.stdin.writable) {
+            return;
+        }
+        const message = {
+            jsonrpc: '2.0',
+            method,
+        };
+        if (params !== undefined) {
+            message.params = params;
+        }
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    getRestartCount() {
+        return Math.max(0, this.restartCount - 1);
+    }
+    onNotification(listener) {
+        this.notificationListeners.add(listener);
+    }
+    onFatalError(listener) {
+        this.fatalListeners.add(listener);
+    }
+    async dispose() {
+        this.disposed = true;
+        this.initialized = false;
+        const child = this.child;
+        if (!child) {
+            return;
+        }
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                child.kill();
+                resolve();
+            }, 2_000);
+            child.once('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            child.kill();
+        });
+    }
+    async startAndInitialize() {
+        const startupTimeoutMs = this.options.backend.appServer?.startupTimeoutMs ?? 15_000;
+        await this.spawnProcess();
+        const initTimeoutMs = Math.max(1_000, startupTimeoutMs);
+        await this.sendRequest('initialize', {
+            clientInfo: {
+                name: 'agent-bridge',
+                title: 'agent-bridge',
+                version: '0.1.0',
+            },
+            capabilities: {
+                experimentalApi: this.options.backend.appServer?.experimentalApi ?? false,
+                optOutNotificationMethods: this.options.backend.appServer?.optOutNotificationMethods ?? [],
+            },
+        }, initTimeoutMs, false);
+        this.notify('initialized');
+        this.initialized = true;
+    }
+    async spawnProcess() {
+        const backend = this.options.backend;
+        const appServerArgs = backend.appServer?.args ?? [];
+        const listen = backend.appServer?.listen ?? 'stdio://';
+        const sessionSource = backend.appServer?.sessionSource ?? 'agent-bridge';
+        const env = { ...process.env, ...backend.env };
+        for (const key of backend.clearEnv ?? []) {
+            delete env[key];
+        }
+        this.child = spawn(backend.command, [
+            'app-server',
+            ...appServerArgs,
+            '--listen',
+            listen,
+            '--session-source',
+            sessionSource,
+        ], {
+            env,
+            stdio: 'pipe',
+            shell: process.platform === 'win32',
+            windowsHide: true,
+        });
+        this.stdoutReader = createInterface({
+            input: this.child.stdout,
+            crlfDelay: Infinity,
+        });
+        this.stderrReader = createInterface({
+            input: this.child.stderr,
+            crlfDelay: Infinity,
+        });
+        this.stdoutReader.on('line', (line) => {
+            this.handleStdoutLine(line);
+        });
+        this.stderrReader.on('line', (line) => {
+            this.options.logger.debug({ line }, 'Codex app-server stderr');
+        });
+        this.child.on('error', (error) => {
+            this.failAll(new CodexAppServerProcessError(error.message));
+        });
+        this.child.on('exit', (code, signal) => {
+            this.initialized = false;
+            this.stdoutReader?.close();
+            this.stderrReader?.close();
+            this.stdoutReader = null;
+            this.stderrReader = null;
+            this.child = null;
+            if (this.disposed) {
+                return;
+            }
+            this.failAll(new CodexAppServerProcessError(`Codex app-server exited unexpectedly (code=${code ?? 'null'}, signal=${signal ?? 'null'})`));
+        });
+        this.restartCount += 1;
+    }
+    handleStdoutLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            this.options.logger.warn({ line: trimmed }, 'Codex app-server emitted non-JSON stdout line');
+            return;
+        }
+        const id = typeof parsed.id === 'number' ? parsed.id : undefined;
+        const hasResult = Object.prototype.hasOwnProperty.call(parsed, 'result');
+        const hasError = Object.prototype.hasOwnProperty.call(parsed, 'error');
+        const method = getString(parsed.method);
+        if (id !== undefined && (hasResult || hasError)) {
+            const pending = this.pending.get(id);
+            if (!pending) {
+                return;
+            }
+            clearTimeout(pending.timer);
+            this.pending.delete(id);
+            if (parsed.error) {
+                const error = asRecord(parsed.error);
+                pending.reject(new CodexAppServerRpcError(pending.method, typeof error?.code === 'number' ? error.code : undefined, getString(error?.message) ?? `${pending.method} failed`));
+                return;
+            }
+            pending.resolve(parsed.result);
+            return;
+        }
+        if (id !== undefined && method) {
+            this.replyUnsupportedServerRequest(parsed);
+            return;
+        }
+        if (!method) {
+            return;
+        }
+        const notification = {
+            method,
+            params: parsed.params,
+        };
+        for (const listener of this.notificationListeners) {
+            listener(notification);
+        }
+    }
+    replyUnsupportedServerRequest(parsed) {
+        if (!this.child?.stdin.writable || typeof parsed.id !== 'number') {
+            return;
+        }
+        this.child.stdin.write(`${JSON.stringify({
+            jsonrpc: '2.0',
+            id: parsed.id,
+            error: {
+                code: -32601,
+                message: 'agent-bridge does not handle app-server initiated requests',
+            },
+        })}\n`);
+    }
+    failAll(error) {
+        const pending = Array.from(this.pending.values());
+        this.pending.clear();
+        for (const request of pending) {
+            clearTimeout(request.timer);
+            request.reject(error);
+        }
+        for (const listener of this.fatalListeners) {
+            listener(error);
+        }
+    }
+}
+const RECONNECT_PATTERN = /reconnecting\.\.\./i;
+const HTTPS_FALLBACK_PATTERN = /falling back from websockets to https transport/i;
+function buildThreadStartParams(params) {
+    const appServer = params.backend.appServer ?? {};
+    return {
+        model: params.model,
+        cwd: params.workspaceDir,
+        approvalPolicy: appServer.approvalPolicy ?? 'never',
+        sandbox: appServer.sandbox ?? 'read-only',
+        serviceName: appServer.serviceName ?? 'agent-bridge',
+        developerInstructions: params.systemPrompt?.trim() || undefined,
+        experimentalRawEvents: appServer.experimentalRawEvents ?? false,
+        persistExtendedHistory: appServer.persistExtendedHistory ?? false,
+    };
+}
+function buildThreadResumeParams(params) {
+    const appServer = params.backend.appServer ?? {};
+    return {
+        threadId: params.threadId,
+        model: params.model,
+        cwd: params.workspaceDir,
+        approvalPolicy: appServer.approvalPolicy ?? 'never',
+        sandbox: appServer.sandbox ?? 'read-only',
+        persistExtendedHistory: appServer.persistExtendedHistory ?? false,
+    };
+}
+function buildTurnStartParams(params) {
+    const appServer = params.backend.appServer ?? {};
+    return {
+        threadId: params.threadId,
+        input: buildTurnInput(params.prompt, params.imagePaths),
+        cwd: params.workspaceDir,
+        approvalPolicy: appServer.approvalPolicy ?? 'never',
+        model: params.model,
+    };
+}
+function buildTurnInput(prompt, imagePaths) {
+    const input = [];
+    if (prompt.trim()) {
+        input.push({
+            type: 'text',
+            text: prompt.trim(),
+            text_elements: [],
+        });
+    }
+    for (const imagePath of imagePaths ?? []) {
+        input.push({
+            type: 'localImage',
+            path: imagePath,
+        });
+    }
+    return input;
+}
+function getThreadIdFromResponse(response) {
+    const record = asRecord(response);
+    const thread = asRecord(record?.thread);
+    return getString(thread?.id);
+}
+function getTurnIdFromResponse(response) {
+    const record = asRecord(response);
+    const turn = asRecord(record?.turn);
+    return getString(turn?.id);
+}
+function getTurnFailureMessage(turn) {
+    if (!turn) {
+        return undefined;
+    }
+    const status = getString(turn.status);
+    const error = asRecord(turn.error);
+    const message = getString(error?.message);
+    if (message) {
+        return message;
+    }
+    if (status && status !== 'completed') {
+        return `Codex turn finished with status ${status}`;
+    }
+    return undefined;
+}
+function toCliUsage(tokenUsage) {
+    const breakdown = asRecord(tokenUsage?.last);
+    if (!breakdown) {
+        return undefined;
+    }
+    const input = getNumber(breakdown.inputTokens);
+    const output = getNumber(breakdown.outputTokens);
+    const cacheRead = getNumber(breakdown.cachedInputTokens);
+    const total = getNumber(breakdown.totalTokens);
+    if ([input, output, cacheRead, total].every((value) => value === undefined)) {
+        return undefined;
+    }
+    return {
+        input,
+        output,
+        cacheRead,
+        total,
+    };
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function getString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function getNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=codex-app-server-runtime.js.map