@agent-compose/sdk 0.5.2 → 0.5.6

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export type { WorkflowDefinition } from "./types/workflow.js";
 export { defineSandboxEnvironment } from "./types/sandbox-environment.js";
 export type { SandboxEnvironmentDefinition } from "./types/sandbox-environment.js";
 export type { AgentRuntime, McpServerConfig, ModelExecutionContract, ToolCallGateResult, RuntimeOptions, } from "./types/runtime.js";
-export type { WorkflowFn, WorkflowCtx, WorkflowRun, AgentBudget, WorkflowHooks, SnapshotConfig, BootSnapshot, IOSchema, OutputSchema, WorkflowMemoryConfig, } from "./types/workflow.js";
+export type { WorkflowFn, WorkflowCtx, WorkflowRun, AgentBudget, WorkflowHooks, SnapshotConfig, BootSnapshot, ReuseSnapshot, IOSchema, OutputSchema, WorkflowMemoryConfig, } from "./types/workflow.js";
 export type { RunSnapshotEntry } from "./client.js";
 export type { WorkflowPlan, WorkflowStepPlan } from "./types/workflow-plan.js";
 export type { BaseExecutionContext, InvokeChild } from "./types/execution-context.js";
@@ -27,7 +27,7 @@ export type { Processor, ProcessorContext, ProcessorVerdict, ToolCall, } from ".
 export type { AgentMessage, AgentMessageInit, AgentMessageText, AgentMessageThinking, AgentMessageToolUse, AgentMessageToolResult, AgentMessageDone, AgentMessageError, AgentMessageUsage, AgentStatus, } from "./types/protocol.js";
 export type { SandboxProvider, DesktopSandboxProvider, } from "./types/sandbox.js";
 export { AgentComposeClient } from "./client.js";
-export type { RegisterResult, RegisterWorkflowInput, RuntimeSourceInput, InvokeWorkflowOptions, InvokeAndWaitOptions, InvokeResult, ListSnapshotsOptions, TemplateRow, ListTemplatesOptions, CreateFactoryInput, UpdateFactoryInput, SecretOptions, SetSecretResult, SecretListEntry, CreateApiKeyInput, StreamRunLogsOptions, EventSubjectType, EventRow, ReportEventInput, ListEventsOptions, ListEventsResult, RunLogLine, ListRunLogsOptions, RegisteredRuntime, RunState, RunStatus, FactoryRow, SnapshotListEntry, SnapshotListResponse, ApiKey, ApiKeyCreated, UsageRollupRow, UsageResponse, CancelRunResponse, RequestAgentPauseOptions, RequestAgentPauseResponse, SendAgentMessageOptions, SendAgentMessageResponse, AnswerSteerOptions, } from "./client.js";
+export type { RegisterResult, RegisterWorkflowInput, RuntimeSourceInput, InvokeWorkflowOptions, InvokeAndWaitOptions, InvokeResult, ListSnapshotsOptions, TemplateRow, ListTemplatesOptions, CreateFactoryInput, UpdateFactoryInput, SecretOptions, SetSecretResult, SecretListEntry, CreateApiKeyInput, StreamRunLogsOptions, EventSubjectType, EventRow, ReportEventInput, ListEventsOptions, ListEventsResult, RunLogLine, ListRunLogsOptions, RegisteredRuntime, RunState, RunStatus, FactoryRow, SnapshotListEntry, SnapshotListResponse, ApiKey, ApiKeyCreated, UsageRollupRow, UsageResponse, CancelRunResponse, RequestAgentPauseOptions, RequestAgentPauseResponse, SendAgentMessageOptions, SendAgentMessageResponse, AnswerSteerOptions, ResumePauseOptions, ResumePauseResponse, ResumePauseSuccess, ResumePausePending, ResumePauseActor, } from "./client.js";
 export { parseSseStream } from "./sse.js";
 export { AgentComposeError } from "./errors.js";
 export { formatError } from "./utils/errors.js";
@@ -37,8 +37,15 @@ export { AgentStatusSchema } from "./utils/schemas.js";
 export { createClaudeRuntime, ClaudeRunner } from "./runtimes/claude.js";
 export type { ClaudeRuntimeConfig } from "./runtimes/claude.js";
 export { default as claudeRuntime } from "./runtimes/claude.js";
