@prismatic-io/lux 0.0.2-preview.3 → 0.0.2-preview.32

package/src/drivers/codex/config.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
-import { DEFAULT_CODEX_MODEL, ReasoningEffortSchema } from "../../core/index.js";
+import { InheritEnvironmentSchema } from "../../core/agent-environment.js";
+import { DurationSchema } from "../../core/duration.js";
+import { applyCatalogEffort, codexCatalog, DEFAULT_CODEX_MODEL } from "../../core/index.js";
 
 export type CodexConfigValue =
   | string
@@ -28,13 +30,14 @@ export const CodexDriverConfigSchema = z
   .object({
     command: z.string().default("codex"),
     model: z.string().min(1).default(DEFAULT_CODEX_MODEL),
-    reasoningEffort: ReasoningEffortSchema.default("low"),
+    reasoningEffort: z.enum(codexCatalog.efforts).optional(),
     sandbox: z
       .enum(["read-only", "workspace-write", "danger-full-access"])
       .default("workspace-write"),
     cwdMode: z.enum(["artifacts", "runDir"]).default("artifacts"),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
+    inheritEnv: InheritEnvironmentSchema.optional(),
     addDirs: z.array(z.string()).optional(),
     profile: z.string().optional(),
     config: z.record(z.string(), CodexConfigValueSchema).optional(),
@@ -46,13 +49,25 @@ export const CodexDriverConfigSchema = z
     strictConfig: z.boolean().default(false),
     interactionMode: z.enum(["app-server", "exec"]).default("app-server"),
     approvalPolicy: z.enum(["untrusted", "on-request", "never"]).default("on-request"),
+    /** Native reviewer for eligible approvals; auto_review requires app-server and on-request. */
+    approvalsReviewer: z.enum(["user", "auto_review"]).default("user"),
     isolation: IsolationSchema.optional(),
     maxInterrupts: z.number().positive().default(20),
     maxLineBytes: z.number().positive().default(10_000_000),
-    idleTimeoutMs: z.number().positive().default(600_000),
+    idleTimeout: DurationSchema.default("10 minutes"),
   })
   .strict()
   .superRefine((config, ctx) => {
+    if (
+      config.approvalsReviewer === "auto_review" &&
+      (config.interactionMode !== "app-server" || config.approvalPolicy !== "on-request")
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["approvalsReviewer"],
+        message: "auto_review requires app-server interaction mode and on-request approval policy",
+      });
+    }
     if (config.interactionMode === "app-server" && config.profile) {
       ctx.addIssue({
         code: "custom",
@@ -82,7 +97,13 @@ export const CodexDriverConfigSchema = z
         message: "isolation requires app-server interaction mode",
       });
     }
-  });
+  })
+  .transform(applyCatalogEffort(codexCatalog));
+
+const effortArgs = (config: CodexDriverConfig): string[] =>
+  config.reasoningEffort
+    ? ["--config", `model_reasoning_effort=${tomlValue(config.reasoningEffort)}`]
+    : [];
 
 export type CodexDriverConfig = z.infer<typeof CodexDriverConfigSchema>;
 
@@ -97,6 +118,27 @@ const tomlValue = (value: CodexConfigValue): string => {
     .join(",")}}`;
 };
 
+// Codex shell snapshots can replace the launching process's PATH. Pin only
+// executable-search variables here; never put other environment secrets in argv.
+export const codexConfigOverrides = (
+  config: CodexDriverConfig,
+): Record<string, CodexConfigValue> => {
+  const authored = config.config ?? {};
+  const paths = Object.fromEntries(
+    Object.entries(config.env ?? {}).filter(
+      ([key]) => key.toUpperCase() === "PATH" || key.toUpperCase() === "PATHEXT",
+    ),
+  );
+  if (Object.keys(paths).length === 0) return authored;
+  const object = (value: CodexConfigValue | undefined): Record<string, CodexConfigValue> =>
+    value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const policy = object(authored.shell_environment_policy);
+  return {
+    ...authored,
+    shell_environment_policy: { ...policy, set: { ...paths, ...object(policy.set) } },
+  };
+};
+
 export const buildExecArgs = (config: CodexDriverConfig): string[] => {
   const args = ["exec", "--json", "--color", "never", "--sandbox", config.sandbox];
   args.push("--model", config.model);
@@ -107,10 +149,10 @@ export const buildExecArgs = (config: CodexDriverConfig): string[] => {
   if (config.ignoreRules) args.push("--ignore-rules");
   if (config.strictConfig) args.push("--strict-config");
   for (const directory of config.addDirs ?? []) args.push("--add-dir", directory);
-  for (const [key, value] of Object.entries(config.config ?? {})) {
+  for (const [key, value] of Object.entries(codexConfigOverrides(config))) {
     args.push("--config", `${key}=${tomlValue(value)}`);
   }
-  args.push("--config", `model_reasoning_effort=${tomlValue(config.reasoningEffort)}`);
+  args.push(...effortArgs(config));
   if (config.extraArgs) args.push(...config.extraArgs);
   args.push("-");
   return args;
@@ -119,10 +161,10 @@ export const buildExecArgs = (config: CodexDriverConfig): string[] => {
 export const buildAppServerArgs = (config: CodexDriverConfig): string[] => {
   const args = ["app-server", "--stdio"];
   if (config.strictConfig) args.push("--strict-config");
-  for (const [key, value] of Object.entries(config.config ?? {})) {
+  for (const [key, value] of Object.entries(codexConfigOverrides(config))) {
     args.push("--config", `${key}=${tomlValue(value)}`);
   }
-  args.push("--config", `model_reasoning_effort=${tomlValue(config.reasoningEffort)}`);
+  args.push(...effortArgs(config));
   if (config.extraArgs) args.push(...config.extraArgs);
   return args;
 };

package/src/drivers/codex/exec-events.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+import { type ParsedDriverEvent, type TokenUsage, toolResultProgress } from "../../core/index.js";
+import type { CodexDriverConfig } from "./config.js";
+
+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: unknown): TokenUsage | null => {
+  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: unknown): string => {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter(
+      (block): block is { type: "text"; text: string } =>
+        typeof block === "object" &&
+        block !== null &&
+        (block as { type?: unknown }).type === "text" &&
+        typeof (block as { text?: unknown }).text === "string",
+    )
+    .map((block) => block.text)
+    .join("\n");
+};
+
+const startedItemProgress = (
+  item: Record<string, unknown>,
+  id: string,
+): ParsedDriverEvent | null => {
+  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: Record<string, unknown>,
+  id: string,
+): ParsedDriverEvent | null => {
+  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 as Record<string, unknown>)
+        : 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 as Record<string, unknown> }
+            : {}),
+          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: Record<string, unknown>,
+  phase: "started" | "completed",
+): ParsedDriverEvent | null => {
+  const id = typeof item.id === "string" ? item.id : `${String(item.type)}-${Date.now()}`;
+  return phase === "started" ? startedItemProgress(item, id) : completedItemProgress(item, id);
+};
+
+export const makeParseEvent = (config: CodexDriverConfig, cliVersion?: string) => {
+  let threadId: string | undefined;
+  return (line: string): ParsedDriverEvent | ParsedDriverEvent[] | null => {
+    let event: Record<string, unknown>;
+    try {
+      event = JSON.parse(line) as Record<string, unknown>;
+    } 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 as Record<string, unknown>,
+        event.type === "item.started" ? "started" : "completed",
+      );
+    }
+    if (event.type === "turn.completed") {
+      const usage = parseUsage(event.usage);
+      const events: ParsedDriverEvent[] = [];
+      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 as Record<string, unknown>).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;
+  };
+};