agents 0.26.0 → 0.28.0

package/dist/harness/container/index.d.ts

@@ -0,0 +1,740 @@
+import {
+  _ as LifecycleJobContext,
+  n as CapabilityStartContext,
+  s as LifecycleCapability,
+  v as LifecycleJobOutcome
+} from "../../capability-runner-BiVUtjqC.js";
+import {
+  d as ContainerInputPart,
+  f as ContainerMessage,
+  g as ContainerWhenBusy,
+  h as ContainerSettings,
+  l as ContainerEvent,
+  m as ContainerPart,
+  u as ContainerInput,
+  x as JsonValue
+} from "../../protocol-BEgrJYC5.js";
+import { r as JsonValue$1, t as HarnessStore } from "../../store-BKM4Xm9M.js";
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+//#region src/harness/container/egress.d.ts
+/** One intercepted host and where its requests go. */
+type EgressRoute = {
+  /** The placeholder hostname the CLI calls, such as `anthropic.harness.internal`. */ readonly host: string /** The real base URL. The request's path and query are appended. */;
+  readonly upstream: string /** Headers to set on the forwarded request, such as credentials. */;
+  readonly headers: {
+    readonly [name: string]: string;
+  } /** Headers to drop from the CLI's request, such as its placeholder key. */;
+  readonly strip: readonly string[];
+};
+/** What `ContainerEgress` is given, as its props. */
+type ContainerEgressProps = {
+  readonly routes: readonly EgressRoute[];
+};
+/**
+ * The `ctx.exports` entry for `ContainerEgress`: called with props, it
+ * returns the `Fetcher` an intercept hands requests to.
+ */
+type ContainerEgressBinding = (init: {
+  readonly props: ContainerEgressProps;
+}) => Fetcher;
+/**
+ * The egress for a `ContainerHarness`'s credentials. Export it from your
+ * Worker's main module so `ctx.exports.ContainerEgress` exists:
+ *
+ * ```ts
+ * export { ContainerEgress } from "agents/harness/container";
+ * ```
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare class ContainerEgress extends WorkerEntrypoint<
+  unknown,
+  ContainerEgressProps
+> {
+  /**
+   * Forward one request the container made.
+   *
+   * @param request - The intercepted request.
+   * @returns The upstream's response.
+   */
+  fetch(request: Request): Promise<Response>;
+}
+//#endregion
+//#region src/harness/container/managed-image.d.ts
+/**
+ * One setup command, run once in the fresh container and kept in its
+ * snapshot.
+ *
+ * Steps run as root by default. A step with `user: "agent"` runs as the
+ * user the CLI runs as, with `HOME=/home/agent`: anything it puts in that
+ * home (installed plugins and mods, `~/.claude/settings.json`, skills,
+ * `~/.codex/config.toml`) is in every session's home, because each session
+ * home starts as a copy of it.
+ */
+type SetupStep = {
+  /** What the step does, for error messages. */ readonly name: string;
+  readonly command: readonly string[] /** Who runs it. Default `root`. */;
+  readonly user?: "root" | "agent";
+};
+//#endregion
+//#region src/harness/container/agents.d.ts
+/**
+ * Where a CLI's model requests go, and the credentials they carry. Added
+ * outside the container, by `ContainerEgress`.
+ *
+ * - Straight to the provider: `{ apiKey }`.
+ * - AI Gateway with Unified Billing: `{ baseUrl: `${gateway}/anthropic`,
+ *   apiKey: gatewayToken }`; the gateway takes its token as the key.
+ * - AI Gateway with BYOK: `{ baseUrl, headers: { "cf-aig-authorization":
+ *   `Bearer ${gatewayToken}` } }`; the gateway holds the provider key.
+ */
+type ProviderConnection = {
+  /** Sent the way the provider expects: `x-api-key`, or `Authorization: Bearer`. */ readonly apiKey?: string;
+  /**
+   * The provider's base URL, as its SDK names it (`ANTHROPIC_BASE_URL`,
+   * `OPENAI_BASE_URL`). Default: the provider's own API.
+   */
+  readonly baseUrl?: string /** More headers on every model request, such as gateway metadata. */;
+  readonly headers?: {
+    readonly [name: string]: string;
+  };
+};
+/** How the container is built. */
+type ContainerImage =
+  /**
+   * `cloudflare/debian-trixie`, set up at runtime by the harness: the
+   * steps run once and the result is snapshotted. The harness installs the
+   * daemon.
+   */
+  | {
+      readonly kind: "managed";
+      readonly setup: readonly SetupStep[];
+    } /** An image you built, whose entrypoint runs the daemon itself. */
+  | {
+      readonly kind: "custom";
+      readonly image: string;
+    };
+/** What runs in the container. Build one with a preset. */
+type ContainerAgent = {
+  /** The daemon adapter: `claude-code`, `codex`, `echo`, or your own. */ readonly adapter: string;
+  readonly image: ContainerImage /** Environment for the daemon and the CLI. Never put secrets here. */;
+  readonly env: {
+    readonly [name: string]: string;
+  } /** Hosts the harness intercepts to add credentials. */;
+  readonly egress: readonly EgressRoute[] /** The model and adapter options new sessions start with. */;
+  readonly model?: string;
+  readonly options?: JsonValue;
+};
+/** `claudeCode()`'s options: its provider connection and settings. */
+type ClaudeCodeAgentOptions = ProviderConnection & {
+  /** Default `claude-sonnet-4-5`. Change one session's with `setModel`. */ readonly model?: string /** The `@anthropic-ai/claude-code` version. Default `2.1.289`. */;
+  readonly version?: string;
+  readonly appendSystemPrompt?: string;
+  readonly allowedTools?: readonly string[];
+  readonly disallowedTools?: readonly string[];
+  readonly maxTurns?: number;
+  /**
+   * More setup steps, run after the install and kept in the snapshot. Use
+   * `user: "agent"` to install plugins, mods or settings in the agent's
+   * home, which every session home starts from.
+   */
+  readonly setup?: readonly SetupStep[];
+};
+/**
+ * Claude Code, installed at runtime on `cloudflare/debian-trixie`.
+ *
+ * @param options - Its provider connection (`apiKey`, `baseUrl`,
+ *   `headers`) and settings.
+ * @returns The agent, for `ContainerHarness`'s `agent`.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare function claudeCode(options: ClaudeCodeAgentOptions): ContainerAgent;
+/** `codex()`'s options: its provider connection and settings. */
+type CodexAgentOptions = ProviderConnection & {
+  /** Default `gpt-5.1`. Change one session's with `setModel`. */ readonly model?: string /** The `@openai/codex` version. Default `0.157.0`. */;
+  readonly version?: string /** Extra `-c key=value` config overrides. */;
+  readonly config?: readonly string[];
+  /**
+   * More setup steps, run after the install and kept in the snapshot. Use
+   * `user: "agent"` to install plugins, mods or settings in the agent's
+   * home, which every session home starts from.
+   */
+  readonly setup?: readonly SetupStep[];
+};
+/**
+ * Codex, installed at runtime on `cloudflare/debian-trixie`.
+ *
+ * @param options - Its provider connection (`apiKey`, `baseUrl`,
+ *   `headers`) and settings.
+ * @returns The agent, for `ContainerHarness`'s `agent`.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare function codex(options: CodexAgentOptions): ContainerAgent;
+/** `containerAgent()`'s options. */
+type CustomAgentOptions = {
+  /** Your image, such as `ctx.container.images.agent`. Its entrypoint runs the daemon. */ readonly image: string /** The adapter its daemon runs. */;
+  readonly adapter: string;
+  readonly env?: {
+    readonly [name: string]: string;
+  };
+  readonly egress?: readonly EgressRoute[];
+  readonly model?: string;
+  readonly options?: JsonValue;
+};
+/**
+ * An agent in an image you built, whose entrypoint serves the daemon
+ * (`serveFromEnv` from `agents/harness/container/runtime`).
+ *
+ * @param options - The image, the adapter, and its environment.
+ * @returns The agent, for `ContainerHarness`'s `agent`.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare function containerAgent(options: CustomAgentOptions): ContainerAgent;
+/**
+ * The echo adapter on `cloudflare/debian-trixie`: no CLI, no model, no
+ * credentials. For smoke tests of the whole path.
+ *
+ * @returns The agent, for `ContainerHarness`'s `agent`.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare function echoAgent(): ContainerAgent;
+//#endregion
+//#region src/harness/container/types.d.ts
+/**
+ * `ContainerHarness`'s own types: how the harness addresses sessions and
+ * reports operations. They mirror `agents/harness/pi` one for one, so code
+ * written against one harness reads the same against the other. Transcript
+ * messages and events are the wire's types (`ContainerMessage`,
+ * `ContainerEvent`), the one format every container adapter produces.
+ */
+/** A session, addressed by its id. The root is `"root"`. */
+type ContainerSessionId = string;
+/** Options for submitting a prompt. */
+type ContainerSubmitOptions = {
+  /** Default: the root session. */ readonly session?: ContainerSessionId /** Idempotency key. Submitting the same id twice returns the same receipt. */;
+  readonly operationId?: string;
+  /**
+   * What the submission does when the session is already running.
+   *
+   * - `followUp` (default): answered after the current run, as its own run.
+   * - `steer`: joins the running turn, when the adapter can steer;
+   *   otherwise it is queued as a follow-up.
+   */
+  readonly whenBusy?: ContainerWhenBusy;
+};
+/** Addresses one session. */
+type ContainerSessionOptions = {
+  /** Default: the root session. */ readonly session?: ContainerSessionId;
+};
+/** Returned once a submission is durable. It says nothing about the model yet. */
+type ContainerReceipt = {
+  readonly operationId: string;
+  readonly session: ContainerSessionId /** False when this operation id was already submitted. */;
+  readonly accepted: boolean;
+};
+/** How one operation ended. */
+type ContainerOperationResult = {
+  readonly operationId: string;
+  readonly session: ContainerSessionId /** `done`: answered. `unanswered`: failed, aborted, or lost with its container. */;
+  readonly status: "done" | "unanswered";
+  /**
+   * Why an unanswered operation ended: the adapter's reason, `aborted`,
+   * `container_lost` (its container stopped mid-run), `not_found`, or
+   * `container_unavailable` (no container could be started).
+   */
+  readonly reason?: string /** The final assistant text, when answered. */;
+  readonly text?: string;
+};
+/** What `prompt()` returns: the result and the transcript after it. */
+type ContainerPromptResponse = ContainerOperationResult & {
+  /** The session's active transcript after the operation. */ readonly messages: readonly ContainerMessage[];
+};
+/** A submission that has not settled yet. */
+type ContainerPendingOperation = {
+  readonly operationId: string;
+  readonly session: ContainerSessionId /** `queued`, or `running` in the container. */;
+  readonly status: "queued" | "running";
+};
+/** One session, as `sessions.list()` reports it. */
+type ContainerSessionInfo = {
+  readonly id: ContainerSessionId /** The session this one was forked from. */;
+  readonly parent?: ContainerSessionId;
+  readonly busy: boolean;
+};
+/** Where the container is, as the harness sees it. */
+type ContainerStatus =
+  | "starting"
+  | "ready" /** The container stopped while it had work; that work is reconciled. */
+  | "lost" /** The container was stopped after it went idle. */
+  | "stopped";
+/** One event on a session's stream. */
+type ContainerSessionEvent =
+  /** What the adapter reported, tagged with its operation. */ | (ContainerEvent & {
+        readonly operationId: string | null;
+      })
+    | {
+        readonly type: "operation-start";
+        readonly operationId: string;
+      }
+    | {
+        readonly type: "operation-end";
+        readonly result: ContainerOperationResult;
+      }
+    | {
+        readonly type: "container";
+        readonly status: ContainerStatus;
+      };
+/** The state of a session when a stream starts. */
+type ContainerSessionSnapshot = {
+  readonly session: ContainerSessionId;
+  readonly messages: readonly ContainerMessage[];
+  readonly pending: readonly ContainerPendingOperation[];
+  readonly busy: boolean;
+};
+/**
+ * A session's events: the snapshot taken when the stream was opened, then
+ * every event after it, in batches, including any that arrived before
+ * `start()`. An event may repeat what the snapshot already shows; messages
+ * are keyed by id. Live: events reach listeners in the isolate that runs
+ * the harness. Call `stop()` when done, started or not.
+ */
+type ContainerEventStream = {
+  readonly snapshot: ContainerSessionSnapshot /** Start delivering events. Call once. */;
+  start(
+    listener: (events: readonly ContainerSessionEvent[]) => void
+  ): void /** Stop delivering events. */;
+  stop(): Promise<void>;
+};
+//#endregion
+//#region src/harness/container/harness.d.ts
+/** The root session's id. */
+declare const ROOT_SESSION: ContainerSessionId;
+/** A container instance size: a named type or a custom shape. */
+type ContainerInstance =
+  | "lite"
+  | "standard-1"
+  | "standard-2"
+  | "standard-3"
+  | "standard-4"
+  | {
+      readonly vcpu: number;
+      readonly memoryMib: number;
+      readonly diskMb: number;
+    };
+/** Applied to a session the first time it is created. */
+type ContainerSessionDefaults = {
+  /** The adapter's model name. Change one session's with `session.setModel`. */ readonly model?: string /** Adapter options, passed through to the adapter untouched. */;
+  readonly options?: JsonValue$1;
+};
+/** `ContainerHarness`'s options. */
+type ContainerHarnessOptions = {
+  /** The object's container: `ctx.container`. */ readonly container: Container /** What runs in it: `claudeCode()`, `codex()`, or `containerAgent()`. */;
+  readonly agent: ContainerAgent;
+  /**
+   * `ctx.exports.ContainerEgress`, which adds the agent's credentials to
+   * its requests outside the container. Required when the agent has egress
+   * routes (every preset does). Export `ContainerEgress` from
+   * your Worker's main module.
+   */
+  readonly egress?: ContainerEgressBinding /** Instance size. Default `standard-1`. */;
+  readonly instance?: ContainerInstance;
+  /**
+   * Whether the container may reach the Internet beyond its egress routes.
+   * Default true: managed images need it to install their CLI in setup.
+   * Commands the agent runs can then reach any host (credentials still
+   * stay outside: only the egress routes carry them). Set false, with a
+   * `containerAgent()` image that has its CLI installed, to allow nothing
+   * but the egress routes.
+   */
+  readonly enableInternet?: boolean /** Where the daemon listens. Default 8080. */;
+  readonly port?: number;
+  /**
+   * How long the container keeps running after its last work, in
+   * milliseconds. The harness then snapshots its filesystem (workspace
+   * included) and stops it; the next prompt starts a new one from that
+   * snapshot and resumes the session in it. Default five minutes; at most
+   * six hours less two minutes (the platform's own stop comes two minutes
+   * later, and the harness must snapshot first).
+   */
+  readonly idleTimeoutMs?: number /** How long a new container may take to answer. Default 60 seconds. */;
+  readonly startTimeoutMs?: number /** What a new session starts with. Default: the agent's model and options. */;
+  readonly defaults?: ContainerSessionDefaults;
+  /**
+   * What happens to an operation whose container stopped while it ran.
+   *
+   * - `fail` (default): it settles `unanswered` with `container_lost`. The
+   *   session itself survives: the next prompt resumes it in a new
+   *   container, from everything the adapter persisted.
+   * - `retry`: it runs again from the start in the new container. Only safe
+   *   when the agent's tools can be repeated.
+   */
+  readonly onContainerLost?:
+    | "fail"
+    | "retry" /** Table prefix for the session store. Default `container_`. */;
+  readonly storePrefix?: string;
+};
+/**
+ * An agent CLI running in a Cloudflare Container, driven from a Durable
+ * Object, behind the same interface as `PiHarness`: `harness.prompt()`,
+ * `harness.sessions`, `harness.session(id)`.
+ *
+ * The harness does not know which agent runs in the container. A preset
+ * (`claudeCode()`, `codex()`) says what to install and which adapter the
+ * daemon runs; the harness builds the container from
+ * `cloudflare/debian-trixie` on first use, installs the bundled daemon, and
+ * snapshots the result, so there is no image to build. Credentials stay
+ * outside: the CLI calls a placeholder host, and `ContainerEgress` adds the
+ * real key. Any adapter that produces `ContainerEvent`s works, including
+ * one in an image of your own (`containerAgent()`).
+ *
+ * The object owns the durable record, in a `HarnessStore`: sessions,
+ * operations, the transcript, and the adapter's resume state. The container
+ * is disposable. It is started on demand with `ctx.container.start()`, kept
+ * for `idleTimeoutMs` after its last work, and then stopped. The next
+ * prompt starts a new container and hands the adapter everything it
+ * persisted, so the agent resumes its own session there.
+ *
+ * Each session has one Lifecycle wake job. It runs while the session has
+ * open operations: it starts or reattaches to the container, reconciles
+ * what the container knows with what the object stored, delivers queued
+ * operations, and waits for them, rescheduling itself as a heartbeat. An
+ * eviction mid-run leaves the job due, so its alarm restarts the object,
+ * which reattaches and replays the frames it missed from its cursor.
+ *
+ * Recovery, by what was lost:
+ *
+ * - **The object** (eviction, deploy): the container keeps running for
+ *   `idleTimeoutMs`. The wake reattaches and replays from the cursor.
+ * - **The socket**: the same, on the next heartbeat.
+ * - **The container** (idle stop, crash, platform restart): a new one
+ *   answers with a different runtime id. The session is reopened in it
+ *   from the persisted resume state; queued operations run there; an
+ *   operation that was running is settled `container_lost` or run again,
+ *   per `onContainerLost`.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare class ContainerHarness extends LifecycleCapability {
+  #private;
+  /** Every session in this object. */
+  readonly sessions: ContainerSessions;
+  /**
+   * @param options - The container, the agent, and session defaults.
+   */
+  constructor(options: ContainerHarnessOptions);
+  /** Reopen the store, re-arm the container's idle timeout, and wake open sessions. */
+  onStart(_context: CapabilityStartContext): Promise<void>;
+  /** Dispatch the harness's jobs: one wake per session, and the idle stop. */
+  onJob(context: LifecycleJobContext): Promise<LifecycleJobOutcome | void>;
+  /** Close the session sockets. Durable state and the container are untouched. */
+  dispose(): Promise<void>;
+  /**
+   * A handle on one session. No I/O until you call it.
+   *
+   * @param id - The session. Default: the root session.
+   * @returns The handle.
+   */
+  session(id?: ContainerSessionId): ContainerSession;
+  /**
+   * Submit a prompt and wait for its answer.
+   *
+   * @param input - The prompt.
+   * @param options - Session, idempotency key, and busy behaviour.
+   * @returns The result, with the session's transcript after it.
+   */
+  prompt(
+    input: ContainerInput,
+    options?: ContainerSubmitOptions
+  ): Promise<ContainerPromptResponse>;
+  /**
+   * Durably submit a prompt. Resolves before the agent runs.
+   *
+   * @param input - The prompt.
+   * @param options - Session, idempotency key, and busy behaviour.
+   * @returns The receipt.
+   */
+  submit(
+    input: ContainerInput,
+    options?: ContainerSubmitOptions
+  ): Promise<ContainerReceipt>;
+  /**
+   * Stop one operation, or everything running in a session.
+   *
+   * @param options - The session, and optionally one operation.
+   * @returns Whether anything was stopped.
+   */
+  abort(
+    options?: ContainerSessionOptions & {
+      readonly operationId?: string;
+    }
+  ): Promise<boolean>;
+  /**
+   * Wait for an operation to settle.
+   *
+   * @param operationId - The operation.
+   * @param options - The session, and a signal that stops only the wait.
+   * @returns How it ended.
+   */
+  wait(
+    operationId: string,
+    options?: ContainerSessionOptions & {
+      readonly signal?: AbortSignal;
+    }
+  ): Promise<ContainerOperationResult>;
+  /**
+   * The session's active transcript.
+   *
+   * @param options - The session.
+   * @returns Its messages since the newest reset.
+   */
+  messages(options?: ContainerSessionOptions): Promise<ContainerMessage[]>;
+  /**
+   * Submissions that have not settled yet, oldest first.
+   *
+   * @param options - Narrow to one session. Default: every session.
+   * @returns The open operations.
+   */
+  pending(
+    options?: ContainerSessionOptions
+  ): Promise<ContainerPendingOperation[]>;
+  /**
+   * The container, as the harness sees it.
+   *
+   * @returns Whether it runs, and the id the harness started it with.
+   */
+  container(): Promise<{
+    readonly running: boolean;
+    readonly runtimeId: string | undefined;
+  }>;
+  /**
+   * Stop the container now. Sessions survive: the next prompt starts a new
+   * container and resumes them in it. Running operations are reconciled as
+   * if the container had died.
+   */
+  stop(): Promise<void>;
+  /** @internal */
+  store(): Promise<HarnessStore>;
+  /** @internal Create a session with the defaults, or fork one. */
+  createSession(
+    id: ContainerSessionId,
+    from?: ContainerSessionId
+  ): Promise<void>;
+  /** @internal */
+  enqueue(
+    session: ContainerSessionId,
+    input: ContainerInput,
+    options: ContainerSubmitOptions
+  ): Promise<ContainerReceipt>;
+  /** @internal Withdraw or abort one operation, or all of a session's. */
+  withdraw(
+    session: ContainerSessionId,
+    operationId: string | undefined
+  ): Promise<boolean>;
+  /** @internal Wait for an operation to settle. */
+  settled(
+    session: ContainerSessionId,
+    operationId: string,
+    signal?: AbortSignal
+  ): Promise<ContainerOperationResult>;
+  /** @internal The active transcript. */
+  transcript(session: ContainerSessionId): Promise<ContainerMessage[]>;
+  /** @internal */
+  busy(session: ContainerSessionId): Promise<boolean>;
+  /** @internal Start a new context: a new agent session, without history. */
+  resetSession(
+    session: ContainerSessionId,
+    handoff: string | undefined
+  ): Promise<void>;
+  /** @internal */
+  setModel(session: ContainerSessionId, model: string): Promise<void>;
+  /** @internal */
+  events(session: ContainerSessionId): Promise<ContainerEventStream>;
+}
+/**
+ * One session, addressed through the harness.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare class ContainerSession {
+  #private;
+  /** The session id. */
+  readonly id: ContainerSessionId;
+  /**
+   * @param harness - The harness.
+   * @param id - The session id.
+   */
+  constructor(harness: ContainerHarness, id: ContainerSessionId);
+  /**
+   * Durably submit a prompt. Resolves before the agent runs.
+   *
+   * @param input - The prompt.
+   * @param options - Idempotency key and busy behaviour.
+   * @returns The receipt.
+   */
+  submit(
+    input: ContainerInput,
+    options?: ContainerSubmitOptions
+  ): Promise<ContainerReceipt>;
+  /**
+   * Submit and wait for the answer and the updated transcript.
+   *
+   * @param input - The prompt.
+   * @param options - Idempotency key and busy behaviour.
+   * @returns The result, with the transcript after it.
+   */
+  prompt(
+    input: ContainerInput,
+    options?: ContainerSubmitOptions
+  ): Promise<ContainerPromptResponse>;
+  /**
+   * Join the running turn, when the adapter can steer; otherwise queue.
+   *
+   * @param input - The prompt.
+   * @param options - Idempotency key.
+   * @returns The receipt.
+   */
+  steer(
+    input: ContainerInput,
+    options?: Omit<ContainerSubmitOptions, "whenBusy">
+  ): Promise<ContainerReceipt>;
+  /**
+   * Wait for an operation to settle. Aborting `signal` stops only the wait.
+   *
+   * @param operationId - The operation.
+   * @param signal - Stops the wait.
+   * @returns How it ended.
+   */
+  wait(
+    operationId: string,
+    signal?: AbortSignal
+  ): Promise<ContainerOperationResult>;
+  /**
+   * Withdraw or abort one operation, or, with no id, every open operation
+   * of the session. Aborted operations settle `unanswered` with `aborted`.
+   *
+   * @param operationId - The operation. Default: all of them.
+   * @returns Whether anything was open to abort (always true with no id).
+   */
+  abort(operationId?: string): Promise<boolean>;
+  /**
+   * Start a new context: a new agent session without the old history,
+   * optionally seeded with a handoff note prepended to the next prompt.
+   * Throws while the session is busy.
+   *
+   * @param handoff - The note.
+   */
+  reset(handoff?: string): Promise<void>;
+  /**
+   * Change this session's model, by the adapter's model name.
+   *
+   * @param model - The model.
+   */
+  setModel(model: string): Promise<void>;
+  /**
+   * The active transcript, since the newest reset.
+   *
+   * @returns The messages, oldest first.
+   */
+  messages(): Promise<ContainerMessage[]>;
+  /**
+   * This session's events: a snapshot, then live batches.
+   *
+   * @returns The stream.
+   */
+  events(): Promise<ContainerEventStream>;
+  /**
+   * Whether the session has open operations.
+   *
+   * @returns True while anything is queued or running.
+   */
+  busy(): Promise<boolean>;
+}
+/**
+ * Every session in this object.
+ *
+ * @experimental The API may change before it stabilizes.
+ */
+declare class ContainerSessions {
+  #private;
+  /**
+   * @param harness - The harness.
+   */
+  constructor(harness: ContainerHarness);
+  /**
+   * A handle on one session.
+   *
+   * @param id - The session id.
+   * @returns The handle.
+   */
+  get(id: ContainerSessionId): ContainerSession;
+  /**
+   * A new top-level session, with the harness's defaults.
+   *
+   * @returns The new session.
+   */
+  create(): Promise<ContainerSession>;
+  /**
+   * A new session that continues `from`'s history as a branch.
+   *
+   * @param from - The session to fork.
+   * @returns The new session.
+   */
+  fork(from: ContainerSessionId): Promise<ContainerSession>;
+  /**
+   * Every session, oldest first.
+   *
+   * @returns Each session's id, parent, and whether it is busy.
+   */
+  list(): Promise<ContainerSessionInfo[]>;
+}
+//#endregion
+export {
+  type ClaudeCodeAgentOptions,
+  type CodexAgentOptions,
+  type ContainerAgent,
+  ContainerEgress,
+  type ContainerEgressBinding,
+  type ContainerEgressProps,
+  type ContainerEvent,
+  type ContainerEventStream,
+  ContainerHarness,
+  type ContainerHarnessOptions,
+  type ContainerImage,
+  type ContainerInput,
+  type ContainerInputPart,
+  type ContainerInstance,
+  type ContainerMessage,
+  type ContainerOperationResult,
+  type ContainerPart,
+  type ContainerPendingOperation,
+  type ContainerPromptResponse,
+  type ContainerReceipt,
+  ContainerSession,
+  type ContainerSessionDefaults,
+  type ContainerSessionEvent,
+  type ContainerSessionId,
+  type ContainerSessionInfo,
+  type ContainerSessionOptions,
+  type ContainerSessionSnapshot,
+  ContainerSessions,
+  type ContainerSettings,
+  type ContainerStatus,
+  type ContainerSubmitOptions,
+  type ContainerWhenBusy,
+  type CustomAgentOptions,
+  type EgressRoute,
+  type JsonValue,
+  type ProviderConnection,
+  ROOT_SESSION,
+  type SetupStep,
+  claudeCode,
+  codex,
+  containerAgent,
+  echoAgent
+};
+//# sourceMappingURL=index.d.ts.map