agent-life-bridge 0.1.1

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

@@ -0,0 +1,1049 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { buildCodexFchConfigArgs, buildFchEnv, } from './fch-runtime-context.js';
+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,
+            fchContext: options.fchContext,
+        });
+        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,
+                onProgress: params.onProgress,
+                onAssistantMessage: params.onAssistantMessage,
+            });
+            const runtimeRestartCount = this.connection.getRestartCount() - restartCountBefore;
+            return {
+                text: completed.text,
+                messages: completed.messages,
+                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,
+            onProgress: params.onProgress,
+            onAssistantMessage: params.onAssistantMessage,
+        });
+        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,
+            messages: [],
+            settled: false,
+            timeoutMs: params.timeoutMs,
+            noProgressTimeoutMs: params.noProgressTimeoutMs > 0 ? params.noProgressTimeoutMs : undefined,
+            onProgress: params.onProgress,
+            onAssistantMessage: params.onAssistantMessage,
+            overallTimer: setTimeout(() => undefined, params.timeoutMs),
+            completion,
+            resolve,
+            reject,
+        };
+        this.armOverallTimer(state, params.timeoutMs);
+        return state;
+    }
+    armOverallTimer(state, timeoutMs) {
+        clearTimeout(state.overallTimer);
+        state.overallTimer = setTimeout(() => {
+            this.rejectTurn(state, new CodexAppServerTurnTimeoutError(`Codex turn exceeded timeout (${Math.round(timeoutMs / 1000)}s).`));
+            if (state.turnId) {
+                this.interruptTurn(state.turnId).catch(() => undefined);
+            }
+        }, timeoutMs);
+    }
+    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);
+        this.emitProgress(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);
+        const itemType = getString(item?.type);
+        if (itemType === 'agentMessage') {
+            const text = getString(item?.text);
+            if (!text) {
+                return;
+            }
+            state.lastText = text;
+            state.messages.push(text);
+            if (state.firstAgentMessageMs === undefined) {
+                state.firstAgentMessageMs = Date.now() - state.startedAt;
+            }
+            this.options.logger.info({
+                sessionId: state.sessionId,
+                threadId: state.threadId,
+                turnId: state.turnId,
+                messageIndex: state.messages.length,
+                textPreview: text.length > 200 ? `${text.slice(0, 200)}...` : text,
+            }, 'Codex app-server emitted agent message');
+            this.emitAssistantMessage(state, text);
+            return;
+        }
+        const progressText = summarizeProgressItem(item);
+        if (progressText) {
+            this.emitProgress(state, progressText);
+        }
+    }
+    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.messages.at(-1) ?? state.lastText ?? '',
+            messages: [...state.messages],
+            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 (message) {
+            this.emitProgress(state, message);
+        }
+        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);
+        }
+    }
+    emitProgress(state, text) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return;
+        }
+        this.armOverallTimer(state, state.timeoutMs);
+        try {
+            void Promise.resolve(state.onProgress?.(normalized)).catch((error) => {
+                this.options.logger.warn({
+                    sessionId: state.sessionId,
+                    threadId: state.threadId,
+                    turnId: state.turnId,
+                    err: error instanceof Error ? error.message : String(error),
+                }, 'Codex progress callback failed');
+            });
+        }
+        catch {
+            return;
+        }
+    }
+    emitAssistantMessage(state, text) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return;
+        }
+        this.armOverallTimer(state, state.timeoutMs);
+        try {
+            void Promise.resolve(state.onAssistantMessage?.(normalized)).catch((error) => {
+                this.options.logger.warn({
+                    sessionId: state.sessionId,
+                    threadId: state.threadId,
+                    turnId: state.turnId,
+                    err: error instanceof Error ? error.message : String(error),
+                }, 'Codex assistant message callback failed');
+            });
+        }
+        catch {
+            return;
+        }
+    }
+    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-life-bridge',
+                title: 'agent-life-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 env = {
+            ...process.env,
+            ...backend.env,
+            ...(this.options.fchContext ? buildFchEnv(this.options.fchContext) : {}),
+        };
+        for (const key of backend.clearEnv ?? []) {
+            delete env[key];
+        }
+        this.child = spawn(backend.command, [
+            ...buildCodexFchConfigArgs(this.options.fchContext),
+            'app-server',
+            ...appServerArgs,
+            '--listen',
+            listen,
+        ], {
+            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-life-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 ?? 'danger-full-access',
+        serviceName: appServer.serviceName ?? 'agent-life-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 ?? 'danger-full-access',
+        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 summarizeProgressItem(item) {
+    if (!item) {
+        return undefined;
+    }
+    const itemType = getString(item.type);
+    const command = getNestedString(item, [
+        ['command'],
+        ['cmd'],
+        ['input', 'command'],
+        ['input', 'cmd'],
+        ['payload', 'command'],
+        ['payload', 'cmd'],
+        ['data', 'command'],
+        ['data', 'cmd'],
+    ]);
+    if (command) {
+        return `执行命令: ${command}`;
+    }
+    const message = getNestedString(item, [
+        ['message'],
+        ['title'],
+        ['summary'],
+        ['text'],
+        ['input', 'description'],
+        ['payload', 'description'],
+        ['data', 'description'],
+    ]);
+    const query = findStringByKeysDeep(item, ['query', 'searchQuery', 'q', 'term', 'keyword', 'keywords']);
+    const url = findStringByKeysDeep(item, ['url', 'uri', 'link']);
+    const title = findStringByKeysDeep(item, ['title', 'name', 'label']);
+    const text = findStringByKeysDeep(item, ['text', 'description', 'summary', 'reason', 'status']);
+    switch (itemType) {
+        case 'userMessage':
+            if (message || text) {
+                return `收到问题: ${truncateProgressText(message ?? text ?? '')}`;
+            }
+            return '收到你的问题，开始处理...';
+        case 'reasoning':
+            if (message || text) {
+                return `思考中: ${truncateProgressText(message ?? text ?? '')}`;
+            }
+            return undefined;
+        case 'webSearch':
+            if (query) {
+                return `搜索网页: ${truncateProgressText(query)}`;
+            }
+            if (title || url) {
+                return `查看网页: ${truncateProgressText(title ?? url ?? '')}`;
+            }
+            break;
+        case 'open':
+        case 'click':
+        case 'find':
+            if (title || url || text) {
+                return `查看内容: ${truncateProgressText(title ?? url ?? text ?? '')}`;
+            }
+            break;
+        default:
+            break;
+    }
+    if (message) {
+        return truncateProgressText(message);
+    }
+    if (query) {
+        return `处理中: ${truncateProgressText(query)}`;
+    }
+    if (title || url || text) {
+        return truncateProgressText(title ?? url ?? text ?? '');
+    }
+    const deepString = findDescriptiveStringDeep(item);
+    if (deepString) {
+        return truncateProgressText(deepString);
+    }
+    if (itemType) {
+        return `步骤完成: ${itemType}`;
+    }
+    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 getNestedString(record, paths) {
+    for (const path of paths) {
+        let current = record;
+        for (const key of path) {
+            current = asRecord(current)?.[key];
+        }
+        const value = getString(current);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function findStringByKeysDeep(value, preferredKeys, maxDepth = 5) {
+    const lowered = new Set(preferredKeys.map((key) => key.toLowerCase()));
+    const queue = [{ value, depth: 0 }];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const { value: currentValue, depth } = current;
+        if (!currentValue || typeof currentValue !== 'object') {
+            continue;
+        }
+        if (visited.has(currentValue)) {
+            continue;
+        }
+        visited.add(currentValue);
+        if (depth > maxDepth) {
+            continue;
+        }
+        if (Array.isArray(currentValue)) {
+            for (const entry of currentValue) {
+                queue.push({ value: entry, depth: depth + 1 });
+            }
+            continue;
+        }
+        for (const [key, nested] of Object.entries(currentValue)) {
+            if (lowered.has(key.toLowerCase())) {
+                const direct = getString(nested);
+                if (direct && isDescriptiveProgressText(direct)) {
+                    return direct;
+                }
+            }
+        }
+        for (const nested of Object.values(currentValue)) {
+            queue.push({ value: nested, depth: depth + 1 });
+        }
+    }
+    return undefined;
+}
+function findDescriptiveStringDeep(value, maxDepth = 5) {
+    const queue = [{ value, depth: 0 }];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const { value: currentValue, depth } = current;
+        const direct = getString(currentValue);
+        if (direct && isDescriptiveProgressText(direct)) {
+            return direct;
+        }
+        if (!currentValue || typeof currentValue !== 'object') {
+            continue;
+        }
+        if (visited.has(currentValue)) {
+            continue;
+        }
+        visited.add(currentValue);
+        if (depth > maxDepth) {
+            continue;
+        }
+        if (Array.isArray(currentValue)) {
+            for (const entry of currentValue) {
+                queue.push({ value: entry, depth: depth + 1 });
+            }
+            continue;
+        }
+        for (const [key, nested] of Object.entries(currentValue)) {
+            if (IGNORED_PROGRESS_KEYS.has(key.toLowerCase())) {
+                continue;
+            }
+            queue.push({ value: nested, depth: depth + 1 });
+        }
+    }
+    return undefined;
+}
+const IGNORED_PROGRESS_KEYS = new Set([
+    'id',
+    'type',
+    'kind',
+    'status',
+    'role',
+    'index',
+]);
+function isDescriptiveProgressText(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return false;
+    }
+    if (normalized.length < 4) {
+        return false;
+    }
+    if (/^(ok|done|true|false|success|completed?)$/i.test(normalized)) {
+        return false;
+    }
+    if (/^[a-z0-9_-]{1,24}$/i.test(normalized)) {
+        return false;
+    }
+    return true;
+}
+function truncateProgressText(value, maxLength = 140) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}
+function getNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=codex-app-server-runtime.js.map