-export { createVercelRuntime, VercelRunner } from "./runtimes/vercel.js";
-export type { VercelRuntimeConfig } from "./runtimes/vercel.js";
+export { createVercelRuntime, VercelRunner, listVercelRuntimeModels } from "./runtimes/vercel.js";
+export type { VercelRuntimeConfig, VercelRuntimeModel } from "./runtimes/vercel.js";
+export type { GatewayModelId } from "ai";
+export { createCodexRuntime } from "./runtimes/codex.js";
+export type { CodexRuntimeConfig } from "./runtimes/codex.js";
+export { default as codexRuntime } from "./runtimes/codex.js";
+export { createAmpRuntime } from "./runtimes/amp.js";
+export type { AmpRuntimeConfig } from "./runtimes/amp.js";
+export { default as ampRuntime } from "./runtimes/amp.js";
 export { bashTool, codingTools, editTool, readTool, writeTool } from "./tools/index.js";
 export type { CodingTool } from "./tools/index.js";
 export type { RunEvent } from "./types/events.js";

package/dist/index.js

@@ -18,7 +18,7 @@ var __toESM = (mod, isNodeMode, target) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/runtimes/vercel.ts
-import { streamText, stepCountIs, tool } from "ai";
+import { streamText, stepCountIs, tool, gateway } from "ai";
 
 // src/types/runtime.ts
 function defineRuntime(pkg) {
@@ -387,6 +387,8 @@ class VercelRunner {
   options;
   config;
   supportsToolCallProcessor = true;
+  kind;
+  model;
   tools;
   messages = [];
   constructor(sandbox, options, config) {
@@ -394,6 +396,8 @@ class VercelRunner {
     this.options = options;
     this.config = config;
     this.tools = config.tools ?? codingTools;
+    this.kind = config.kind;
+    this.model = config.modelId;
   }
   async gateToolCall(call, ctx) {
     const verdict = await runProcessorChain(this.options.processors ?? [], (p) => p.processToolCall, call, ctx);
@@ -511,6 +515,10 @@ function createVercelRuntime(config) {
     create: (sandbox, opts) => new VercelRunner(sandbox, opts, config)
   });
 }
+async function listVercelRuntimeModels() {
+  const { models } = await gateway.getAvailableModels();
+  return models.filter((m) => m.modelType == null || m.modelType === "language").map((m) => ({ id: m.id, name: m.name })).sort((a, b) => a.id.localeCompare(b.id));
+}
 // src/types/workflow.ts
 import { z as z3 } from "zod";
 
@@ -2368,6 +2376,259 @@ function createClaudeRuntime(config = {}) {
   });
 }
 var claude_default = createClaudeRuntime();
