@agent-compose/sdk 0.8.0 → 0.8.2

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

@@ -25,6 +25,31 @@
  */
 import type { AgentMessage, ModelExecutionContract, RuntimeOptions, SandboxProvider, ToolCallGateResult } from "../index.js";
 import type { ProcessorContext, ToolCall } from "../processors/processor.js";
+/** Backoff between tail re-attach attempts after a mid-turn stream fault
+ *  (durable detached transport). Short: the runner is alive and producing,
+ *  and each retry costs one exec; the executor's evidence machinery — not
+ *  this loop — bounds a truly dead sandbox. Exported for tests. */
+export declare const TAIL_REATTACH_DELAY_MS = 2000;
+/** Provider deadline on the detached LAUNCH exec. The launch shell only
+ *  truncates the durable files, forks the detached runner (stdio fully
+ *  redirected — see the launch command), writes the pidfile, and echoes the
+ *  pid — sub-second work, so 30s is generous headroom for a slow envd, not a
+ *  budget the runner ever consumes. Exported for tests. */
+export declare const LAUNCH_EXEC_TIMEOUT_MS = 30000;
+/** How many times (and how spaced) a THROWN launch exec falls back to reading
+ *  the durable pidfile before the fault is surfaced. A deadlined/canceled
+ *  launch STREAM does not mean the launch failed — the detached tree may be
+ *  up and working — so the pid is recovered over the envd HTTP file
+ *  transport (immune to the command-stream fault) and the turn proceeds.
+ *  Only "no pidfile after these attempts" is a real launch failure.
+ *  Exported for tests. */
+export declare const LAUNCH_PID_RECOVERY_ATTEMPTS = 3;
+export declare const LAUNCH_PID_RECOVERY_DELAY_MS = 1000;
+/** Explicit deadline on the `command -v` install probe. E2B's default command
+ *  deadline (60s) throws the deadline_exceeded TimeoutError — every provider
+ *  call in the turn path carries an explicit timeout so no SDK default can
+ *  decide a turn's fate. Exported for tests. */
+export declare const INSTALL_PROBE_TIMEOUT_MS = 30000;
 /** Single-quote a value for safe interpolation into a `sh -c` command line. */
 export declare function shellQuote(value: string): string;
 /**
@@ -69,13 +94,15 @@ export declare const ACP_TURN_IDLE_TIMEOUT_MS: number;
  *  implements duplex) falls back to JSONL cleanly via the capability check in
  *  `sendMessage`. */
 export declare const ACP_TRANSPORT_READY = true;
-/** Reasoning-effort level a CLI turn may carry (T2 session effort). The
- *  per-CLI mapping lives in each spec's `buildCommand` — Claude Code takes a
- *  thinking-token budget via `MAX_THINKING_TOKENS`, codex takes
- *  `-c model_reasoning_effort=<level>`. Specs without a real knob
- *  (opencode/droid/cursor) never receive one: the server hides + rejects
- *  effort for those runtimes. */
-export type CliReasoningEffort = "low" | "medium" | "high";
+/** Reasoning-effort level a CLI turn may carry (T2 session effort) — the
+ *  UNION of what the effort-capable CLIs accept. The per-CLI mapping lives in
+ *  each spec's `buildCommand` — Claude Code takes its own `--effort` flag
+ *  (all five levels), codex takes `-c model_reasoning_effort=<level>`
+ *  (low|medium|high|xhigh — no "max"; the spec clamps it). Specs without a
+ *  real knob (opencode/droid/cursor) never receive one: the server hides +
+ *  rejects effort for those runtimes, and rejects levels a runtime lacks
+ *  (sessionEffortLockError). */
+export type CliReasoningEffort = "low" | "medium" | "high" | "xhigh" | "max";
 /** 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 {

package/dist/runtimes/claude-code.d.ts

@@ -40,18 +40,20 @@ import { type CliAgentSpec, type CliReasoningEffort } from "./_cli-agent.js";
  *  bridge daemon (cli/src/bridge/acp.ts) imports this same pin so both
  *  executors launch the identical adapter. Verified against 0.16.2. */
 export declare const CLAUDE_CODE_ACP_ADAPTER = "@zed-industries/claude-code-acp@0.16.2";
-/** Extended-thinking token budget per effort level — Claude Code's real knob
- *  is the `MAX_THINKING_TOKENS` env var (its documented settings env), set
- *  per invocation below. Values mirror the platform turn loop's
- *  `EFFORT_BUDGET_TOKENS` (server model-client) so "high" means the same
- *  thing in a channel and in a claude-code session. */
-export declare const CLAUDE_CODE_THINKING_TOKENS: Record<CliReasoningEffort, number>;
+/** Claude Code's real reasoning knob is its own `--effort <level>` flag
+ *  (low|medium|high|xhigh|max — verified against `claude -p --help`). The
+ *  CliReasoningEffort union IS the CLI's vocabulary, so the level rides the
+ *  flag verbatim; the CLI itself downgrades a level the selected model lacks
+ *  (its documented behaviour, e.g. xhigh → high off Opus). The old
+ *  `MAX_THINKING_TOKENS` env mapping is gone: the CLI deprecated it (treated
+ *  as on/off on current models) and it could never express xhigh/max. */
+export declare const CLAUDE_CODE_EFFORT_LEVELS: readonly CliReasoningEffort[];
 export declare const claudeCodeSpec: CliAgentSpec;
 export interface ClaudeCodeRuntimeConfig {
     /** Claude model id (`--model`). Omit to use the CLI's configured default. */
     model?: string;
-    /** Extended-thinking effort (`MAX_THINKING_TOKENS`). Omit for the CLI's
-     *  default behaviour (no forced budget). */
+    /** Reasoning effort (`--effort <level>`; the CLI accepts all five levels).
+     *  Omit for the CLI's default behaviour. */
     effort?: CliReasoningEffort;
 }
 export declare function createClaudeCodeRuntime(config?: ClaudeCodeRuntimeConfig): import("../index.js").AgentRuntime<import("../sandbox.js").SandboxProvider>;

package/dist/runtimes/codex.buildcommand.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * codexSpec.buildCommand — the in-sandbox `codex exec --json` invocation for
+ * cloud codex sessions. Regression pin for the resume `-C` bug: the working
+ * directory rides a shell `cd` (like every other runtime), NOT codex's `-C`
+ * flag, because `-C` is accepted by `codex exec` but REJECTED by
+ * `codex exec resume` ("unexpected argument '-C'") — so a fresh turn worked
+ * and every follow-up died with exit code 2.
+ */
+export {};

package/dist/runtimes/codex.d.ts

@@ -20,12 +20,15 @@ export declare function isCodexAdvisoryNoise(text: string): boolean;
  *  `mapEvent` is the golden the ACP normaliser is asserted equal to. Not part
  *  of the public runtime surface — `createCodexRuntime` stays the entry point. */
 export declare const codexSpec: CliAgentSpec;
+/** The effort levels codex actually has (`model_reasoning_effort`):
+ *  low|medium|high|xhigh — no "max" (that level is Claude Code's alone). */
+export type CodexReasoningEffort = Exclude<CliReasoningEffort, "max">;
 export interface CodexRuntimeConfig {
     /** Codex model id (`-m`). Omit to use the codex CLI's configured default. */
     model?: string;
     /** Reasoning effort (`-c model_reasoning_effort=<level>`). Omit to use the
      *  codex CLI's configured default. */
-    effort?: CliReasoningEffort;
+    effort?: CodexReasoningEffort;
 }
 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>;