@prismatic-io/lux 0.0.2-preview.4 → 0.0.2-preview.40

package/lib/drivers/codex/index.js

@@ -3,242 +3,21 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import { temporaryDirectory } from "tempy";
-import { z } from "zod";
-import { discoverCliVersion, spawnManagedProcess, TypedEmitter, toolResultProgress, } from "../../core/index.js";
+import { agentEnvironment } from "../../core/agent-environment.js";
+import { durationMs } from "../../core/duration.js";
+import { defineDriver, discoverCliVersion, selectModelAndReasoningEffort, spawnManagedProcess, TypedEmitter, } from "../../core/index.js";
+import { resolveExecutable } from "../../core/platform-process.js";
+import { copyRegularFileNoFollow } from "../../core/secure-copy.js";
 import { walkArtifacts } from "../shared/artifacts.js";
-import { copyRegularFileNoFollow } from "../shared/secure-copy.js";
+import { configuredClaudeSourceHashes } from "../shared/experiment-behavior.js";
+import { prepareCodexExperimentConfig } from "../shared/experiment-policy.js";
+import { stageSkills } from "../shared/skills.js";
 import { subprocessDriver } from "../subprocess/index.js";
-import { appItemProgress, appItemToolName, appTurnLabel, appUsage, asRecord, messageOf, } from "./app-events.js";
-import { buildAppServerArgs, buildExecArgs as buildArgs, CodexDriverConfigSchema, } from "./config.js";
+import { appAgentLifecycleProgress, appItemProgress, appItemToolName, appTurnLabel, appUsage, asRecord, CodexSubagentTracker, messageOf, } from "./app-events.js";
+import { buildAppServerArgs, buildExecArgs as buildArgs, CodexDriverConfigSchema, codexConfigOverrides, } from "./config.js";
+import { makeParseEvent } from "./exec-events.js";
 const LUX_BOOKKEEPING_FILES = new Set(["events.jsonl", "case.json", "run.json", "grading.json"]);
 const commandName = (command) => command.split(/[\\/]/).at(-1) ?? command;
