@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/adapters/codex/src/runtime/session-common.js

@@ -0,0 +1,364 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from '@vibe-forge/hooks';
+import { createLogger } from '@vibe-forge/utils/create-logger';
+import { resolveCodexBinaryPath } from '#~/paths.js';
+import { CodexRpcError } from '#~/protocol/rpc.js';
+import { CODEX_PROXY_META_HEADER_NAME, encodeCodexProxyMeta, ensureCodexProxyServer } from './proxy';
+/**
+ * Map a single vibe-forge `AdapterMessageContent` item to zero or one Codex input items.
+ */
+function mapSingleContentToCodexInput(item) {
+    if (item.type === 'text' && typeof item.text === 'string') {
+        return { type: 'text', text: item.text };
+    }
+    if (item.type === 'image' && typeof item.url === 'string') {
+        // data: URIs are not supported as inline image inputs by Codex app-server
+        if (item.url.startsWith('data:')) {
+            return { type: 'text', text: '[Image: base64 data not supported inline]' };
+        }
+        return { type: 'image', url: item.url };
+    }
+    return null;
+}
+function buildSpawnEnv(env) {
+    return {
+        ...process.env,
+        ...Object.fromEntries(Object.entries(env).filter((entry) => entry[1] != null))
+    };
+}
+function resolveApprovalPolicy(permissionMode) {
+    if (permissionMode === 'bypassPermissions' || permissionMode === 'dontAsk')
+        return 'never';
+    if (permissionMode === 'plan')
+        return 'onRequest';
+    return 'unlessTrusted';
+}
+function shouldUseYolo(permissionMode) {
+    return permissionMode === 'bypassPermissions';
+}
+export function toCodexOutboundApprovalPolicy(approvalPolicy) {
+    return approvalPolicy === 'unlessTrusted'
+        ? 'untrusted'
+        : approvalPolicy === 'onRequest'
+            ? 'on-request'
+            : 'never';
+}
+/**
+ * Encode a string value as a TOML inline string (JSON encoding is a valid subset).
+ */
+const toToml = (value) => JSON.stringify(value);
+const isPlainObject = (value) => value != null && typeof value === 'object' && !Array.isArray(value);
+const normalizeStringRecord = (value) => {
+    if (!isPlainObject(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+};
+const normalizePositiveInteger = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : undefined);
+const resolveRoutedServiceKey = (rawModel) => {
+    const normalizedRawModel = rawModel?.trim();
+    if (normalizedRawModel == null || !normalizedRawModel.includes(','))
+        return undefined;
+    const commaIdx = normalizedRawModel.indexOf(',');
+    return normalizedRawModel.slice(0, commaIdx).trim() || undefined;
+};
+const normalizeProviderBaseUrl = (apiBaseUrl, wireApi) => {
+    if (typeof apiBaseUrl !== 'string' || apiBaseUrl.trim() === '')
+        return undefined;
+    return (wireApi ?? 'responses') === 'responses' && apiBaseUrl.endsWith('/responses')
+        ? apiBaseUrl.slice(0, -'/responses'.length)
+        : apiBaseUrl;
+};
+/**
+ * Encode a flat string→string record as a TOML inline table: `{key = "value", …}`.
+ */
+const toTomlInlineTable = (obj) => `{${Object.entries(obj).map(([k, v]) => `${k} = ${JSON.stringify(v)}`).join(', ')}}`;
+/**
+ * Derive the `-c key=value` overrides and API-key env injections needed to map
+ * vibe-forge `systemPrompt` and `modelServices` onto codex configuration.
+ *
+ * model format: plain `"gpt-4o"` — used as-is;
+ *               `"service,model"` — routes through the named model service.
+ */
+function buildCodexConfigOverrides(params) {
+    const { systemPrompt, rawModel, modelServices, proxyBaseUrl, proxyLogContext } = params;
+    const args = [];
+    const fingerprintArgs = [];
+    const normalizedRawModel = rawModel?.trim();
+    const pushArgs = (value) => {
+        args.push('-c', value);
+    };
+    const pushFingerprintArgs = (value) => {
+        fingerprintArgs.push('-c', value);
+    };
+    const pushBoth = (value) => {
+        pushArgs(value);
+        pushFingerprintArgs(value);
+    };
+    if (systemPrompt) {
+        pushBoth(`developer_instructions=${toToml(systemPrompt)}`);
+    }
+    let resolvedModel;
+    let resolvedMaxOutputTokens;
+    if (normalizedRawModel?.toLowerCase() === 'default') {
+        resolvedModel = undefined;
+    }
+    else if (normalizedRawModel?.includes(',')) {
+        const commaIdx = normalizedRawModel.indexOf(',');
+        const serviceKey = normalizedRawModel.slice(0, commaIdx).trim();
+        const modelId = normalizedRawModel.slice(commaIdx + 1).trim();
+        const service = modelServices[serviceKey];
+        if (service) {
+            const { title, apiBaseUrl, apiKey, extra, timeoutMs, maxOutputTokens } = service;
+            const { wireApi, queryParams, headers } = extra?.codex ?? {};
+            const prefix = `model_providers.${serviceKey}`;
+            const normalizedBaseUrl = normalizeProviderBaseUrl(apiBaseUrl, wireApi);
+            const normalizedHeaders = normalizeStringRecord(headers);
+            const normalizedQueryParams = normalizeStringRecord(queryParams);
+            const normalizedTimeoutMs = normalizePositiveInteger(timeoutMs);
+            const normalizedMaxOutputTokens = normalizePositiveInteger(maxOutputTokens);
+            const shouldProxyProvider = proxyBaseUrl != null && normalizedBaseUrl != null;
+            pushBoth(`model_provider=${toToml(serviceKey)}`);
+            pushBoth(`${prefix}.name=${toToml(title ?? serviceKey)}`);
+            if (shouldProxyProvider) {
+                const proxyMeta = encodeCodexProxyMeta({
+                    upstreamBaseUrl: normalizedBaseUrl,
+                    ...(Object.keys(normalizedHeaders).length > 0 ? { headers: normalizedHeaders } : {}),
+                    ...(Object.keys(normalizedQueryParams).length > 0 ? { queryParams: normalizedQueryParams } : {}),
+                    ...(normalizedMaxOutputTokens != null ? { maxOutputTokens: normalizedMaxOutputTokens } : {}),
+                    ...(proxyLogContext != null ? { logContext: proxyLogContext } : {})
+                });
+                pushArgs(`${prefix}.base_url=${toToml(proxyBaseUrl)}`);
+                pushFingerprintArgs(`${prefix}.base_url=${toToml(normalizedBaseUrl)}`);
+                pushBoth(`${prefix}.http_headers=${toTomlInlineTable({ [CODEX_PROXY_META_HEADER_NAME]: proxyMeta })}`);
+            }
+            else if (normalizedBaseUrl != null) {
+                pushBoth(`${prefix}.base_url=${toToml(normalizedBaseUrl)}`);
+            }
+            if (apiKey) {
+                pushBoth(`${prefix}.experimental_bearer_token=${toToml(apiKey)}`);
+            }
+            if (wireApi) {
+                pushBoth(`${prefix}.wire_api=${toToml(wireApi)}`);
+            }
+            if (!shouldProxyProvider && Object.keys(normalizedHeaders).length > 0) {
+                pushBoth(`${prefix}.http_headers=${toTomlInlineTable(normalizedHeaders)}`);
+            }
+            if (normalizedTimeoutMs != null) {
+                pushBoth(`${prefix}.stream_idle_timeout_ms=${normalizedTimeoutMs}`);
+            }
+            resolvedMaxOutputTokens = shouldProxyProvider && normalizedMaxOutputTokens != null
+                ? null
+                : normalizedMaxOutputTokens;
+            if (!shouldProxyProvider && Object.keys(normalizedQueryParams).length > 0) {
+                pushBoth(`${prefix}.query_params=${toTomlInlineTable(normalizedQueryParams)}`);
+            }
+        }
+        resolvedModel = modelId || undefined;
+    }
+    else {
+        resolvedModel = normalizedRawModel || undefined;
+    }
+    return { args, fingerprintArgs, resolvedModel, resolvedMaxOutputTokens };
+}
+/**
+ * Build `-c mcp_servers.<name>.*` overrides for each filtered MCP server.
+ */
+function buildMcpConfigArgs(servers) {
+    const args = [];
+    for (const [name, server] of Object.entries(servers)) {
+        const { command, args: cmdArgs, env, url, headers } = server;
+        const prefix = `mcp_servers.${name}`;
+        if (typeof command === 'string') {
+            args.push('-c', `${prefix}.command=${toToml(command)}`);
+            if (Array.isArray(cmdArgs) && cmdArgs.length > 0) {
+                args.push('-c', `${prefix}.args=${JSON.stringify(cmdArgs)}`);
+            }
+            if (env != null) {
+                args.push('-c', `${prefix}.env=${toTomlInlineTable(env)}`);
+            }
+        }
+        else if (typeof url === 'string') {
+            args.push('-c', `${prefix}.url=${toToml(url)}`);
+            if (headers != null && Object.keys(headers).length > 0) {
+                args.push('-c', `${prefix}.http_headers=${toTomlInlineTable(headers)}`);
+            }
+        }
+    }
+    return args;
+}
+/**
+ * Build `--enable <name>` / `--disable <name>` args from a features map.
+ */
+export function buildFeatureArgs(features) {
+    const args = [];
+    for (const [name, enabled] of Object.entries(features)) {
+        args.push(enabled ? '--enable' : '--disable', name);
+    }
+    return args;
+}
+/**
+ * Map an array of vibe-forge `AdapterMessageContent` to Codex `turn/start` input items.
+ */
+export function mapContentToCodexInput(content) {
+    return content
+        .map(mapSingleContentToCodexInput)
+        .filter((x) => x != null);
+}
+export const getErrorSummary = (err) => (err instanceof Error ? err.message : String(err));
+export const getErrorDetails = (err) => (err instanceof CodexRpcError ? err.data : undefined);
+const formatErrorDetails = (value) => {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+};
+export const getErrorMessage = (err) => {
+    const summary = getErrorSummary(err);
+    const details = formatErrorDetails(getErrorDetails(err));
+    return details ? `${summary}\nDetails: ${details}` : summary;
+};
+export const toAdapterErrorData = (err, overrides = {}) => ({
+    message: overrides.message ?? getErrorSummary(err),
+    ...(overrides.code != null
+        ? { code: overrides.code }
+        : err instanceof CodexRpcError
+            ? { code: String(err.code) }
+            : {}),
+    ...(overrides.details !== undefined
+        ? { details: overrides.details }
+        : getErrorDetails(err) !== undefined
+            ? { details: getErrorDetails(err) }
+            : {}),
+    fatal: overrides.fatal ?? true
+});
+export const isInvalidEncryptedContentError = (err) => {
+    const message = getErrorMessage(err);
+    return message.includes('invalid_encrypted_content') || message.includes('organization_id did not match');
+};
+async function buildThreadCacheKey(params) {
+    const authPath = resolve(process.env.HOME, '.codex', 'auth.json');
+    let authDigest;
+    try {
+        const authContent = await readFile(authPath, 'utf8');
+        authDigest = createHash('sha256').update(authContent).digest('hex');
+    }
+    catch {
+        authDigest = undefined;
+    }
+    const fingerprint = createHash('sha256')
+        .update(JSON.stringify({
+        cwd: params.cwd,
+        useYolo: params.useYolo,
+        approvalPolicy: params.approvalPolicy,
+        sandboxPolicy: params.sandboxPolicy,
+        model: params.resolvedModel ?? null,
+        configOverrideArgs: params.configFingerprintArgs,
+        features: params.features,
+        authDigest: authDigest ?? null
+    }))
+        .digest('hex');
+    return `context:${fingerprint}`;
+}
+export async function resolveSessionBase(ctx, options) {
+    const { logger, cwd, env, cache, configs: [config, userConfig] } = ctx;
+    const { sandboxPolicy: configSandboxPolicy, features: configFeatures } = {
+        ...(config?.adapters?.codex ?? {}),
+        ...(userConfig?.adapters?.codex ?? {})
+    };
+    const useYolo = shouldUseYolo(options.permissionMode);
+    const approvalPolicy = resolveApprovalPolicy(options.permissionMode);
+    const sandboxPolicy = useYolo
+        ? { type: 'dangerFullAccess' }
+        : (configSandboxPolicy ?? { type: 'workspaceWrite' });
+    const features = { ...(configFeatures ?? {}) };
+    const mergedModelServices = {
+        ...(config?.modelServices ?? {}),
+        ...(userConfig?.modelServices ?? {})
+    };
+    const routedServiceKey = resolveRoutedServiceKey(options.model);
+    const routedService = routedServiceKey != null ? mergedModelServices[routedServiceKey] : undefined;
+    const shouldUseProxy = typeof routedService?.apiBaseUrl === 'string' && routedService.apiBaseUrl.trim() !== '';
+    const proxyLogger = shouldUseProxy
+        ? createLogger(cwd, `${ctx.ctxId}/${options.sessionId ?? 'default'}/adapter-codex`, 'proxy')
+        : undefined;
+    const proxyBaseUrl = shouldUseProxy
+        ? (await ensureCodexProxyServer(proxyLogger)).baseUrl
+        : undefined;
+    if (proxyBaseUrl != null && routedServiceKey != null && proxyLogger != null) {
+        proxyLogger.info('[codex session] using local proxy for routed model service', {
+            serviceKey: routedServiceKey,
+            proxyBaseUrl,
+            upstreamBaseUrl: normalizeProviderBaseUrl(routedService?.apiBaseUrl, (routedService?.extra?.codex ?? {}).wireApi) ?? routedService?.apiBaseUrl
+        });
+    }
+    const { args: configOverrideArgs, fingerprintArgs: configFingerprintArgs, resolvedModel, resolvedMaxOutputTokens } = buildCodexConfigOverrides({
+        systemPrompt: options.systemPrompt,
+        rawModel: options.model,
+        modelServices: mergedModelServices,
+        proxyBaseUrl,
+        proxyLogContext: proxyBaseUrl != null
+            ? {
+                cwd,
+                ctxId: ctx.ctxId,
+                sessionId: options.sessionId ?? 'default'
+            }
+            : undefined
+    });
+    const filteredMcpServers = options.assetPlan?.mcpServers ?? {
+        ...(config?.mcpServers ?? {}),
+        ...(userConfig?.mcpServers ?? {})
+    };
+    const mcpConfigArgs = buildMcpConfigArgs(filteredMcpServers);
+    configOverrideArgs.push(...mcpConfigArgs);
+    configFingerprintArgs.push(...mcpConfigArgs);
+    const binaryPath = resolveCodexBinaryPath(env);
+    await mkdir(resolve(process.env.HOME, '.codex'), { recursive: true });
+    const spawnEnv = buildSpawnEnv(env);
+    if (env.__VF_PROJECT_AI_CODEX_NATIVE_HOOKS_AVAILABLE__ === '1') {
+        features.codex_hooks = true;
+        spawnEnv.__VF_VIBE_FORGE_CODEX_HOOKS_ACTIVE__ = '1';
+        spawnEnv[NATIVE_HOOK_BRIDGE_ADAPTER_ENV] = 'codex';
+        spawnEnv.__VF_CODEX_HOOK_RUNTIME__ = options.runtime;
+        spawnEnv.__VF_CODEX_TASK_SESSION_ID__ = options.sessionId;
+    }
+    const threadCacheKey = await buildThreadCacheKey({
+        cwd,
+        useYolo,
+        approvalPolicy,
+        sandboxPolicy,
+        resolvedModel,
+        configFingerprintArgs,
+        features
+    });
+    let cachedThreadId;
+    if (options.type === 'resume') {
+        const cachedThreads = await cache.get('adapter.codex.threads');
+        cachedThreadId = cachedThreads?.[threadCacheKey];
+    }
+    return {
+        logger,
+        cwd,
+        binaryPath,
+        spawnEnv,
+        useYolo,
+        approvalPolicy,
+        sandboxPolicy,
+        features,
+        configOverrideArgs,
+        resolvedModel,
+        resolvedMaxOutputTokens,
+        threadCacheKey,
+        cachedThreadId
+    };
+}

package/dist/packages/adapters/codex/src/runtime/session.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
+/**
+ * Create a codex adapter session, dispatching to `direct` or `stream` mode
+ * based on `options.mode` (default: `'stream'`).
+ */
+export declare const createCodexSession: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<{
+    kill: () => boolean;
+    emit: () => void;
+    pid: number | undefined;
+} | {
+    kill: () => void;
+    emit: (event: import("@vibe-forge/types").AdapterEvent) => void;
+    pid: number | undefined;
+}>;

package/dist/packages/adapters/codex/src/runtime/session.js

@@ -0,0 +1,26 @@
+import { createDirectCodexSession } from './direct';
+import { resolveSessionBase } from './session-common';
+import { createStreamCodexSession } from './stream';
+/**
+ * Create a codex adapter session, dispatching to `direct` or `stream` mode
+ * based on `options.mode` (default: `'stream'`).
+ */
+export const createCodexSession = async (ctx, options) => {
+    const base = await resolveSessionBase(ctx, options);
+    options.onEvent({
+        type: 'init',
+        data: {
+            uuid: options.sessionId,
+            model: base.resolvedModel ?? options.model ?? 'default',
+            version: 'unknown',
+            tools: [],
+            slashCommands: [],
+            cwd: ctx.cwd,
+            agents: [],
+            assetDiagnostics: options.assetPlan?.diagnostics
+        }
+    });
+    return options.mode === 'direct'
+        ? createDirectCodexSession(base, options)
+        : createStreamCodexSession(base, ctx, options);
+};

package/dist/packages/adapters/codex/src/runtime/stream.d.ts

@@ -0,0 +1,11 @@
+import type { AdapterCtx, AdapterEvent, AdapterQueryOptions } from '@vibe-forge/types';
+import type { CodexSessionBase } from './session-common';
+/**
+ * Spawn `codex app-server` and drive it over JSON-RPC 2.0 (JSONL),
+ * forwarding events to `onEvent`.
+ */
+export declare function createStreamCodexSession(base: CodexSessionBase, ctx: AdapterCtx, options: AdapterQueryOptions): Promise<{
+    kill: () => void;
+    emit: (event: AdapterEvent) => void;
+    pid: number | undefined;
+}>;

package/dist/packages/adapters/codex/src/runtime/stream.js

@@ -0,0 +1,263 @@
+import { spawn } from 'node:child_process';
+import { AgentMessageAccumulator, CommandOutputAccumulator, handleIncomingNotification } from '#~/protocol/incoming.js';
+import { CodexRpcClient } from '#~/protocol/rpc.js';
+import { buildFeatureArgs, getErrorMessage, isInvalidEncryptedContentError, mapContentToCodexInput, toAdapterErrorData, toCodexOutboundApprovalPolicy } from './session-common';
+/**
+ * Spawn `codex app-server` and drive it over JSON-RPC 2.0 (JSONL),
+ * forwarding events to `onEvent`.
+ */
+export async function createStreamCodexSession(base, ctx, options) {
+    const { logger, cwd, binaryPath, spawnEnv, useYolo, approvalPolicy, sandboxPolicy, features, configOverrideArgs, resolvedModel, resolvedMaxOutputTokens, threadCacheKey, cachedThreadId } = base;
+    const { cache, configs: [config, userConfig] } = ctx;
+    const { onEvent, description, sessionId, type: sessionType } = options;
+    const model = resolvedModel;
+    const rpcApprovalPolicy = toCodexOutboundApprovalPolicy(approvalPolicy);
+    const { experimentalApi = false, effort, maxOutputTokens: adapterMaxOutputTokens, clientInfo: rawClientInfo = {} } = {
+        ...(config?.adapters?.codex ?? {}),
+        ...(userConfig?.adapters?.codex ?? {})
+    };
+    const maxOutputTokens = typeof resolvedMaxOutputTokens === 'number'
+        ? resolvedMaxOutputTokens
+        : resolvedMaxOutputTokens === null
+            ? undefined
+            : adapterMaxOutputTokens;
+    const clientInfo = {
+        name: rawClientInfo.name ?? 'vibe-forge',
+        title: rawClientInfo.title ?? 'Vibe Forge',
+        version: rawClientInfo.version ?? '0.1.0'
+    };
+    logger.info('[codex session] spawning app-server (stream mode)', { binaryPath, cwd });
+    const proc = spawn(String(binaryPath), [
+        ...(useYolo ? ['--yolo'] : []),
+        'app-server',
+        ...configOverrideArgs,
+        ...buildFeatureArgs(features)
+    ], { env: spawnEnv, cwd, stdio: ['pipe', 'pipe', 'inherit'] });
+    const rpc = new CodexRpcClient(proc, logger);
+    const msgAcc = new AgentMessageAccumulator();
+    const cmdAcc = new CommandOutputAccumulator();
+    let threadId;
+    let activeTurnId;
+    let usedCachedThread = false;
+    let didEmitExit = false;
+    let didEmitFatalError = false;
+    const emitEvent = (event) => {
+        if (event.type === 'error' && event.data.fatal !== false) {
+            didEmitFatalError = true;
+        }
+        onEvent(event);
+    };
+    const emitFailureAndExit = (err) => {
+        if (didEmitExit)
+            return;
+        didEmitExit = true;
+        const stderr = getErrorMessage(err);
+        logger.error('[codex session] stream session failed', { err, sessionId, threadId });
+        if (!didEmitFatalError) {
+            emitEvent({ type: 'error', data: toAdapterErrorData(err) });
+        }
+        rpc.destroy(stderr);
+        emitEvent({ type: 'exit', data: { exitCode: 1, stderr } });
+        proc.kill();
+    };
+    const readThreadCache = async () => (await cache.get('adapter.codex.threads')) ?? {};
+    const writeThreadCache = async (nextThreadId) => {
+        const cachedThreads = await readThreadCache();
+        if (cachedThreads[threadCacheKey] === nextThreadId)
+            return;
+        await cache.set('adapter.codex.threads', { ...cachedThreads, [threadCacheKey]: nextThreadId });
+    };
+    const deleteCachedThread = async () => {
+        const cachedThreads = await readThreadCache();
+        if (!(threadCacheKey in cachedThreads))
+            return;
+        const { [threadCacheKey]: _removed, ...rest } = cachedThreads;
+        await cache.set('adapter.codex.threads', rest);
+    };
+    rpc.onNotification((method, params) => {
+        if (method === 'turn/started') {
+            activeTurnId = params.turn?.id;
+        }
+        else if (method === 'turn/completed') {
+            const turn = params.turn;
+            if (turn?.status === 'failed') {
+                logger.error('[codex session] turn failed', {
+                    sessionId,
+                    threadId,
+                    turnId: turn.id,
+                    error: turn.error
+                });
+            }
+            activeTurnId = undefined;
+        }
+        handleIncomingNotification(method, params, rpc, emitEvent, msgAcc, cmdAcc, approvalPolicy);
+    });
+    proc.on('exit', (code) => {
+        if (didEmitExit)
+            return;
+        didEmitExit = true;
+        if ((code ?? 0) !== 0 && !didEmitFatalError) {
+            emitEvent({
+                type: 'error',
+                data: {
+                    message: `Process exited with code ${code ?? 1}`,
+                    details: { exitCode: code ?? 1 },
+                    fatal: true
+                }
+            });
+        }
+        rpc.destroy('process exited');
+        emitEvent({ type: 'exit', data: { exitCode: code ?? undefined } });
+    });
+    const startNewThread = async () => {
+        logger.info('[codex session] starting new thread', { cwd, sessionId });
+        const startResult = await rpc.request('thread/start', {
+            cwd,
+            approvalPolicy: rpcApprovalPolicy,
+            sandboxPolicy,
+            serviceName: 'vibe-forge',
+            ...(model ? { model } : {})
+        });
+        threadId = startResult.thread.id;
+        usedCachedThread = false;
+        await writeThreadCache(threadId);
+        logger.info('[codex session] thread started', { threadId, sessionId });
+    };
+    const recoverFromInvalidEncryptedContent = async (source) => {
+        logger.warn('[codex session] invalid encrypted content detected; starting a fresh thread', {
+            sessionId,
+            threadId,
+            source
+        });
+        await deleteCachedThread();
+        await startNewThread();
+    };
+    const resumeCachedThread = async (nextThreadId) => {
+        logger.info('[codex session] resuming thread', { threadId: nextThreadId, sessionId });
+        const resumeResult = await rpc.request('thread/resume', {
+            threadId: nextThreadId,
+            ...(model ? { model } : {})
+        });
+        threadId = resumeResult.thread.id;
+        usedCachedThread = true;
+        await writeThreadCache(threadId);
+    };
+    const startTurn = async (input, source) => {
+        const turnParams = {
+            threadId: threadId,
+            input,
+            cwd,
+            approvalPolicy: rpcApprovalPolicy,
+            sandboxPolicy,
+            ...(model ? { model } : {}),
+            ...(effort ? { effort } : {}),
+            ...(typeof maxOutputTokens === 'number' ? { maxOutputTokens } : {})
+        };
+        try {
+            logger.info('[codex session] starting turn', { threadId, input, source });
+            const turnResult = await rpc.request('turn/start', turnParams);
+            logger.info('[codex session] turn started', { turnId: turnResult.turn.id, source });
+            return turnResult;
+        }
+        catch (err) {
+            if (usedCachedThread && isInvalidEncryptedContentError(err)) {
+                await recoverFromInvalidEncryptedContent(source);
+                const retryParams = {
+                    ...turnParams,
+                    threadId: threadId
+                };
+                logger.info('[codex session] retrying turn on fresh thread', { threadId, source });
+                const retryResult = await rpc.request('turn/start', retryParams);
+                logger.info('[codex session] turn started after retry', { turnId: retryResult.turn.id, source });
+                return retryResult;
+            }
+            throw err;
+        }
+    };
+    try {
+        const initResult = await rpc.request('initialize', {
+            clientInfo,
+            capabilities: {
+                experimentalApi,
+                optOutNotificationMethods: [
+                    'turn/diff/updated',
+                    'turn/plan/updated',
+                    'thread/tokenUsage/updated'
+                ]
+            }
+        });
+        logger.info('[codex session] initialized', { userAgent: initResult?.userAgent });
+        rpc.notify('initialized', {});
+        if (sessionType === 'resume' && cachedThreadId != null) {
+            try {
+                await resumeCachedThread(cachedThreadId);
+            }
+            catch (err) {
+                if (!isInvalidEncryptedContentError(err))
+                    throw err;
+                await recoverFromInvalidEncryptedContent('thread/resume');
+            }
+        }
+        else {
+            await startNewThread();
+        }
+        if (description) {
+            const input = [{ type: 'text', text: description }];
+            await startTurn(input, 'initial');
+        }
+    }
+    catch (err) {
+        emitFailureAndExit(err);
+        throw err;
+    }
+    const emit = (event) => {
+        switch (event.type) {
+            case 'message': {
+                const textItems = mapContentToCodexInput(event.content);
+                if (activeTurnId != null) {
+                    rpc.request('turn/steer', {
+                        threadId: threadId,
+                        input: textItems,
+                        expectedTurnId: activeTurnId
+                    }).catch((err) => {
+                        logger.error('[codex session] turn/steer failed', { err });
+                        emitFailureAndExit(err);
+                    });
+                }
+                else {
+                    startTurn(textItems, 'emit').catch((err) => {
+                        logger.error('[codex session] turn/start from emit failed', { err });
+                        emitFailureAndExit(err);
+                    });
+                }
+                break;
+            }
+            case 'interrupt': {
+                if (activeTurnId != null) {
+                    rpc.request('turn/interrupt', {
+                        threadId: threadId,
+                        turnId: activeTurnId
+                    }).catch((err) => {
+                        logger.error('[codex session] turn/interrupt failed', { err });
+                    });
+                }
+                break;
+            }
+            case 'stop': {
+                proc.kill();
+                break;
+            }
+            default:
+                logger.warn('[codex session] unknown emit event', { event });
+                break;
+        }
+    };
+    return {
+        kill: () => {
+            rpc.destroy('killed by caller');
+            proc.kill();
+        },
+        emit,
+        pid: proc.pid
+    };
+}