+// src/runtimes/_cli-agent.ts
+function now3() {
+  return new Date().toISOString();
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+class CliAgentRunner {
+  sandbox;
+  options;
+  spec;
+  configModel;
+  kind;
+  constructor(sandbox, options, spec, configModel) {
+    this.sandbox = sandbox;
+    this.options = options;
+    this.spec = spec;
+    this.configModel = configModel;
+    this.kind = spec.kind;
+  }
+  get model() {
+    return this.configModel ?? this.options.model ?? this.spec.defaultModel;
+  }
+  installed = false;
+  async ensureInstalled() {
+    if (this.installed)
+      return;
+    const probe = await this.sandbox.commands.run(`command -v ${this.spec.bin}`);
+    if (probe.exitCode === 0) {
+      this.installed = true;
+      return;
+    }
+    const res = await this.sandbox.commands.run(this.spec.install, { timeoutMs: 300000 });
+    if (res.exitCode !== 0) {
+      throw new Error(`failed to install ${this.spec.bin}: ${(res.stderr || res.stdout || "").slice(-500)}`);
+    }
+    this.installed = true;
+  }
+  async* sendMessage(opts) {
+    yield { type: "init", sessionId: opts.sessionId ?? "", timestamp: now3() };
+    let sessionId = opts.sessionId;
+    let sawError = false;
+    try {
+      await this.ensureInstalled();
+      const promptPath = `/tmp/ac-${this.spec.kind}-${this.options.agentId ?? "agent"}-${opts.iteration ?? 0}.in`;
+      await this.sandbox.files.write(promptPath, this.spec.promptPayload(opts.prompt));
+      const cmd = this.spec.buildCommand({
+        promptPath,
+        sessionId: opts.sessionId,
+        model: this.model,
+        cwd: this.options.cwd
+      });
+      const lines = new AsyncQueue;
+      let buf = "";
+      const onStdout = (data) => {
+        buf += data;
+        let nl;
+        while ((nl = buf.indexOf(`
+`)) >= 0) {
+          const line = buf.slice(0, nl).trim();
+          buf = buf.slice(nl + 1);
+          if (line)
+            lines.push(line);
+        }
+      };
+      const runPromise = this.sandbox.commands.run(cmd, {
+        ...this.options.cwd ? { cwd: this.options.cwd } : {},
+        onStdout
+      }).then((res2) => {
+        const tail = buf.trim();
+        if (tail)
+          lines.push(tail);
+        lines.close();
+        return res2;
+      }, (err) => {
+        lines.close();
+        throw err;
+      });
+      for await (const line of lines) {
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const sid = this.spec.extractSessionId(parsed);
+        if (sid)
+          sessionId = sid;
+        for (const msg of this.spec.mapEvent(parsed)) {
+          if (msg.type === "error")
+            sawError = true;
+          yield msg;
+        }
+      }
+      const res = await runPromise;
+      if (res.exitCode !== 0 && !sawError) {
+        const tail = (res.stderr ?? "").slice(-2000);
+        yield { type: "error", text: `${this.spec.kind} exited with code ${res.exitCode}${tail ? `: ${tail}` : ""}`, timestamp: now3() };
+        return;
+      }
+      if (!sawError)
+        yield { type: "done", sessionId: sessionId ?? "", timestamp: now3() };
+    } catch (err) {
+      yield { type: "error", text: formatError(err), timestamp: now3() };
+    }
+  }
+}
+function createCliAgentRuntime(spec, configModel) {
+  return defineRuntime({
+    create: (sandbox, opts) => new CliAgentRunner(sandbox, opts, spec, configModel)
+  });
+}
+
+// src/runtimes/codex.ts
+function now4() {
+  return new Date().toISOString();
+}
+var codexSpec = {
+  kind: "codex",
+  authEnv: "CODEX_API_KEY",
+  bin: "codex",
+  install: 'sudo npm install -g @openai/codex && (command -v codex >/dev/null 2>&1 || sudo ln -sf "$(npm prefix -g)/bin/codex" /usr/local/bin/codex)',
+  promptPayload: (prompt) => prompt,
+  buildCommand: ({ promptPath, sessionId, model, cwd }) => {
+    const flags = [
+      "--json",
+      "--skip-git-repo-check",
+      "--dangerously-bypass-approvals-and-sandbox",
+      ...model ? ["-m", shellQuote(model)] : [],
+      ...cwd ? ["-C", shellQuote(cwd)] : []
+    ].join(" ");
+    const exec = sessionId ? `codex exec resume ${shellQuote(sessionId)} ${flags}` : `codex exec ${flags}`;
+    return `${exec} - < ${shellQuote(promptPath)}`;
+  },
+  extractSessionId: (p) => p.type === "thread.started" && typeof p.thread_id === "string" ? p.thread_id : undefined,
+  mapEvent: (p) => {
+    const ts = now4();
+    switch (p.type) {
+      case "item.started":
+      case "item.completed": {
+        const item = p.item;
+        if (!item)
+          return [];
+        const itype = String(item.type ?? "");
+        if (itype === "agent_message") {
+          return p.type === "item.completed" ? [{ type: "text", text: String(item.text ?? ""), timestamp: ts }] : [];
+        }
+        if (itype === "reasoning") {
+          return p.type === "item.completed" ? [{ type: "thinking", text: String(item.text ?? ""), timestamp: ts }] : [];
+        }
+        if (itype === "command_execution") {
+          const id = String(item.id ?? "");
+          if (p.type === "item.started") {
+            return [{ type: "tool_use", toolName: "shell", toolInput: { command: String(item.command ?? "") }, toolUseId: id, timestamp: ts }];
+          }
+          const failed = item.status === "failed" || typeof item.exit_code === "number" && item.exit_code !== 0;
+          return [{ type: "tool_result", toolUseId: id, output: String(item.aggregated_output ?? item.output ?? ""), isError: failed, timestamp: ts }];
+        }
+        if (p.type === "item.completed") {
+          return [{ type: "tool_use", toolName: itype || "item", toolInput: item, toolUseId: String(item.id ?? ""), timestamp: ts }];
+        }
+        return [];
+      }
+      case "turn.completed": {
+        const u = p.usage;
+        if (!u)
+          return [];
+        return [{
+          type: "usage",
+          inputTokens: u.input_tokens ?? 0,
+          outputTokens: u.output_tokens ?? 0,
+          cacheReadTokens: u.cached_input_tokens ?? 0,
+          cacheCreationTokens: 0,
+          durationMs: 0,
+          numTurns: 1,
+          timestamp: ts
+        }];
+      }
+      case "turn.failed":
+      case "error":
+        return [{ type: "error", text: formatError(p.error ?? p.message ?? p), timestamp: ts }];
+      default:
+        return [];
+    }
+  }
+};
+function createCodexRuntime(config = {}) {
+  return createCliAgentRuntime(codexSpec, config.model);
+}
+var codex_default = createCodexRuntime();
+// src/runtimes/amp.ts
+function now5() {
+  return new Date().toISOString();
+}
+function blocks(msg) {
+  const inner = msg.message?.content ?? msg.content ?? [];
+  return inner;
+}
+var ampSpec = {
+  kind: "amp",
+  authEnv: "AMP_API_KEY",
+  bin: "amp",
+  install: 'sudo npm install -g @ampcode/cli && (command -v amp >/dev/null 2>&1 || sudo ln -sf "$(npm prefix -g)/bin/amp" /usr/local/bin/amp)',
+  promptPayload: (prompt) => JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: prompt }] } }) + `
+`,
+  buildCommand: ({ promptPath, sessionId }) => {
+    const cont = sessionId ? `threads continue ${shellQuote(sessionId)} ` : "";
+    return `amp ${cont}-x --stream-json --stream-json-input < ${shellQuote(promptPath)}`;
+  },
+  extractSessionId: (p) => typeof p.session_id === "string" ? p.session_id : undefined,
+  mapEvent: (p) => {
+    const ts = now5();
+    if (p.type === "assistant") {
+      return blocks(p).flatMap((b) => {
+        if (b.type === "text")
+          return [{ type: "text", text: String(b.text ?? ""), timestamp: ts }];
+        if (b.type === "thinking")
+          return [{ type: "thinking", text: String(b.thinking ?? ""), timestamp: ts }];
+        if (b.type === "tool_use")
+          return [{ type: "tool_use", toolName: String(b.name ?? ""), toolInput: b.input ?? {}, toolUseId: String(b.id ?? ""), timestamp: ts }];
+        return [];
+      });
+    }
+    if (p.type === "user") {
+      return blocks(p).flatMap((b) => b.type === "tool_result" ? [{ type: "tool_result", toolUseId: String(b.tool_use_id ?? ""), output: typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? ""), isError: Boolean(b.is_error), timestamp: ts }] : []);
+    }
+    if (p.type === "result") {
+      const out = [];
+      const u = p.usage;
+      if (u)
+        out.push({
+          type: "usage",
+          inputTokens: u.input_tokens ?? 0,
+          outputTokens: u.output_tokens ?? 0,
+          cacheReadTokens: u.cache_read_input_tokens ?? 0,
+          cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+          durationMs: Number(p.duration_ms ?? 0),
+          numTurns: Number(p.num_turns ?? 0),
+          timestamp: ts
+        });
+      if (p.is_error || p.subtype === "error") {
+        out.push({ type: "error", text: formatError(p.result ?? p.error), timestamp: ts });
+      }
+      return out;
+    }
+    return [];
+  }
+};
+function createAmpRuntime(config = {}) {
+  return createCliAgentRuntime(ampSpec, config.model);
+}
+var amp_default = createAmpRuntime();
 // src/sandbox.ts
 import { promises as fs2 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
@@ -3666,6 +3927,7 @@ export {
   parseAgentResponse,
   makeSandboxProvider,
   makeDesktopSandboxProvider,
+  listVercelRuntimeModels,
   listOwnedSandboxes,
   killSandboxById,
   killAllSandboxes,
@@ -3683,8 +3945,11 @@ export {
   defineRuntime,
   createVercelRuntime,
   createSandbox,
+  createCodexRuntime,
   createClaudeRuntime,
+  createAmpRuntime,
   codingTools,
+  codex_default as codexRuntime,
   claude_default as claudeRuntime,
   classifyError,
   bundleWorkflow,
@@ -3692,6 +3957,7 @@ export {
   buildInvokeChild,
   bashTool,
   assertDefaultExportIsDefineWorkflow,
+  amp_default as ampRuntime,
   agentLoop,
   agent,
   WorkflowSourceValidationError,

package/dist/runtimes/_cli-agent.d.ts

@@ -0,0 +1,89 @@
+/**
+ * CLI-agent runtime base — drive an external agentic coding CLI inside the
+ * sandbox and map its JSON-Lines (JSONL) stream onto the `AgentMessage`
+ * contract.
+ *
+ * This is a different *mechanism* from the other runtimes: `claudeRuntime`
+ * drives the Anthropic Agent SDK and `vercelRuntime` drives the Vercel AI SDK,
+ * but a CLI-agent runtime spawns the provider's own CLI (`codex exec --json`,
+ * `amp -x --stream-json`) — the CLI brings its own agent loop + tools, and we
+ * only stream-parse the events it prints. Codex and Amp are the first two; this
+ * base is the shared machinery (spawn → line-buffer stdout → JSONL parse →
+ * AsyncQueue bridge → init/usage/done/error lifecycle), parameterised per-CLI
+ * by a `CliAgentSpec`.
+ *
+ * Provisioning (per spec): the runtime installs the provider CLI on demand —
+ * `command -v <bin>` before the first turn, falling back to the spec's
+ * `install` command when it's absent — so it works on a bare sandbox with no
+ * manual setup or hardcoded snapshot id. Pair it with
+ * `snapshots: { bootFrom: "reuse" }` on the workflow and the install happens
+ * exactly once: the first run installs the CLI and captures a snapshot, and
+ * every run after boots from that snapshot with the CLI already present (the
+ * probe short-circuits). The provider's API key must be in the sandbox env
+ * (see each spec's `authEnv`); `commands.run` inherits the sandbox env, so
+ * values set via `agentc secrets set` are visible to the CLI.
+ */
+import type { AgentMessage, ModelExecutionContract, RuntimeOptions, SandboxProvider } from "../index.js";
+/** Single-quote a value for safe interpolation into a `sh -c` command line. */
+export declare function shellQuote(value: string): string;
+/** Per-CLI behaviour. The base owns the lifecycle (init/done/error) and the
+ *  transport (spawn + JSONL parse); a spec owns the CLI-specific bits. */
+export interface CliAgentSpec {
+    /** Runtime self-id surfaced on `agent.spawned` (dashboard runtime icon). */
+    kind: string;
+    /** Env var the CLI reads for auth — documentation only (must be set in the
+     *  sandbox env via a workflow secret). */
+    authEnv: string;
+    /** Default model id when none is configured; omit to let the CLI choose. */
+    defaultModel?: string;
+    /** Binary the runtime spawns (`codex`, `amp`). Probed with `command -v`
+     *  before the first turn; if absent, `install` provisions it. */
+    bin: string;
+    /** Shell command that installs `bin` when it's missing from the sandbox.
+     *  Runs at most once per runner, and only when the probe fails — so booting
+     *  from a snapshot that already has the CLI (the steady state under
+     *  `snapshots: { bootFrom: "reuse" }`) skips it. Must leave `bin` resolvable
+     *  on a non-login shell's PATH (the runtime spawns via `sh -c`). */
+    install: string;
+    /** Serialise the user prompt into the bytes written to the prompt file —
+     *  plain text for a CLI that reads the prompt from stdin (codex `-`), or a
+     *  JSONL user message for a `--stream-json-input` CLI (amp). */
+    promptPayload(prompt: string): string;
+    /** Build the one-shot shell command for a turn. `promptPath` is a file in the
+     *  sandbox holding `promptPayload(prompt)`; `sessionId` continues a thread. */
+    buildCommand(args: {
+        promptPath: string;
+        sessionId?: string;
+        model?: string;
+        cwd?: string;
+    }): string;
+    /** Map one parsed JSONL stdout event to `AgentMessage`s. The base emits
+     *  `init`/`done`/`error` lifecycle itself, so a spec maps only content +
+     *  usage (text / thinking / tool_use / tool_result / usage). */
+    mapEvent(parsed: Record<string, unknown>): AgentMessage[];
+    /** Pull a session/thread id out of a parsed event so the next turn can
+     *  resume it (codex `thread.started.thread_id`, amp `session_id`). */
+    extractSessionId(parsed: Record<string, unknown>): string | undefined;
+}
+export declare class CliAgentRunner implements ModelExecutionContract {
+    private readonly sandbox;
+    private readonly options;
+    private readonly spec;
+    private readonly configModel?;
+    readonly kind: string;
+    constructor(sandbox: SandboxProvider, options: RuntimeOptions, spec: CliAgentSpec, configModel?: string | undefined);
+    get model(): string | undefined;
+    private installed;
+    /** Provision the CLI on demand. A no-op once `bin` is on PATH — the steady
+     *  state under `snapshots: { bootFrom: "reuse" }`, where the first run's
+     *  install is baked into the snapshot every later run boots from. So the
+     *  install command runs exactly once: on the first run of a content hash. */
+    private ensureInstalled;
+    sendMessage(opts: {
+        prompt: string;
+        sessionId?: string;
+        iteration?: number;
+        signal?: AbortSignal;
+    }): AsyncGenerator<AgentMessage>;
+}
+export declare function createCliAgentRuntime(spec: CliAgentSpec, configModel?: string): import("../index.js").AgentRuntime<SandboxProvider>;

package/dist/runtimes/amp.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Amp CLI runtime — drives Sourcegraph's `amp -x --stream-json` agentic CLI
+ * inside the sandbox and maps its (Claude-Code-compatible) JSONL stream onto
+ * the AgentMessage contract. Built on the shared CLI-agent base; Amp brings its
+ * own loop + tools, so we only stream-parse what it prints.
+ *
+ * Auth: set `AMP_API_KEY` (`sgamp_…`) in the sandbox env via a workflow secret.
+ * The runtime installs the `amp` CLI (`@ampcode/cli`) on demand — no image
+ * baking needed; pair with `snapshots: { bootFrom: "reuse" }` to install once
+ * and boot from the captured snapshot on every run after. The model is chosen
+ * by the AMP_API_KEY account (e.g. a GPT-only token runs GPT); the runtime
+ * doesn't pin a model.
+ *
+ * Verified against a live `amp -x --stream-json` run: the user-message stdin
+ * shape, assistant content blocks, and result usage below all round-trip.
+ */
+export interface AmpRuntimeConfig {
+    /** Amp uses its configured model; reserved for forward-compatibility. */
+    model?: string;
+}
+export declare function createAmpRuntime(config?: AmpRuntimeConfig): import("../index.js").AgentRuntime<import("../sandbox.js").SandboxProvider>;
+declare const _default: import("../index.js").AgentRuntime<import("../sandbox.js").SandboxProvider>;
+export default _default;

package/dist/runtimes/cli-agent.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CliAgentRunner self-provisioning — the runtime installs its CLI on demand
+ * (`command -v <bin>` → install if missing), runs the install at most once per
+ * runner, and surfaces an install failure as an `error` message rather than
+ * blowing up. This is what lets `createCodexRuntime()` work on a bare sandbox
+ * with no image baking, and lets `snapshots: { bootFrom: "reuse" }` collapse
+ * the install to a one-time cost.
+ */
+export {};

package/dist/runtimes/codex.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Codex CLI runtime — drives OpenAI's `codex exec --json` agentic CLI inside
+ * the sandbox and maps its JSONL event stream onto the AgentMessage contract.
+ * Built on the shared CLI-agent base; Codex brings its own loop + tools, so we
+ * only stream-parse what it prints.
+ *
+ * Auth: set `OPENAI_API_KEY` (or `CODEX_API_KEY`) in the sandbox env via a
+ * workflow secret. The runtime installs the `codex` CLI (`@openai/codex`) on
+ * demand — no image baking needed; pair with `snapshots: { bootFrom: "reuse" }`
+ * to install once and boot from the captured snapshot on every run after.
+ *
+ * Verified against codex-cli 0.124.0: `codex exec --json` + resume-by-thread,
+ * with the command_execution / reasoning / agent_message item shapes below.
+ */
+export interface CodexRuntimeConfig {
+    /** Codex model id (`-m`). Omit to use the codex CLI's configured default. */
+    model?: string;
+}
+export declare function createCodexRuntime(config?: CodexRuntimeConfig): import("../index.js").AgentRuntime<import("../sandbox.js").SandboxProvider>;
+declare const _default: import("../index.js").AgentRuntime<import("../sandbox.js").SandboxProvider>;
+export default _default;