-const CodexUsageSchema = z.object({
-    input_tokens: z.number().nonnegative().catch(0),
-    cached_input_tokens: z.number().nonnegative().catch(0),
-    output_tokens: z.number().nonnegative().catch(0),
-});
-const parseUsage = (raw) => {
-    const usage = CodexUsageSchema.safeParse(raw).data;
-    if (!usage)
-        return null;
-    return {
-        input: Math.max(0, usage.input_tokens - usage.cached_input_tokens),
-        output: usage.output_tokens,
-        cacheRead: usage.cached_input_tokens,
-        cacheCreation: 0,
-    };
-};
-const resultText = (content) => {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .filter((block) => typeof block === "object" &&
-        block !== null &&
-        block.type === "text" &&
-        typeof block.text === "string")
-        .map((block) => block.text)
-        .join("\n");
-};
-const startedItemProgress = (item, id) => {
-    if (item.type === "command_execution") {
-        return {
-            tag: "progress",
-            progress: {
-                id: `tc-${id}`,
-                kind: "tool-call",
-                payload: { name: "command_execution", input: { command: item.command }, toolUseId: id },
-                ts: Date.now(),
-            },
-        };
-    }
-    if (item.type === "mcp_tool_call") {
-        const tool = typeof item.tool === "string" ? item.tool : String(item.name ?? "mcp_tool_call");
-        const server = typeof item.server === "string" ? item.server : undefined;
-        return {
-            tag: "progress",
-            progress: {
-                id: `tc-${id}`,
-                kind: "tool-call",
-                payload: {
-                    name: tool,
-                    input: item.arguments ?? item.input,
-                    toolUseId: id,
-                    ...(server ? { server } : {}),
-                },
-                ts: Date.now(),
-            },
-        };
-    }
-    if (item.type === "web_search") {
-        return {
-            tag: "progress",
-            progress: {
-                id: `tc-${id}`,
-                kind: "tool-call",
-                payload: { name: "web_search", input: { query: item.query }, toolUseId: id },
-                ts: Date.now(),
-            },
-        };
-    }
-    if (item.type === "file_change") {
-        return {
-            tag: "progress",
-            progress: {
-                id: `tc-${id}`,
-                kind: "tool-call",
-                payload: { name: "file_change", input: { changes: item.changes }, toolUseId: id },
-                ts: Date.now(),
-            },
-        };
-    }
-    return null;
-};
-const completedItemProgress = (item, id) => {
-    if (item.type === "agent_message" && typeof item.text === "string") {
-        return {
-            tag: "progress",
-            progress: {
-                id: `am-${id}`,
-                kind: "agent-message",
-                payload: { text: item.text },
-                ts: Date.now(),
-            },
-        };
-    }
-    if (item.type === "reasoning") {
-        const text = typeof item.text === "string" ? item.text : item.summary;
-        return {
-            tag: "progress",
-            progress: { id: `reasoning-${id}`, kind: "reasoning", payload: { text }, ts: Date.now() },
-        };
-    }
-    if (item.type === "mcp_tool_call") {
-        const tool = typeof item.tool === "string" ? item.tool : String(item.name ?? "mcp_tool_call");
-        const raw = item.result && typeof item.result === "object"
-            ? item.result
-            : item;
-        const content = raw.content ?? item.result ?? [];
-        const structuredContent = raw.structuredContent ?? raw.structured_content;
-        return {
-            tag: "progress",
-            progress: toolResultProgress(0, {
-                name: tool,
-                toolUseId: id,
-                content,
-                ...(structuredContent && typeof structuredContent === "object"
-                    ? { structuredContent: structuredContent }
-                    : {}),
-                isError: raw.isError === true ||
-                    raw.is_error === true ||
-                    item.status === "failed" ||
-                    (item.error !== undefined && item.error !== null),
-                text: resultText(content) || (typeof item.error === "string" ? item.error : ""),
-            }, Date.now()),
-        };
-    }
-    if (item.type === "command_execution") {
-        const output = item.aggregated_output ?? item.output ?? "";
-        const exitCode = typeof item.exit_code === "number" ? item.exit_code : undefined;
-        return {
-            tag: "progress",
-            progress: toolResultProgress(0, {
-                name: "command_execution",
-                toolUseId: id,
-                content: { output, ...(exitCode !== undefined ? { exitCode } : {}) },
-                isError: item.status === "failed" || (exitCode !== undefined && exitCode !== 0),
-                text: typeof output === "string" ? output : JSON.stringify(output),
-            }, Date.now()),
-        };
-    }
-    if (item.type === "web_search" || item.type === "file_change") {
-        const isWebSearch = item.type === "web_search";
-        const content = isWebSearch
-            ? { query: item.query }
-            : { changes: item.changes, status: item.status };
-        let text = JSON.stringify(item.changes ?? []);
-        if (isWebSearch)
-            text = typeof item.query === "string" ? item.query : "";
-        return {
-            tag: "progress",
-            progress: toolResultProgress(0, {
-                name: item.type,
-                toolUseId: id,
-                content,
-                isError: item.status === "failed",
-                text,
-            }, Date.now()),
-        };
-    }
-    return null;
-};
-const itemProgress = (item, phase) => {
-    const id = typeof item.id === "string" ? item.id : `${String(item.type)}-${Date.now()}`;
-    return phase === "started" ? startedItemProgress(item, id) : completedItemProgress(item, id);
-};
-const makeParseEvent = (config, cliVersion) => {
-    let threadId;
-    return (line) => {
-        let event;
-        try {
-            event = JSON.parse(line);
-        }
-        catch {
-            return null;
-        }
-        if (event.type === "thread.started") {
-            threadId = typeof event.thread_id === "string" ? event.thread_id : undefined;
-            return {
-                tag: "ready",
-                ready: {
-                    agentId: "codex",
-                    model: config.model,
-                    detail: { ...(threadId ? { threadId } : {}), ...(cliVersion ? { cliVersion } : {}) },
-                },
-            };
-        }
-        if (event.type === "item.started" || event.type === "item.completed") {
-            if (!event.item || typeof event.item !== "object")
-                return null;
-            return itemProgress(event.item, event.type === "item.started" ? "started" : "completed");
-        }
-        if (event.type === "turn.completed") {
-            const usage = parseUsage(event.usage);
-            const events = [];
-            if (usage) {
-                events.push({
-                    tag: "progress",
-                    progress: {
-                        id: `usage-${threadId ?? Date.now()}`,
-                        kind: "usage",
-                        payload: usage,
-                        ts: Date.now(),
-                    },
-                });
-            }
-            events.push({
-                tag: "done",
-                done: { exitReason: "done", summary: { threadId, ...(usage ? { usage } : {}) } },
-            });
-            return events;
-        }
-        if (event.type === "turn.failed" || event.type === "error") {
-            const nestedMessage = event.error && typeof event.error === "object"
-                ? event.error.message
-                : undefined;
-            let message = "codex reported an error";
-            if (typeof event.message === "string")
-                message = event.message;
-            else if (typeof event.error === "string")
-                message = event.error;
-            else if (typeof nestedMessage === "string")
-                message = nestedMessage;
-            return { tag: "error", error: { exitReason: "error", reason: message } };
-        }
-        return null;
-    };
-};
 class CodexAppServerDriverImpl {
     emitter = new TypedEmitter();
     config;
@@ -248,12 +27,13 @@ class CodexAppServerDriverImpl {
     runDir = null;
     isolatedWorkspace = null;
     isolatedStateDir = null;
+    isolationConfig = {};
     threadId = null;
     cliVersion;
     nextRequestId = 1;
     responses = new Map();
     interrupts = new Map();
-    subagentParents = new Map();
+    subagents = new CodexSubagentTracker();
     turnFacets = new Map();
     interruptCount = 0;
     idleTimer = null;
@@ -276,10 +56,12 @@ class CodexAppServerDriverImpl {
             throw new Error("codex driver: start called more than once");
         let cwd = this.config.cwd ?? (this.config.cwdMode === "artifacts" ? ctx.artifactsDir : ctx.runDir);
         let env = this.config.env;
+        let launchCommand = this.config.command;
         if (this.config.isolation) {
             const workspace = await realpath(temporaryDirectory({ prefix: "lux-codex-workspace-" }));
             await cp(ctx.artifactsDir, workspace, { recursive: true });
             this.isolatedWorkspace = workspace;
+            await stageSkills(this.config.skillDirs ?? [], workspace, ".agents");
             cwd = workspace;
         }
         if (this.config.isolation || this.config.ignoreUserConfig) {
@@ -300,6 +82,38 @@ class CodexAppServerDriverImpl {
                 CODEX_CONFIG_HOME: stateDir,
             };
         }
+        if (this.config.isolation) {
+            const reads = await Promise.all(this.config.isolation.allowRead.map((path) => realpath(path)));
+            const executable = resolveExecutable(this.config.command, { ...agentEnvironment(process.env, this.config.inheritEnv), ...env }, undefined, cwd);
+            if (executable) {
+                launchCommand = await realpath(executable);
+                reads.push(executable, launchCommand);
+            }
+            // Native filesystem tools relaunch the CLI inside the subject sandbox.
+            // Workspace requirements reload process configuration during a turn.
+            // A thread-only profile is accepted at startup but fails that reload.
+            this.isolationConfig = {
+                allow_login_shell: false,
+                project_doc_max_bytes: 0,
+                projects: { [cwd]: { trust_level: "untrusted" } },
+                default_permissions: "lux-isolated",
+                permissions: {
+                    "lux-isolated": {
+                        filesystem: {
+                            ":minimal": "read",
+                            [cwd]: "write",
+                            ...Object.fromEntries(reads.map((path) => [path, "read"])),
+                        },
+                        network: { enabled: true },
+                    },
+                },
+                features: {
+                    ...(this.config.config?.features ?? {}),
+                    shell_snapshot: false,
+                    shell_snapshot_v2: false,
+                },
+            };
+        }
         this.collectDir = cwd;
         this.artifactsDir = ctx.artifactsDir;
         this.runDir = ctx.runDir;
@@ -310,10 +124,13 @@ class CodexAppServerDriverImpl {
             commandName(this.config.command) === "codex"
                 ? await discoverCliVersion(this.config.command)
                 : undefined;
-        const managed = spawnManagedProcess(this.config.command, buildAppServerArgs(this.config), {
+        const managed = spawnManagedProcess(launchCommand, buildAppServerArgs({
+            ...this.config,
+            config: { ...this.config.config, ...this.isolationConfig },
+        }), {
             cwd,
             env: {
-                ...process.env,
+                ...agentEnvironment(process.env, this.config.inheritEnv),
                 LUX_RUN_DIR: ctx.runDir,
                 LUX_ARTIFACTS_DIR: ctx.artifactsDir,
                 ...env,
@@ -366,41 +183,31 @@ class CodexAppServerDriverImpl {
             capabilities: { experimentalApi: true, requestAttestation: false },
         });
         this.notify("initialized");
-        const isolationReads = this.config.isolation
-            ? await Promise.all(this.config.isolation.allowRead.map((path) => realpath(path)))
-            : [];
         const threadConfig = {
-            ...(this.config.config ?? {}),
-            model_reasoning_effort: this.config.reasoningEffort,
-            ...(this.config.isolation
-                ? {
-                    project_doc_max_bytes: 0,
-                    projects: { [cwd]: { trust_level: "untrusted" } },
-                    permissions: {
-                        "lux-isolated": {
-                            filesystem: {
-                                ":minimal": "read",
-                                ":workspace_roots": { ".": "write" },
-                                ...Object.fromEntries(isolationReads.map((path) => [path, "read"])),
-                            },
-                            network: { enabled: true },
-                        },
-                    },
-                }
+            ...codexConfigOverrides(this.config),
+            ...(this.config.reasoningEffort
+                ? { model_reasoning_effort: this.config.reasoningEffort }
                 : {}),
+            ...this.isolationConfig,
         };
         const started = await this.request("thread/start", {
             model: this.config.model,
             cwd,
-            runtimeWorkspaceRoots: this.config.addDirs ?? [],
+            runtimeWorkspaceRoots: this.config.isolation
+                ? [cwd, ...(this.config.addDirs ?? [])]
+                : (this.config.addDirs ?? []),
             approvalPolicy: this.config.approvalPolicy,
-            approvalsReviewer: "user",
+            approvalsReviewer: this.config.approvalsReviewer,
             ...(this.config.isolation
                 ? { permissions: "lux-isolated" }
                 : { sandbox: this.config.sandbox }),
             config: threadConfig,
             ephemeral: this.config.ephemeral,
         });
+        if (this.config.approvalsReviewer === "auto_review" &&
+            started.approvalsReviewer !== "auto_review") {
+            throw new Error("codex app-server did not enable the requested auto_review approvals reviewer");
+        }
         const thread = asRecord(started.thread);
         if (!thread || typeof thread.id !== "string") {
             throw new Error("codex app-server returned an invalid thread/start response");
@@ -411,6 +218,7 @@ class CodexAppServerDriverImpl {
             model: typeof started.model === "string" ? started.model : this.config.model,
             detail: {
                 threadId: thread.id,
+                approvalsReviewer: this.config.approvalsReviewer,
                 ...(typeof thread.sessionId === "string" ? { sessionId: thread.sessionId } : {}),
                 ...(this.cliVersion ? { cliVersion: this.cliVersion } : {}),
             },
@@ -517,6 +325,10 @@ class CodexAppServerDriverImpl {
             ? withRoot.filter((artifact) => !LUX_BOOKKEEPING_FILES.has(artifact.path))
             : withRoot;
     }
+    async verificationWorkspace() {
+        await this.quiesce();
+        return this.isolatedWorkspace ?? undefined;
+    }
     async quiesce() {
         this.clearIdleTimer();
         await this.process?.terminate();
@@ -591,6 +403,8 @@ class CodexAppServerDriverImpl {
             .catch((error) => this.fail(messageOf(error)));
     }
     async dispatch(message) {
+        if (this.terminal)
+            return;
         const method = typeof message.method === "string" ? message.method : "";
         const params = asRecord(message.params) ?? {};
         if (message.id !== undefined && method) {
@@ -601,6 +415,12 @@ class CodexAppServerDriverImpl {
             await this.handleItemNotification(method, params);
             return;
         }
+        if ((method === "thread/tokenUsage/updated" ||
+            method === "turn/completed" ||
+            method === "error") &&
+            typeof params.threadId === "string" &&
+            params.threadId !== this.threadId)
+            return;
         if (method === "thread/tokenUsage/updated") {
             this.handleTokenUsageNotification(params);
             return;
@@ -632,27 +452,23 @@ class CodexAppServerDriverImpl {
             facets.tools.push(toolName);
         if (turnId)
             this.turnFacets.set(turnId, facets);
-        this.recordSubagentParents(item);
-        const parentToolUseId = typeof params.threadId === "string" ? this.subagentParents.get(params.threadId) : undefined;
+        const threadId = typeof params.threadId === "string" ? params.threadId : undefined;
+        this.subagents.record(item, threadId, this.threadId);
+        const agent = this.subagents.attribution(threadId, this.threadId);
         const event = item
-            ? appItemProgress(item, method === "item/started" ? "started" : "completed", parentToolUseId)
+            ? appItemProgress(item, method === "item/started" ? "started" : "completed", agent)
             : null;
         if (event?.tag === "progress")
             await this.emitter.emit("progress", event.progress);
-    }
-    recordSubagentParents(item) {
-        if (item?.type !== "collabAgentToolCall" || typeof item.id !== "string")
-            return;
-        const receiverThreadIds = Array.isArray(item.receiverThreadIds)
-            ? item.receiverThreadIds.filter((value) => typeof value === "string")
-            : [];
-        for (const receiverThreadId of receiverThreadIds) {
-            this.subagentParents.set(receiverThreadId, item.id);
+        if (item) {
+            for (const lifecycle of appAgentLifecycleProgress(item, method === "item/started" ? "started" : "completed", agent, event?.tag === "progress" ? event.progress.ts : Date.now())) {
+                await this.emitter.emit("progress", lifecycle);
+            }
         }
     }
     handleTokenUsageNotification(params) {
         const tokenUsage = asRecord(params.tokenUsage);
-        const usage = appUsage(tokenUsage?.last);
+        const usage = appUsage(tokenUsage?.total) ?? appUsage(tokenUsage?.last);
         if (usage)
             this.latestUsage = usage;
     }
@@ -703,6 +519,8 @@ class CodexAppServerDriverImpl {
         }
     }
     handleErrorNotification(params) {
+        if (params.willRetry === true)
+            return;
         const error = asRecord(params.error);
         let errorMessage = "codex app-server reported an error";
         if (typeof params.message === "string")
@@ -809,8 +627,8 @@ class CodexAppServerDriverImpl {
             this.idleTimer = null;
             if (this.interrupts.size > 0)
                 return;
-            this.fail(`no event for ${this.config.idleTimeoutMs}ms`, "idle-timeout");
-        }, this.config.idleTimeoutMs);
+            this.fail(`no event for ${durationMs(this.config.idleTimeout)}ms`, "idle-timeout");
+        }, durationMs(this.config.idleTimeout));
     }
     clearIdleTimer() {
         if (!this.idleTimer)
@@ -855,12 +673,13 @@ class CodexExecDriverImpl {
             command: this.config.command,
             args: buildArgs(this.config),
             cwd,
-            env: this.config.env,
+            env: agentEnvironment(process.env, this.config.inheritEnv, this.config.env),
+            inheritEnv: false,
             protocol: "custom",
             parseEvent: makeParseEvent(this.config, cliVersion),
             formatPrompt: (prompt) => prompt,
             closeStdinAfterPrompt: true,
-            idleTimeoutMs: this.config.idleTimeoutMs,
+            idleTimeout: this.config.idleTimeout,
             maxLineBytes: this.config.maxLineBytes,
             maxInterrupts: 1,
         });
@@ -893,12 +712,31 @@ class CodexExecDriverImpl {
         await this.inner?.close();
     }
 }
-export const codexDriver = {
+export const codexDriver = defineDriver({
     name: "codex",
     configSchema: CodexDriverConfigSchema,
+    runtime: (config) => ({
+        commands: [config.command],
+        capabilities: {
+            interactive: config.interactionMode === "app-server",
+            "tool-calls": true,
+            "tool-results": true,
+            artifacts: true,
+            subagents: config.interactionMode === "app-server",
+            usage: true,
+            cost: false,
+            isolation: Boolean(config.isolation),
+        },
+    }),
+    experiment: {
+        version: "1",
+        prepare: prepareCodexExperimentConfig,
+        identity: (config, { rootDir }) => configuredClaudeSourceHashes({ name: "codex", config }, rootDir),
+    },
+    selectHarness: selectModelAndReasoningEffort,
     create: (config) => config.interactionMode === "app-server"
         ? new CodexAppServerDriverImpl(config)
         : new CodexExecDriverImpl(config),
-};
+});
 export { appItemProgress, buildAppServerArgs, buildArgs, CodexDriverConfigSchema, makeParseEvent };
 //# sourceMappingURL=index.js.map