@yuandc/aica 0.1.0

package/dist/acp/providers/codex-acp/context-maintenance.js

@@ -0,0 +1,148 @@
+import fs from "node:fs";
+const MB = 1024 * 1024;
+export function readCodexContextMaintenancePolicy(env = process.env) {
+    return {
+        compactTokenThreshold: positiveInteger(env.ACA_CODEX_COMPACT_TOKEN_THRESHOLD, 120_000),
+        compactContextRatio: ratio(env.ACA_CODEX_COMPACT_CONTEXT_RATIO, 0.45),
+        rolloverTokenThreshold: positiveInteger(env.ACA_CODEX_ROLLOVER_TOKEN_THRESHOLD, 180_000),
+        rolloverContextRatio: ratio(env.ACA_CODEX_ROLLOVER_CONTEXT_RATIO, 0.60),
+        rolloutMaxBytes: positiveInteger(env.ACA_CODEX_ROLLOUT_MAX_BYTES, 50 * MB),
+        threadMaxTurns: positiveInteger(env.ACA_CODEX_THREAD_MAX_TURNS, 40),
+        compactTimeoutMs: positiveInteger(env.ACA_CODEX_COMPACT_TIMEOUT_MS, 10 * 60 * 1000),
+        slowEventThresholdMs: positiveInteger(env.ACA_CODEX_SLOW_EVENT_THRESHOLD_MS, 5 * 60 * 1000)
+    };
+}
+export function codexTokenUsageFromNotification(params, nowMs = Date.now()) {
+    const record = objectOrEmpty(params);
+    const tokenUsage = objectOrEmpty(record.tokenUsage);
+    const last = objectOrEmpty(tokenUsage.last);
+    const inputTokens = nonNegativeNumber(last.inputTokens);
+    const totalTokens = nonNegativeNumber(last.totalTokens);
+    const contextWindow = nonNegativeNumber(tokenUsage.modelContextWindow);
+    if (inputTokens === 0 && totalTokens === 0 && contextWindow === 0)
+        return null;
+    return {
+        inputTokens,
+        totalTokens,
+        contextWindow,
+        contextRatio: contextWindow > 0 ? inputTokens / contextWindow : 0,
+        observedAtMs: nowMs
+    };
+}
+export function decideCodexContextMaintenance(state, policy, input = {}) {
+    const compactReasons = [];
+    const rolloverReasons = [];
+    if (state.usage && state.usage.inputTokens >= policy.compactTokenThreshold)
+        compactReasons.push("token-threshold");
+    if (state.usage && state.usage.contextRatio >= policy.compactContextRatio)
+        compactReasons.push("context-ratio");
+    if (state.rolloutBytes >= policy.rolloutMaxBytes)
+        compactReasons.push("rollout-size");
+    if (state.turnCount >= policy.threadMaxTurns)
+        compactReasons.push("turn-count");
+    if (input.compactAttempted) {
+        if (input.compactFailed)
+            rolloverReasons.push("compact-failed");
+        if (state.usage && state.usage.inputTokens >= policy.rolloverTokenThreshold)
+            rolloverReasons.push("token-still-high");
+        if (state.usage && state.usage.contextRatio >= policy.rolloverContextRatio)
+            rolloverReasons.push("context-ratio-still-high");
+        if (state.rolloutBytes >= policy.rolloutMaxBytes)
+            rolloverReasons.push("rollout-size");
+        if (state.turnCount >= policy.threadMaxTurns)
+            rolloverReasons.push("turn-count");
+    }
+    return {
+        compact: compactReasons.length > 0,
+        rollover: rolloverReasons.length > 0,
+        reasons: [...new Set([...compactReasons, ...rolloverReasons])]
+    };
+}
+export function rolloutFileSize(filePath) {
+    if (!filePath)
+        return 0;
+    try {
+        const stat = fs.statSync(filePath);
+        return stat.isFile() ? stat.size : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function buildCodexContinuityInstructions(input) {
+    const files = [...new Set(input.affectedFiles.map((item) => item.trim()).filter(Boolean))].slice(0, 30);
+    return [
+        "ACA automatically rotated a long Codex thread to keep future turns responsive.",
+        "Treat the following as continuity context, not as a new user request.",
+        "Repository files on disk are authoritative; inspect them before making further edits.",
+        "",
+        `Previous thread: ${input.previousThreadId}`,
+        `Working directory: ${input.cwd}`,
+        "",
+        "Latest user request:",
+        truncateText(input.userRequest, 3_000) || "(not available)",
+        "",
+        "Latest completed assistant result:",
+        truncateText(input.assistantResponse, 7_000) || "(not available)",
+        "",
+        "Recently affected files:",
+        files.length > 0 ? files.map((item) => `- ${item}`).join("\n") : "- (not recorded)"
+    ].join("\n");
+}
+export class CodexPromptPerformanceTracker {
+    startedAtMs;
+    firstEventAtMs = null;
+    lastEventAtMs = null;
+    eventCount = 0;
+    lastSlowReportAtMs = 0;
+    constructor(startedAtMs = Date.now()) {
+        this.startedAtMs = startedAtMs;
+    }
+    recordEvent(atMs = Date.now()) {
+        if (this.firstEventAtMs === null)
+            this.firstEventAtMs = atMs;
+        this.lastEventAtMs = atMs;
+        this.eventCount += 1;
+    }
+    shouldReportSlow(nowMs, thresholdMs) {
+        const lastActivityAt = this.lastEventAtMs ?? this.startedAtMs;
+        if (nowMs - lastActivityAt < thresholdMs)
+            return false;
+        if (this.lastSlowReportAtMs > 0 && nowMs - this.lastSlowReportAtMs < thresholdMs)
+            return false;
+        this.lastSlowReportAtMs = nowMs;
+        return true;
+    }
+    snapshot(nowMs = Date.now()) {
+        const lastActivityAt = this.lastEventAtMs ?? this.startedAtMs;
+        return {
+            startedAtMs: this.startedAtMs,
+            firstEventAtMs: this.firstEventAtMs,
+            lastEventAtMs: this.lastEventAtMs,
+            eventCount: this.eventCount,
+            firstEventLatencyMs: this.firstEventAtMs === null ? null : this.firstEventAtMs - this.startedAtMs,
+            silentForMs: Math.max(0, nowMs - lastActivityAt),
+            durationMs: Math.max(0, nowMs - this.startedAtMs)
+        };
+    }
+}
+function positiveInteger(value, fallback) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function ratio(value, fallback) {
+    const parsed = Number.parseFloat(value ?? "");
+    return Number.isFinite(parsed) && parsed > 0 && parsed <= 1 ? parsed : fallback;
+}
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
+}
+function truncateText(value, maxLength) {
+    const normalized = value.replace(/\r\n/g, "\n").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 16).trimEnd()}\n...[truncated]`;
+}
+function objectOrEmpty(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}

package/dist/acp/providers/codex-acp/launch.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+export function resolveCodexAcpLaunch() {
+    if (process.isSea || process.env.ACA_SINGLE_FILE_WORKER === "1") {
+        return {
+            command: process.execPath,
+            args: ["--internal-acp-adapter"]
+        };
+    }
+    const adapterTs = fileURLToPath(new URL("./adapter.ts", import.meta.url));
+    const adapterJs = fileURLToPath(new URL("./adapter.js", import.meta.url));
+    const distAdapterJs = adapterTs.replace(`${path.sep}src${path.sep}`, `${path.sep}dist${path.sep}`).replace(/\.ts$/, ".js");
+    if (fs.existsSync(distAdapterJs)) {
+        return {
+            command: process.execPath,
+            args: [distAdapterJs]
+        };
+    }
+    if (fs.existsSync(adapterJs)) {
+        return {
+            command: process.execPath,
+            args: [adapterJs]
+        };
+    }
+    const require = createRequire(import.meta.url);
+    return {
+        command: process.execPath,
+        args: ["--import", require.resolve("tsx"), adapterTs]
+    };
+}
+export function resolveCodexAcpDisplayCommand(launch) {
+    return `${path.basename(launch.command)} ${launch.args.join(" ")}`;
+}

package/dist/acp/providers/codex-acp/provider.js

@@ -0,0 +1,486 @@
+import fs from "node:fs";
+import { promptBlocksToAcpContent } from "../../client/acp-content.js";
+import { eventFromAcpSessionUpdate, statusFromAcpSessionUpdate } from "../../client/acp-events.js";
+import { defaultAcpRuntimePool } from "../../client/acp-runtime-pool.js";
+import { resolveCodexAcpLaunch } from "./launch.js";
+import { CodexPromptPerformanceTracker, readCodexContextMaintenancePolicy } from "./context-maintenance.js";
+export const codexAcpCapabilities = {
+    sessionResume: true,
+    imageInput: true,
+    fileAttachment: true,
+    filesystem: true,
+    terminal: true,
+    permissionRequest: true,
+    configOptions: true,
+    usage: true,
+    contextUsage: true,
+    contextCompaction: true,
+    plan: true,
+    diff: true
+};
+export class CodexAcpProvider {
+    id = "codex-acp";
+    name = "Codex ACP";
+    capabilities = codexAcpCapabilities;
+    async createSession(input) {
+        return new CodexAcpSession(input.cwd, input.providerSessionId ?? null, input.timeoutMs);
+    }
+}
+class CodexAcpSession {
+    cwd;
+    providerSessionId;
+    defaultTimeoutMs;
+    lease = null;
+    sessionResponse = null;
+    statusCallback = null;
+    updateCallback = null;
+    permissionCallback = null;
+    userInputCallback = null;
+    abortHandler = null;
+    statusTimeline = [];
+    updates = [];
+    content = "";
+    performanceTracker = null;
+    constructor(cwd, providerSessionId, defaultTimeoutMs = readCodexAcpPromptTimeoutMs()) {
+        this.cwd = cwd;
+        this.providerSessionId = providerSessionId;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+    }
+    async sendPrompt(input) {
+        if (!fs.existsSync(input.cwd) || !fs.statSync(input.cwd).isDirectory()) {
+            throw new Error(`Project root does not exist or is not a directory: ${input.cwd}`);
+        }
+        const startedAt = Date.now();
+        this.statusCallback = input.onStatus ?? null;
+        this.updateCallback = input.onUpdate ?? null;
+        this.permissionCallback = input.onPermissionRequest ?? null;
+        this.userInputCallback = input.onUserInputRequest ?? null;
+        this.attachAbortSignal(input.signal);
+        this.content = "";
+        this.updates.length = 0;
+        this.statusTimeline.length = 0;
+        this.performanceTracker = new CodexPromptPerformanceTracker(startedAt);
+        let client = null;
+        let started = null;
+        let sessionId = this.providerSessionId;
+        let promptResponse;
+        let slowStatusTimer = null;
+        try {
+            this.emitStatus("initializing", "Codex ACP 启动中", "codex-acp");
+            const lease = await this.acquireRuntime(input.cwd);
+            this.lease = lease;
+            client = lease.client;
+            started = lease.started;
+            await this.initialize(lease);
+            sessionId = await this.establishSession(lease, input);
+            await this.applyConfig(client, sessionId, input);
+            this.emitStatus("thinking", "思考中");
+            slowStatusTimer = this.startSlowStatusTimer();
+            promptResponse = await this.promptWithAbort(client, {
+                sessionId,
+                prompt: promptBlocksToAcpContent(input.prompt, input.promptBlocks),
+                timeoutMs: input.timeoutMs ?? this.defaultTimeoutMs,
+                signal: input.signal
+            });
+            const nextSessionId = sessionIdFromPromptResponse(promptResponse);
+            if (nextSessionId && nextSessionId !== sessionId) {
+                sessionId = nextSessionId;
+                this.providerSessionId = nextSessionId;
+                lease.setProviderSession({ providerSessionId: nextSessionId, sessionResponse: this.sessionResponse });
+            }
+        }
+        finally {
+            if (slowStatusTimer)
+                clearInterval(slowStatusTimer);
+            if (this.abortHandler && input.signal) {
+                input.signal.removeEventListener("abort", this.abortHandler);
+                this.abortHandler = null;
+            }
+            this.releaseLease();
+        }
+        this.emitStatus("completed", "已完成");
+        return {
+            providerSessionId: sessionId,
+            cliType: "builtin",
+            agentType: "codex",
+            effectiveConfig: {
+                model: input.model ?? null,
+                mode: input.mode ?? null,
+                configOptionValues: input.configOptionValues ?? null,
+                command: started.command,
+                processPid: started.child.pid ?? null,
+                provider: "codex-acp",
+                protocol: "acp"
+            },
+            command: started.command,
+            args: started.args,
+            cwd: input.cwd,
+            exitCode: started.child.exitCode,
+            signal: started.child.signalCode,
+            durationMs: Date.now() - startedAt,
+            stdout: client.rpc.stdout,
+            stderr: client.rpc.stderr,
+            content: this.content.trim(),
+            updates: [...this.updates],
+            statusTimeline: [...this.statusTimeline],
+            performance: this.performanceTracker?.snapshot(),
+            contextUsage: contextUsageFromPromptResponse(promptResponse),
+            promptResponse
+        };
+    }
+    async compactContext(input) {
+        if (!fs.existsSync(input.cwd) || !fs.statSync(input.cwd).isDirectory()) {
+            throw new Error(`Project root does not exist or is not a directory: ${input.cwd}`);
+        }
+        const startedAt = Date.now();
+        this.statusCallback = input.onStatus ?? null;
+        this.updateCallback = input.onUpdate ?? null;
+        this.attachAbortSignal(input.signal);
+        let sessionId = this.providerSessionId;
+        let response;
+        try {
+            this.emitStatus("initializing", "Codex ACP 启动中", "codex-acp");
+            const lease = await this.acquireRuntime(input.cwd);
+            this.lease = lease;
+            await this.initialize(lease);
+            sessionId = await this.establishSession(lease, input);
+            await this.applyConfig(lease.client, sessionId, input);
+            response = await lease.client.compactSession({
+                sessionId,
+                allowRollover: input.allowRollover === true
+            }, input.timeoutMs ?? 10 * 60 * 1000);
+            const nextSessionId = sessionIdFromPromptResponse(response);
+            if (nextSessionId && nextSessionId !== sessionId) {
+                sessionId = nextSessionId;
+                this.providerSessionId = nextSessionId;
+                lease.setProviderSession({ providerSessionId: nextSessionId, sessionResponse: this.sessionResponse });
+            }
+        }
+        catch (error) {
+            if (this.lease && shouldDisposeRuntimeAfterCompactError(error, input.signal)) {
+                const lease = this.lease;
+                this.lease = null;
+                await lease.dispose().catch(() => void 0);
+            }
+            throw error;
+        }
+        finally {
+            if (this.abortHandler && input.signal) {
+                input.signal.removeEventListener("abort", this.abortHandler);
+                this.abortHandler = null;
+            }
+            this.releaseLease();
+        }
+        const record = objectOrNull(response) ?? {};
+        return {
+            providerSessionId: sessionId || this.providerSessionId || "",
+            contextUsage: contextUsageFromRecord(record.contextUsage),
+            maintenance: objectOrNull(record.maintenance) ?? {},
+            durationMs: Date.now() - startedAt
+        };
+    }
+    async cancel() {
+        if (this.providerSessionId)
+            this.lease?.client.cancel(this.providerSessionId);
+    }
+    async close() {
+        this.statusCallback = null;
+        this.updateCallback = null;
+        this.permissionCallback = null;
+        this.userInputCallback = null;
+        if (this.abortHandler)
+            this.abortHandler = null;
+        this.releaseLease();
+    }
+    async acquireRuntime(cwd) {
+        const launch = resolveCodexAcpLaunch();
+        return defaultAcpRuntimePool.acquire({
+            providerId: "codex-acp",
+            cwd,
+            providerSessionId: this.providerSessionId,
+            command: launch.command,
+            args: launch.args,
+            onSessionUpdate: (params) => this.handleSessionUpdate(params),
+            onClientRequest: async (method, params) => {
+                if (method === "session/request_permission")
+                    return this.requestPermission(params);
+                if (method === "elicitation/create" || method === "session/request_user_input")
+                    return this.requestUserInput(params);
+                throw new Error(`Unsupported Codex ACP client request: ${method}`);
+            }
+        });
+    }
+    async initialize(lease) {
+        if (lease.initialized)
+            return;
+        await lease.client.initialize(60_000);
+        lease.markInitialized();
+    }
+    async establishSession(lease, input) {
+        const client = lease.client;
+        const initialConfig = initialCodexConfig(input);
+        if (lease.providerSessionId && lease.sessionEstablished) {
+            this.providerSessionId = lease.providerSessionId;
+            this.sessionResponse = lease.sessionResponse;
+            return lease.providerSessionId;
+        }
+        if (this.providerSessionId) {
+            try {
+                this.emitStatus("resuming", "Codex ACP 会话恢复中", "session/load");
+                const loaded = await client.loadSession({ sessionId: this.providerSessionId, cwd: input.cwd, config: initialConfig }, 60_000);
+                this.sessionResponse = objectOrNull(loaded);
+                const sessionId = sessionIdFromResponse(loaded) || this.providerSessionId;
+                this.providerSessionId = sessionId;
+                lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.sessionResponse });
+                return sessionId;
+            }
+            catch {
+                this.providerSessionId = null;
+            }
+        }
+        this.emitStatus("acp", "Codex ACP 会话创建中", "session/new");
+        const created = await client.newSession({ cwd: input.cwd, config: initialConfig }, 120_000);
+        this.sessionResponse = objectOrNull(created);
+        const sessionId = sessionIdFromResponse(created);
+        if (!sessionId)
+            throw new Error("Codex ACP session/new did not return sessionId");
+        this.providerSessionId = sessionId;
+        lease.setProviderSession({ providerSessionId: sessionId, sessionResponse: this.sessionResponse });
+        return sessionId;
+    }
+    async applyConfig(client, sessionId, input) {
+        if (input.model) {
+            await client.setSessionConfigOption({ sessionId, configId: "model", value: input.model }, 60_000).catch(() => void 0);
+        }
+        const approvalPolicy = approvalPolicyFromMode(input.mode);
+        if (approvalPolicy) {
+            await client.setSessionConfigOption({ sessionId, configId: "approvalPolicy", value: approvalPolicy }, 60_000).catch(() => void 0);
+        }
+        const mode = modeToCodexSandbox(input.mode);
+        if (mode) {
+            await client.setSessionConfigOption({ sessionId, configId: "sandbox", value: mode }, 60_000).catch(() => void 0);
+        }
+        for (const [configId, value] of Object.entries(input.configOptionValues ?? {})) {
+            if (["model", "mode", "sandbox", "approvalPolicy"].includes(configId))
+                continue;
+            await client.setSessionConfigOption({ sessionId, configId, value }, 60_000).catch(() => void 0);
+        }
+    }
+    handleSessionUpdate(params) {
+        this.performanceTracker?.recordEvent();
+        this.updates.push({ method: "session/update", params });
+        const event = eventFromAcpSessionUpdate(params);
+        if (event) {
+            if (event.type === "agent_message_chunk")
+                this.content += event.text ?? "";
+            this.updateCallback?.(event);
+        }
+        const status = statusFromAcpSessionUpdate(params);
+        if (status)
+            this.emitStatus(status.phase, status.label, status.detail, status.updateType);
+    }
+    startSlowStatusTimer() {
+        const thresholdMs = readCodexContextMaintenancePolicy().slowEventThresholdMs;
+        const timer = setInterval(() => {
+            const tracker = this.performanceTracker;
+            const now = Date.now();
+            if (!tracker?.shouldReportSlow(now, thresholdMs))
+                return;
+            const snapshot = tracker.snapshot(now);
+            const minutes = Math.max(1, Math.round(snapshot.silentForMs / 60_000));
+            this.emitStatus("thinking", "模型长时间处理中", `已 ${minutes} 分钟没有收到新的 ACP 事件`, "aca.performance.slow");
+        }, Math.min(30_000, Math.max(1_000, Math.floor(thresholdMs / 4))));
+        timer.unref();
+        return timer;
+    }
+    attachAbortSignal(signal) {
+        if (!signal)
+            return;
+        this.abortHandler = () => {
+            void this.cancel();
+        };
+        if (signal.aborted)
+            throw new Error("Codex ACP prompt cancelled");
+        signal.addEventListener("abort", this.abortHandler, { once: true });
+    }
+    async promptWithAbort(client, input) {
+        const promptPromise = client.prompt({ sessionId: input.sessionId, prompt: input.prompt }, input.timeoutMs);
+        if (!input.signal)
+            return promptPromise;
+        if (input.signal.aborted) {
+            await this.lease?.dispose().catch(() => void 0);
+            throw new Error("Codex ACP prompt cancelled");
+        }
+        let abortHandler = null;
+        const abortPromise = new Promise((_, reject) => {
+            abortHandler = () => {
+                client.cancel(input.sessionId);
+                void this.lease?.dispose().catch(() => void 0);
+                reject(new Error("Codex ACP prompt cancelled"));
+            };
+            input.signal?.addEventListener("abort", abortHandler, { once: true });
+        });
+        try {
+            return await Promise.race([promptPromise, abortPromise]);
+        }
+        finally {
+            if (abortHandler)
+                input.signal.removeEventListener("abort", abortHandler);
+        }
+    }
+    async requestPermission(params) {
+        if (!this.permissionCallback)
+            return { outcome: { outcome: "cancelled" } };
+        const record = params && typeof params === "object" && !Array.isArray(params) ? params : {};
+        const request = record.request && typeof record.request === "object" && !Array.isArray(record.request) ? record.request : record;
+        const rawOptions = Array.isArray(request.options) ? request.options : [];
+        const options = rawOptions.map((option, index) => {
+            const item = option && typeof option === "object" && !Array.isArray(option) ? option : {};
+            return {
+                optionId: String(item.optionId ?? item.id ?? index),
+                kind: String(item.kind ?? "choice"),
+                ...(typeof item.label === "string" ? { label: item.label } : {})
+            };
+        });
+        this.emitStatus("requestPermission", "等待授权", permissionRequestDetail(request), "session/request_permission");
+        return this.permissionCallback({
+            requestId: String(request.requestId ?? request.id ?? `codex-acp-permission-${Date.now()}`),
+            params,
+            options
+        });
+    }
+    async requestUserInput(params) {
+        if (!this.userInputCallback)
+            return { outcome: { outcome: "cancelled" } };
+        const record = params && typeof params === "object" && !Array.isArray(params) ? params : {};
+        const request = record.request && typeof record.request === "object" && !Array.isArray(record.request) ? record.request : record;
+        this.emitStatus("requestPermission", "等待输入", userInputRequestDetail(request), "elicitation/create");
+        return this.userInputCallback({
+            requestId: String(request.requestId ?? request.id ?? `codex-acp-input-${Date.now()}`),
+            prompt: String(request.prompt ?? request.message ?? request.question ?? ""),
+            params,
+            ...(typeof request.defaultValue === "string" ? { defaultValue: request.defaultValue } : {})
+        });
+    }
+    emitStatus(phase, label, detail, updateType) {
+        const status = {
+            phase,
+            label,
+            ...(detail ? { detail } : {}),
+            ...(updateType ? { updateType } : {}),
+            atMs: Date.now()
+        };
+        const last = this.statusTimeline[this.statusTimeline.length - 1];
+        if (last && last.phase === status.phase && last.label === status.label && last.detail === status.detail && last.updateType === status.updateType)
+            return;
+        this.statusTimeline.push(status);
+        this.statusCallback?.(status);
+    }
+    releaseLease() {
+        this.lease?.release();
+        this.lease = null;
+    }
+}
+function shouldDisposeRuntimeAfterCompactError(error, signal) {
+    if (signal?.aborted)
+        return true;
+    const message = error instanceof Error ? error.message : String(error || "");
+    return /compact.*timed out|request timed out.*compact|adapter closed|aborted|cancelled/i.test(message);
+}
+function sessionIdFromResponse(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const sessionId = value.sessionId;
+    return typeof sessionId === "string" && sessionId.trim() ? sessionId.trim() : null;
+}
+function objectOrNull(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function modeToCodexSandbox(mode) {
+    const normalized = String(mode || "").trim();
+    if (!normalized)
+        return null;
+    if (normalized === "read-only")
+        return "read-only";
+    if (["agent-full-access", "full-access", "bypassPermissions", "danger-full-access"].includes(normalized))
+        return "danger-full-access";
+    return "workspace-write";
+}
+function approvalPolicyFromMode(mode) {
+    const normalized = String(mode || "").trim();
+    if (!normalized)
+        return null;
+    if (["agent-full-access", "full-access", "bypassPermissions", "danger-full-access"].includes(normalized))
+        return "never";
+    if (normalized === "acceptEdits" || normalized === "accept-edits")
+        return "on-failure";
+    return "on-request";
+}
+function initialCodexConfig(input) {
+    return {
+        ...(input.model ? { model: input.model } : {}),
+        ...(approvalPolicyFromMode(input.mode) ? { approvalPolicy: approvalPolicyFromMode(input.mode) } : {}),
+        ...(modeToCodexSandbox(input.mode) ? { sandbox: modeToCodexSandbox(input.mode) } : {}),
+        ...(input.configOptionValues ?? {})
+    };
+}
+function permissionRequestDetail(request) {
+    const params = request.params && typeof request.params === "object" && !Array.isArray(request.params) ? request.params : request;
+    for (const key of ["command", "cwd", "reason", "grantRoot", "method"]) {
+        const value = params[key];
+        if (typeof value === "string" && value.trim())
+            return textPreview(value);
+    }
+    return undefined;
+}
+function userInputRequestDetail(request) {
+    for (const key of ["prompt", "message", "question", "title"]) {
+        const value = request[key];
+        if (typeof value === "string" && value.trim())
+            return textPreview(value);
+    }
+    return undefined;
+}
+function textPreview(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+function readCodexAcpPromptTimeoutMs() {
+    const parsed = Number.parseInt(process.env.ACA_CODEX_ACP_PROMPT_TIMEOUT_MS ?? process.env.ACA_ACP_PROMPT_TIMEOUT_MS ?? "", 10);
+    return Number.isInteger(parsed) && parsed >= 30_000 ? parsed : 6 * 60 * 60 * 1000;
+}
+function sessionIdFromPromptResponse(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    return typeof record.sessionId === "string" && record.sessionId.trim() ? record.sessionId : null;
+}
+function contextUsageFromPromptResponse(value) {
+    const record = objectOrNull(value);
+    const meta = objectOrNull(record?._meta);
+    return contextUsageFromRecord(meta?.acaContextUsage);
+}
+function contextUsageFromRecord(value) {
+    const record = objectOrNull(value);
+    if (!record)
+        return null;
+    const contextWindow = finiteNumber(record.contextWindow);
+    const usedTokens = finiteNumber(record.usedTokens);
+    const inputTokens = finiteNumber(record.inputTokens);
+    const rawState = String(record.state || "unknown");
+    const state = ["active", "compacted", "new_thread"].includes(rawState)
+        ? rawState
+        : "unknown";
+    return {
+        usedTokens,
+        inputTokens,
+        contextWindow,
+        ratio: contextWindow > 0 ? Math.max(0, finiteNumber(record.ratio) || usedTokens / contextWindow) : 0,
+        observedAtMs: finiteNumber(record.observedAtMs) || Date.now(),
+        state,
+        maintenanceAction: typeof record.maintenanceAction === "string" ? record.maintenanceAction : null
+    };
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}