@evolvingmachines/sdk 0.0.51 → 0.0.52-launch-round-1.20260803.37a56fe

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 import { EventEmitter } from 'events';
 import * as zod from 'zod';
-import { z } from 'zod';
+import { ZodType, z } from 'zod';
 export { E2BConfig, E2BProvider, createE2BProvider } from '@evolvingmachines/e2b';
 export { DaytonaConfig, DaytonaProvider, createDaytonaProvider } from '@evolvingmachines/daytona';
 export { ModalConfig, ModalProvider, createModalProvider } from '@evolvingmachines/modal';
+import { H as HostedClientConfig, A as AgentsClient, a as AuthClient, D as DatasetsClient, J as JobsClient, T as TrialsClient, C as CapabilityDocument, b as HostedErrorCode } from './types-B6iGD_du.js';
+export { r as ActiveDataset, y as AgentArm, z as AgentArmInput, f as AgentCapability, K as AgentDatasetStats, _ as AgentInfo, aq as AgentInput, aE as AgentList, aD as AgentPage, $ as AgentResult, as as AgentSource, at as AgentSourceInput, ar as AgentUpsertInput, l as ApiKey, a3 as AttemptPhase, k as AuthStatus, g as Awaitable, ab as CompareCell, ac as CompareCoverage, aa as CompareJobAggregate, ae as CompareResponse, ad as CompareTaskRow, q as Dataset, ai as DatasetImport, an as DatasetImportFailure, h as DatasetImportList, j as DatasetImportPage, am as DatasetImportStatus, aC as DatasetList, aB as DatasetPage, aj as DatasetPatch, u as DatasetRef, v as DatasetSelector, al as DatasetSource, s as DatasetVersion, t as DatasetVersionState, aP as DownloadDatasetOptions, aO as DownloadJobOptions, E as EVAL_SANDBOX_PROVIDERS, ap as EvalAgent, Z as EvalModelInfo, O as EvalSandboxProvider, a2 as EvalStepResult, a1 as ExceptionInfo, aK as GetDatasetOptions, c as HOSTED_ERROR_CODES, ao as ImportWarning, F as Job, B as JobCreate, a7 as JobEvent, G as JobFailure, ay as JobList, ax as JobPage, I as JobStats, N as JobStatus, m as JobTaskRollup, o as JobTaskRollupList, n as JobTaskRollupPage, a8 as JobWatch, aJ as ListAgentsOptions, aI as ListDatasetsOptions, L as ListImportsOptions, p as ListJobTasksOptions, aG as ListJobsOptions, aH as ListTrialsOptions, M as ManagedProviderCapability, av as Page, aw as PageOptions, P as ProviderCapability, ak as PublishDatasetInput, ah as RegradeRequest, ag as ResumeRequest, af as SourceJob, au as SpendSource, aF as StartJobOptions, S as StatusVocabulary, a4 as StopResponse, d as TRIAL_ARTIFACT_STREAMS, e as TRIAL_STATUSES, w as Task, x as TaskProviderVerdict, Y as TimingInfo, a5 as TraceEvent, a6 as TraceEventPage, aL as TraceOptions, Q as Trial, R as TrialArtifactStream, W as TrialCounts, aA as TrialList, az as TrialPage, V as TrialStatus, X as TrialStatusTally, U as UpstreamStatus, a9 as VerifierEnvironmentMode, a0 as VerifierResult, aN as WatchImportOptions, aM as WatchJobOptions, i as isHostedErrorCode } from './types-B6iGD_du.js';
 
 /**
  * ACP-inspired output types for unified agent event streaming.
@@ -141,7 +143,40 @@ interface PlanEntry {
  * All possible session update types.
  * Discriminated union on `sessionUpdate` field.
  */
-type SessionUpdate = AgentMessageChunk | AgentThoughtChunk | UserMessageChunk | ToolCall | ToolCallUpdate | Plan;
+type SessionUpdate = AgentMessageChunk | AgentThoughtChunk | UserMessageChunk | ToolCall | ToolCallUpdate | Plan | AgentError;
+/**
+ * A failure the HARNESS itself reported — not model output, not work.
+ *
+ * WHY THIS IS ITS OWN VARIANT AND NOT AN agent_message_chunk. Harnesses stream
+ * their failures on the same channel as their output: codex writes
+ * {"type":"error"} and {"type":"turn.failed"} to stdout as JSONL while its
+ * stderr says only "Reading prompt from stdin...". Dropping those left a run
+ * that could not reach the model looking identical to a run that produced
+ * nothing at all, which cost a full night of blind diagnosis. Folding them into
+ * agent_message_chunk would be worse than dropping them: a consumer counting
+ * "did the agent do any work" would count the error as work.
+ *
+ * So the transcript records the failure, and the discriminant says plainly that
+ * it is a failure. Anything deciding whether a harness RAN must exclude this
+ * variant — see isAgentWorkUpdate() below, and the eval runner's
+ * harnessNeverRan law, which must keep firing for an error-only run so an
+ * infrastructure failure is never scored as a zero.
+ */
+interface AgentError {
+    sessionUpdate: "error";
+    /** The harness's own message, verbatim. */
+    message: string;
+    /** True when the harness treated it as terminal for the turn. */
+    fatal: boolean;
+}
+/**
+ * Is this update evidence the harness did WORK, as opposed to reporting a
+ * failure? The one predicate every "did it run" check should use, so the answer
+ * cannot drift between callers.
+ */
+declare function isAgentWorkUpdate(update: {
+    sessionUpdate?: unknown;
+} | null | undefined): boolean;
 /**
  * Streaming text/image from agent.
  * May arrive in multiple chunks - concatenate text.
@@ -285,6 +320,301 @@ interface OutputEvent {
     update: SessionUpdate;
 }
 
+/**
+ * Agent Registry
+ *
+ * Single source of truth for agent-specific behavior.
+ * All differences between agents are data, not code.
+ */
+
+/**
+ * What a CLI does with a reasoning-effort input:
+ *   'level'   the value reaches the CLI as a graded level
+ *   'binary'  thinking on/off only — only BINARY_EFFORT_VALUES are honest inputs
+ *   'none'    the CLI takes no effort input at all
+ */
+type EffortSupport = "level" | "binary" | "none";
+/**
+ * The effort vocabulary a graded ('level') harness accepts, in ascending order
+ * of thinking. This is the ADVERTISED list: the ReasoningEffort union in
+ * types.ts additionally accepts the legacy spelling "no-thinking" (same
+ * behaviour as "off"), which is deliberately not advertised anywhere.
+ */
+declare const REASONING_EFFORTS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max", "thinking"];
+/**
+ * The subset a 'binary' harness can honestly represent. Four SPELLINGS, two
+ * BEHAVIOURS: 'off' and 'minimal' disable thinking, 'medium' and 'thinking'
+ * enable it (isThinkingEnabled draws the same line). The graded levels are
+ * excluded because a binary CLI cannot express a gradation — accepting 'high'
+ * would record a claim the CLI never received.
+ */
+declare const BINARY_EFFORT_VALUES: readonly ["off", "minimal", "medium", "thinking"];
+/**
+ * The effort a run takes when it names none, for harnesses that take one at
+ * all. Owned HERE because managed evals and managed agents must advertise the
+ * same defaults: the hosted-evals lane resolves an omitted effort to this value
+ * at job creation and publishes it on GET /api/meta via the generated
+ * harness-capabilities.json artifact.
+ */
+declare const DEFAULT_REASONING_EFFORT: ReasoningEffort;
+/**
+ * The effort vocabulary one harness accepts and the value an unnamed effort
+ * takes there — pure data derivation from its effortSupport. The
+ * harness-capabilities artifact generator and picker UIs share this.
+ */
+declare function harnessEffortVocabulary(support: EffortSupport): {
+    efforts: readonly ReasoningEffort[];
+    defaultEffort: ReasoningEffort | null;
+};
+/** Model configuration */
+interface ModelInfo {
+    /** Model alias (short name used with --model) */
+    alias: string;
+    /** Full model ID */
+    modelId: string;
+    /** What this model is best for */
+    description: string;
+    /** Per-model context ceiling where it differs from the harness default
+     *  (e.g. Kimi K3's 1M window vs the K2-era 262144). Consumers fall back to
+     *  the harness-level value when absent. */
+    maxContextSize?: number;
+}
+/** MCP configuration for an agent */
+interface McpConfigInfo {
+    /** Settings directory (e.g., "~/.claude") */
+    settingsDir: string;
+    /** Config filename (e.g., "settings.json" or "config.toml") */
+    filename: string;
+    /** Config format */
+    format: "json" | "toml";
+    /** Whether to use workingDir for project-level config (Claude only) */
+    projectConfig?: boolean;
+}
+/** Options for building agent commands */
+interface BuildCommandOptions {
+    prompt: string;
+    model: string;
+    isResume: boolean;
+    sessionId?: string;
+    reasoningEffort?: string;
+    isDirectMode?: boolean;
+    /**
+     * External gateway mode (caller-minted credential + base URL). Direct-mode
+     * env injection applies, but CLIs that route via generated config (OpenCode
+     * inline config, Droid settings file) must use their GATEWAY command shape
+     * pointed at the caller's gateway — with the model passed VERBATIM (route
+     * names belong to the caller's gateway, never to Evolve's alias maps).
+     */
+    isExternalGateway?: boolean;
+    /** Skills enabled for this run */
+    skills?: string[];
+    /** Sandbox home directory (default: "/home/user") */
+    homeDir?: string;
+}
+interface AgentRegistryEntry {
+    /** Sandbox image/template identifier (provider maps to its own concept) */
+    image: string;
+    /**
+     * What this CLI does with a reasoning-effort input (see EffortSupport).
+     * Advertised DATA beside the buildCommand BEHAVIOUR: the generated
+     * harness-capabilities.json artifact reads this so the hosted-evals lane
+     * advertises exactly the vocabulary the local SDK drives.
+     */
+    effortSupport: EffortSupport;
+    /** Environment variable name for API key */
+    apiKeyEnv: string;
+    /** Environment variable name for OAuth (file path or token depending on agent) */
+    oauthEnv?: string;
+    /** OAuth credentials filename (e.g., "auth.json" for Codex, "oauth_creds.json" for Gemini) */
+    oauthFileName?: string;
+    /** Environment variable to set when OAuth is active (e.g., GOOGLE_GENAI_USE_GCA=true for Gemini) */
+    oauthActivationEnv?: {
+        key: string;
+        value: string;
+    };
+    /** Environment variable name for base URL, if this CLI supports one */
+    baseUrlEnv?: string;
+    /** Default model alias */
+    defaultModel: string;
+    /**
+     * Reasoning effort Evolve pins when the caller omits `reasoningEffort`.
+     *
+     * Every run stamps this value explicitly on the wire (flag/env/config file)
+     * instead of relying on the vendor's silent default — managed-evals
+     * reproducibility requires the effort a run used to be recorded, not implied
+     * by whatever the CLI happened to default to that week. Where the vendor
+     * documents a default, the pin matches it; where none is documented, the pin
+     * is Evolve's choice (noted per entry). Absent only for harnesses with no
+     * effort control (Gemini).
+     */
+    defaultReasoningEffort?: ReasoningEffort;
+    /** Available models for this agent */
+    models: ModelInfo[];
+    /** System prompt filename (e.g., "CLAUDE.md") */
+    systemPromptFile: string;
+    /** MCP configuration */
+    mcpConfig: McpConfigInfo;
+    /** Build the CLI command for this agent */
+    buildCommand: (opts: BuildCommandOptions) => string;
+    /** Extra setup step (e.g., codex login) */
+    setupCommand?: string;
+    /** Gateway path prefix for CLIs that use a provider-native passthrough endpoint */
+    gatewayPath?: string;
+    /** Default base URL for direct mode (only needed if provider requires specific endpoint, e.g., Qwen → Dashscope) */
+    defaultBaseUrl?: string;
+    /** Available beta headers for this agent (for reference) */
+    availableBetas?: Record<string, string>;
+    /** Skills configuration for this agent */
+    skillsConfig: SkillsConfig;
+    /** Multi-provider env mapping: model prefix → keyEnv (for CLIs like OpenCode that resolve provider from model string) */
+    providerEnvMap?: Record<string, {
+        keyEnv: string;
+    }>;
+    /** Env var for inline config (e.g., OPENCODE_CONFIG_CONTENT) — used in gateway mode to set provider base URLs */
+    gatewayConfigEnv?: string;
+    /** Gateway-only model aliases for CLIs whose native model IDs differ from the Evolve gateway's route names */
+    gatewayModelAliases?: Record<string, string>;
+    /** Direct-mode model aliases for CLIs whose public model names differ from CLI-native model IDs */
+    directModelAliases?: Record<string, string>;
+    /** Do not set provider API key env in gateway mode (used when routing via generated settings instead) */
+    skipApiKeyEnvInGateway?: boolean;
+    /** Dedicated Droid settings file for Evolve gateway custom model routing */
+    droidGatewaySettings?: {
+        settingsPath: string;
+        displayName: string;
+        provider: "generic-chat-completion-api" | "openai" | "anthropic";
+        maxOutputTokens?: number;
+    };
+    /** Environment variable that CLI reads for custom outbound HTTP headers */
+    customHeadersEnv?: string;
+    /** Format for custom headers env var: "newline" (Claude) or "comma" (Gemini). Default: "newline" */
+    customHeadersFormat?: "newline" | "comma";
+    /**
+     * Per-env-var spend tracking for CLIs that support env_http_headers in config
+     * (e.g., Codex TOML). Maps Evolve gateway header names to env var names that the CLI
+     * reads at request time. Alternative to customHeadersEnv for agents without a
+     * single custom-headers env var.
+     */
+    spendTrackingEnvs?: {
+        /** Env var name for x-litellm-customer-id value */
+        sessionTagEnv: string;
+        /** Env var name for x-litellm-tags value */
+        runTagEnv: string;
+    };
+    /**
+     * Config-file-based spend tracking for CLIs that read custom headers from a
+     * JSON settings file (e.g., Qwen settings.json → model.generationConfig.customHeaders).
+     * The SDK writes headers to this file before each run.
+     * Source-verified: Qwen reads customHeaders from settings.json, not env vars.
+     */
+    spendTrackingJsonConfig?: {
+        /** JSON path to the customHeaders object (dot-separated) */
+        headersPath: string;
+    };
+    /**
+     * TOML provider-based spend tracking for CLIs that read custom_headers from a
+     * provider entry in config.toml (e.g., Kimi Code).
+     * The SDK writes a provider+model entry with custom_headers before each run.
+     * Source-verified: Kimi Code reads custom_headers from
+     * providers[name].custom_headers in ~/.kimi-code/config.toml.
+     */
+    spendTrackingTomlProvider?: {
+        /** Config file path (e.g., "~/.kimi-code/config.toml") */
+        configPath: string;
+        /** Provider name in config (e.g., "evolve-gateway") */
+        providerName: string;
+        /** Model entry name (e.g., "evolve-default") */
+        modelName: string;
+        /** Max context size for the model entry */
+        maxContextSize: number;
+    };
+    /** Additional directories to include in checkpoint tar (beyond mcpConfig.settingsDir).
+     *  Used for agents like OpenCode that spread state across XDG directories. */
+    checkpointDirs?: string[];
+    /** Additional relative paths to exclude from checkpoint tar. */
+    checkpointExcludes?: string[];
+}
+/**
+ * Registry of all supported agents.
+ *
+ * Each agent defines a buildCommand function that constructs the CLI command.
+ * This is type-safe and handles conditional logic cleanly.
+ */
+declare const AGENT_REGISTRY: Record<AgentType, AgentRegistryEntry>;
+/**
+ * Get registry entry for an agent type
+ */
+declare function getAgentConfig(agentType: AgentType): AgentRegistryEntry;
+/**
+ * Check if an agent type is valid
+ */
+declare function isValidAgentType(type: string): type is AgentType;
+/**
+ * Expand path with ~ to the sandbox home directory (default: /home/user)
+ */
+declare function expandPath(path: string, homeDir?: string): string;
+/**
+ * Get MCP settings path for an agent
+ */
+declare function getMcpSettingsPath(agentType: AgentType, homeDir?: string): string;
+/**
+ * Get MCP settings directory for an agent
+ */
+declare function getMcpSettingsDir(agentType: AgentType, homeDir?: string): string;
+
+interface ManagedSecretRef {
+    name: string;
+    as?: string;
+}
+interface ManagedSecretMetadata {
+    id: string;
+    name: string;
+    allowedHosts: string[];
+    allowedPathPrefixes: string[];
+    allowedMethods: string[];
+    createdAt: string;
+    updatedAt: string;
+    lastUsedAt: string | null;
+}
+interface ManagedSecretsClientConfig {
+    apiKey?: string;
+    dashboardUrl?: string;
+}
+interface ManagedSecretsClient {
+    list(): Promise<ManagedSecretMetadata[]>;
+}
+declare function managedSecrets(config?: ManagedSecretsClientConfig): ManagedSecretsClient;
+
+interface EvolveEvents {
+    stdout: (chunk: string) => void;
+    stderr: (chunk: string) => void;
+    content: (event: OutputEvent) => void;
+    lifecycle: (event: LifecycleEvent) => void;
+}
+interface EvolveConfig {
+    agent?: AgentConfig;
+    sandbox?: SandboxProvider;
+    sandboxCreateOptions?: SandboxCreateOptions;
+    workingDirectory?: string;
+    workspaceMode?: WorkspaceMode;
+    secrets?: Record<string, string>;
+    managedSecrets?: ManagedSecretRef[];
+    sandboxId?: string;
+    systemPrompt?: string;
+    context?: FileMap;
+    files?: FileMap;
+    mcpServers?: Record<string, McpServerConfig>;
+    browser?: BrowserConfig;
+    browserCredentials?: BrowserCredentialsConfig;
+    plugins?: AgentPluginConfig[];
+    skills?: SkillName[];
+    schema?: ZodType<unknown> | JsonSchema;
+    schemaOptions?: SchemaValidationOptions;
+    sessionTagPrefix?: string;
+    observability?: Record<string, unknown>;
+    integrations?: IntegrationsSetup;
+    storage?: StorageConfig;
+}
 /** Result of a completed sandbox command */
 interface SandboxCommandResult {
     exitCode: number;
@@ -318,6 +648,13 @@ interface SandboxRunOptions {
 interface SandboxSpawnOptions extends SandboxRunOptions {
     stdin?: boolean;
 }
+/** Provider-neutral outbound network policy applied when the sandbox boots. */
+interface SandboxNetworkPolicy {
+    /** Allow all outbound traffic, or deny it except for allowedDestinations. */
+    outbound: "open" | "blocked";
+    /** Hostnames, IP addresses, or CIDR ranges that remain reachable when blocked. */
+    allowedDestinations?: string[];
+}
 /** Options for creating a sandbox */
 interface SandboxCreateOptions {
     /** Sandbox image/template ID. Provider uses its default if not specified. */
@@ -325,7 +662,108 @@ interface SandboxCreateOptions {
     envs?: Record<string, string>;
     metadata?: Record<string, string>;
     timeoutMs?: number;
+    /**
+     * Terminate the sandbox after this long with nothing running in it. This is
+     * an INACTIVITY bound, not a lifetime: `timeoutMs` caps how long the box may
+     * live at all, this caps how long it may sit doing nothing — which is what
+     * reclaims a box whose client died between commands, long before the lifetime
+     * would.
+     *
+     * Providers must reject it if they cannot enforce it, never silently ignore
+     * it. Only modal has a true idle timer alongside an absolute lifetime; e2b has
+     * no idle concept, and daytona's only clock IS an inactivity one, which
+     * `timeoutMs` already drives there.
+     *
+     * WHAT COUNTS AS ACTIVITY IS THE PROVIDER'S DEFINITION, and it is narrower
+     * than "the client is doing something" — Modal counts a running exec, a stdin
+     * write, and an open tunnel connection, and says nothing about filesystem
+     * calls. Size this above the longest gap between commands the caller expects,
+     * not above the longest gap between API calls.
+     */
+    idleTimeoutMs?: number;
     workingDirectory?: string;
+    /**
+     * Per-sandbox compute sizing: cpu in cores, memory and disk in GiB.
+     * Providers must reject entries they cannot enforce at create time, never
+     * silently ignore them (modal sizes cpu/memory at create but cannot size
+     * disk; e2b sizes at template build only; daytona sizes at snapshot build,
+     * so an existing snapshot cannot be resized at create).
+     */
+    resources?: {
+        cpu?: number;
+        memory?: number;
+        disk?: number;
+    };
+    /** Providers must reject policies they cannot enforce; never silently ignore them. */
+    network?: SandboxNetworkPolicy;
+    /**
+     * Run all commands and file operations as this user.
+     * Providers must reject it if they cannot enforce it, never silently ignore it.
+     */
+    user?: string;
+    /**
+     * Home directory used for agent config paths inside the sandbox.
+     * Default: "/root" when user is "root", "/home/<user>" for other users,
+     * "/home/user" when no user is given.
+     */
+    homeDir?: string;
+}
+/** Options for listing sandboxes (capability: SandboxProvider.list). */
+interface SandboxListOptions {
+    /**
+     * Provider-neutral states. Providers map them onto their own vocabulary and
+     * must not invent matches for a state they do not have (Modal has no paused
+     * state, so a filter excluding "running" matches nothing there).
+     */
+    state?: ("running" | "paused")[];
+    metadata?: Record<string, string>;
+    limit?: number;
+}
+/** File or directory entry (capability: SandboxFiles.list). */
+interface FileInfo {
+    name: string;
+    path: string;
+    type: "file" | "dir";
+}
+/**
+ * A COMPLETE (or admittedly incomplete) enumeration of a provider's fleet.
+ *
+ * `complete` is the load-bearing field, not a nicety. The callers that need a
+ * whole fleet — orphan sweeps, lifecycle reconciliation — read a sandbox's
+ * ABSENCE from the list as evidence it is gone, so a truncated page and a small
+ * fleet must never be the same answer. Returning a short array with no signal
+ * makes them identical, and the caller that acts on that difference is the one
+ * deleting machines.
+ *
+ * A caller that sees `complete: false` has to leave every row alone, exactly as
+ * if it had never asked.
+ */
+interface SandboxListPage {
+    sandboxes: SandboxInfo[];
+    /**
+     * False means THIS IS NOT THE WHOLE FLEET — for any reason, including a
+     * `limit` the caller set. A caller-imposed limit that stopped the walk while
+     * more sandboxes existed is still a truncated answer, and reporting it as
+     * complete is what made this flag useless at its only real consumer: a sweep
+     * that always passes a limit could never learn it had been truncated.
+     * Complete means the provider ran out, not that we stopped asking.
+     */
+    complete: boolean;
+    /** Provider requests made. Diagnostic — a fleet that suddenly costs 40 pages. */
+    pagesFetched: number;
+    /** Why it could not be finished, when it could not. */
+    error?: string;
+}
+/** Sandbox metadata and lifecycle info (capability: SandboxProvider.list, SandboxInstance.getInfo). */
+interface SandboxInfo {
+    sandboxId: string;
+    /** The provider-neutral image/template the sandbox booted from. */
+    image: string;
+    name?: string;
+    metadata: Record<string, string>;
+    startedAt: string;
+    /** End time (undefined for running sandboxes). */
+    endAt?: string;
 }
 /** Command execution capabilities */
 interface SandboxCommands {
@@ -343,6 +781,27 @@ interface SandboxFiles {
         data: string | Buffer | ArrayBuffer | Uint8Array;
     }>): Promise<void>;
     makeDir(path: string): Promise<void>;
+    /**
+     * Upload a LOCAL file by path, without loading it into the process heap.
+     *
+     * write()/writeBatch() take the bytes as a value, so uploading a large
+     * artifact costs one full-size Buffer per concurrent upload — a caller doing
+     * many uploads at once pays that in RSS. This takes the path instead and lets
+     * the provider move the bytes its own cheapest way (a request body streamed
+     * off disk, or the vendor SDK's own path upload).
+     *
+     * OPTIONAL: a provider that has no cheaper path than "read it and send it"
+     * omits this, and uploadFileFromPath() falls back to write().
+     */
+    writeFromPath?(sandboxPath: string, localPath: string): Promise<void>;
+    /** Check whether a file or directory exists. */
+    exists?(path: string): Promise<boolean>;
+    /** List directory contents. */
+    list?(path: string): Promise<FileInfo[]>;
+    /** Delete a file or directory. */
+    remove?(path: string): Promise<void>;
+    /** Rename or move a file or directory. */
+    rename?(oldPath: string, newPath: string): Promise<void>;
 }
 /** Sandbox instance */
 interface SandboxInstance {
@@ -353,15 +812,62 @@ interface SandboxInstance {
     getHost(port: number): Promise<string>;
     kill(): Promise<void>;
     pause(): Promise<void>;
+    /** Whether the sandbox is currently running. */
+    isRunning?(): Promise<boolean>;
+    /** Sandbox metadata and timing. */
+    getInfo?(): Promise<SandboxInfo>;
 }
 /** Sandbox lifecycle management - providers implement this */
 interface SandboxProvider {
     /** Provider type identifier (e.g., "e2b") */
     readonly providerType: string;
-    /** Human-readable provider name for logging */
+    /** Human-readable provider name for logging (e.g., "E2B") */
     readonly name?: string;
     create(options: SandboxCreateOptions): Promise<SandboxInstance>;
     connect(sandboxId: string, timeoutMs?: number): Promise<SandboxInstance>;
+    /**
+     * List sandboxes, paginating to exhaustion.
+     *
+     * `limit` bounds the number of items RETURNED, so a caller that wants one
+     * cheap page still asks for one; without it the answer is the whole fleet.
+     * It used to be first-page-only regardless, which silently truncated any
+     * account past a provider's page size.
+     *
+     * Errors throw. A caller that cannot treat a failed enumeration as an
+     * exception — because it reads absence as termination — wants `listAll`.
+     *
+     * OPTIONAL: all three first-party providers implement it, but the SDK never
+     * calls it, so requiring it would break third-party providers passed to
+     * .withSandbox() for no gain. Declared here so every provider that offers it
+     * offers the SAME signature.
+     */
+    list?(options?: SandboxListOptions): Promise<SandboxInfo[]>;
+    /**
+     * The fleet-bookkeeping counterpart to `list()`: paginates to exhaustion and
+     * NEVER throws.
+     *
+     * The difference is not error style, it is what a failure MEANS to the
+     * caller. Anything that reads a sandbox's absence as "terminated" cannot
+     * distinguish a provider that answered "nothing" from one that could not
+     * finish answering — and acting on that confusion mass-kills a live fleet. So
+     * a failure comes back as `complete: false` rather than as an exception the
+     * caller might catch and treat as an empty list.
+     *
+     * REQUIRED, unlike `list`. It was optional in the first cut, and that is
+     * precisely what let one provider keep silently truncating while this
+     * interface promised exhaustive listing — a provider that cannot answer "is
+     * this the whole fleet?" cannot be used for fleet bookkeeping at all, so the
+     * type refuses to let a fourth one ship without saying so.
+     *
+     * PARTIAL RESULTS ARE RETURNED, not discarded: `complete: false` with a
+     * non-empty `sandboxes` means "at least these, and there are more". Modal's
+     * own `listSandboxIds` takes the stricter line and returns an empty set on
+     * failure, on the grounds that partial results are worse than none for a
+     * terminal-state decision. Both are safe because `complete` is what callers
+     * branch on; the divergence is deliberate and noted here so nobody "fixes"
+     * one to match the other without deciding which rule they want.
+     */
+    listAll(options?: SandboxListOptions): Promise<SandboxListPage>;
 }
 /** Supported agent types (headless CLI agents only, no ACP) */
 type AgentType = "claude" | "codex" | "gemini" | "qwen" | "kimi" | "opencode" | "droid";
@@ -376,7 +882,7 @@ declare const AGENT_TYPES: {
     readonly DROID: "droid";
 };
 /** Workspace mode determines folder structure and system prompt */
-type WorkspaceMode = "knowledge" | "swe";
+type WorkspaceMode = "knowledge" | "swe" | "task";
 /** Available skills that can be enabled */
 type SkillName = "pdf" | "dev-browser" | (string & {});
 /** Browser automation providers that can be enabled explicitly */
@@ -520,6 +1026,21 @@ interface SchemaValidationOptions {
  * Validation mode preset definitions
  */
 declare const VALIDATION_PRESETS: Record<ValidationMode, Required<Omit<SchemaValidationOptions, "mode">>>;
+/**
+ * Caller-minted gateway credential for external gateway mode.
+ *
+ * For callers that mint their own spend-capped key on an OpenAI-compatible
+ * gateway. The credential is injected like direct mode and sealCredentials()
+ * calls revoke() — sealing fails if revocation fails.
+ */
+interface ExternalGatewayConfig {
+    /** Spend-capped gateway API key minted by the caller */
+    apiKey: string;
+    /** OpenAI-compatible gateway base URL */
+    baseUrl: string;
+    /** Revoke the minted credential. Called by sealCredentials(); seal fails if this throws. */
+    revoke: () => Promise<void>;
+}
 /** Configuration passed to withAgent() */
 interface AgentConfig {
     /** Agent type (default: "claude") */
@@ -532,10 +1053,27 @@ interface AgentConfig {
     oauthToken?: string;
     /** Provider base URL for direct mode (default: provider env var or registry default) */
     providerBaseUrl?: string;
+    /**
+     * Caller-minted revocable gateway credential. Mutually exclusive with
+     * apiKey (gateway mode) and providerApiKey/providerBaseUrl (direct mode).
+     */
+    externalGateway?: ExternalGatewayConfig;
     /** Model to use (optional, uses agent's default if omitted) */
     model?: string;
     /** Reasoning effort for models that support it */
     reasoningEffort?: ReasoningEffort;
+    /**
+     * Context/completion ceiling for CLIs that must be told one (Kimi Code reads
+     * it as `max_context_size` and sends it as the request's `max_tokens`).
+     *
+     * Set it to the model's real ceiling when driving a harness against a model
+     * from another family — e.g. Kimi Code against `gpt-5.5` through an
+     * OpenAI-compatible gateway, where an oversized `max_tokens` is rejected with
+     * a 400. When set it is used verbatim. When omitted, the harness's own models
+     * keep their registry value and any other model falls back to a conservative
+     * 128000. Harnesses that never send a ceiling ignore it.
+     */
+    maxContextSize?: number;
 }
 /** Resolved agent config (output of resolution, not an extension of input) */
 interface ResolvedAgentConfig {
@@ -546,15 +1084,29 @@ interface ResolvedAgentConfig {
     isOAuth?: boolean;
     /** File content for file-based OAuth (Codex) */
     oauthFileContent?: string;
+    /** External gateway mode: caller-minted revocable credential */
+    externalGateway?: {
+        revoke: () => Promise<void>;
+    };
     model?: string;
     reasoningEffort?: ReasoningEffort;
+    /** Caller-pinned context/completion ceiling; used verbatim when present */
+    maxContextSize?: number;
 }
 /** Options for Agent constructor */
 interface AgentOptions {
     /** Sandbox provider (e.g., E2B) */
     sandboxProvider?: SandboxProvider;
+    /** Provider-neutral sandbox creation options forwarded on fresh creates. */
+    sandboxCreateOptions?: SandboxCreateOptions;
     /** Additional environment secrets */
     secrets?: Record<string, string>;
+    /** Dashboard-stored managed secrets exposed through opaque env vars. */
+    managedSecrets?: {
+        secrets: ManagedSecretRef[];
+        apiKey: string;
+        dashboardUrl?: string;
+    };
     /** Existing sandbox ID to connect to */
     sandboxId?: string;
     /** Working directory path */
@@ -706,7 +1258,7 @@ interface RunCost {
     runId: string;
     /** 1-based chronological position in session */
     index: number;
-    /** Total cost in USD (includes platform margin) */
+    /** Total cost in USD as billed to your Evolve account */
     cost: number;
     /** Token counts */
     tokens: {
@@ -986,8 +1538,6 @@ interface IntegrationAccountDeleteResult {
  *
  * Single Agent class that uses registry lookup for agent-specific behavior.
  * All agent differences are data (in registry), not code.
- *
- * Evidence: sdk-rewrite-v3.md Design Decisions section
  */
 
 /**
@@ -1002,9 +1552,10 @@ declare class Agent {
     private sandbox?;
     private hasRun;
     private readonly workingDir;
+    private readonly homeDir;
     private lastRunTimestamp?;
     private readonly registry;
-    /** Unified session ID — used for both observability (SessionLogger) and spend tracking (LiteLLM customer-id) */
+    /** Unified session ID — used for both observability (SessionLogger) and spend tracking (gateway customer-id) */
     private sessionTag;
     /** Previous session tag — preserved across kill()/setSession() so cost queries still work */
     private previousSessionTag?;
@@ -1020,6 +1571,9 @@ declare class Agent {
     private droidSessionId?;
     private managedBrowserSession?;
     private providerRuntimeToken?;
+    private managedSecretRuntimeToken?;
+    private managedSecretProxy?;
+    private credentialsSealed;
     private readonly skills?;
     private readonly storage?;
     private lastCheckpointId?;
@@ -1043,10 +1597,41 @@ declare class Agent {
      * Get or create sandbox instance
      */
     getSandbox(callbacks?: StreamCallbacks): Promise<SandboxInstance>;
+    /**
+     * The `max_context_size` Kimi Code is told, which it sends as the request's
+     * `max_tokens`. Three cases, in order:
+     *
+     *   1. `maxContextSize` on the agent config wins verbatim — the caller knows
+     *      the model's real ceiling.
+     *   2. A model the kimi registry entry itself declares keeps that model's
+     *      own ceiling when the row declares one (K3: 1048576), else the
+     *      harness default (262144).
+     *   3. Any other model — e.g. driving Kimi Code against `gpt-5.5` through an
+     *      OpenAI-compatible gateway — gets the conservative constant, because
+     *      262144 is above that model's ceiling and the gateway answers 400.
+     *
+     * Both kimi wiring paths (KIMI_MODEL_MAX_CONTEXT_SIZE and the config.toml
+     * `max_context_size`) resolve it here, so they can never disagree.
+     */
+    private resolveKimiMaxContextSize;
+    /**
+     * The effort this agent's runs stamp on the wire: the caller's
+     * reasoningEffort when given, else the harness's registry-pinned default.
+     * Every command/env/config build path reads this, so an omitted effort is
+     * an explicit stamp of the pin — never the vendor's silent default.
+     */
+    private reasoningEffort;
+    /**
+     * Kimi Code model envs for direct-style credential injection (direct mode
+     * and externalGateway mode). Kimi Code reads KIMI_MODEL_* — the registry's
+     * KIMI_API_KEY/KIMI_BASE_URL are SDK-facing inputs the CLI never reads.
+     */
+    private buildKimiDirectModelEnvs;
     /**
      * Build environment variables for sandbox
      */
     private buildEnvironmentVariables;
+    private buildSandboxCreateOptions;
     private validatedUserSecretsForEnvironment;
     private ensureManagedBrowserSession;
     private ensureProviderRuntimeToken;
@@ -1054,6 +1639,10 @@ declare class Agent {
     private setupManagedBrowser;
     private closeManagedBrowserSession;
     private closeProviderRuntimeToken;
+    private ensureManagedSecretRuntimeToken;
+    private bindManagedSecretRuntimeToken;
+    private setupManagedSecretEgress;
+    private closeManagedSecretRuntimeToken;
     /**
      * Build the inline gateway config JSON for agents using gatewayConfigEnv
      * (e.g., OpenCode OPENCODE_CONFIG_CONTENT). Centralizes the provider config
@@ -1067,9 +1656,12 @@ declare class Agent {
      */
     private buildGatewayConfigJson;
     private activeProviderRuntimeToken;
+    private requireActiveProviderRuntimeToken;
     private ensureSessionLogger;
     private flushSessionLoggerWithTimeout;
+    private requiresPreRunDashboardIngest;
     private providerRuntimeHeaderUpdates;
+    private shouldExposeProviderRuntimeTokenEnv;
     private buildProviderRuntimeProcessEnvs;
     /**
      * Build per-run env overrides for spend tracking.
@@ -1082,6 +1674,7 @@ declare class Agent {
     private captureDroidSession;
     private extractDroidSessionId;
     private findDroidSessionId;
+    private droidSessionStatePath;
     private loadDroidSessionState;
     private writeDroidSessionState;
     private resolveGatewayModel;
@@ -1090,6 +1683,7 @@ declare class Agent {
      * Agent-specific authentication setup
      */
     private setupAgentAuth;
+    private writeGeminiGatewayAuthSettings;
     private setupAgentPlugins;
     private assertProviderRuntimeDoesNotExposeGatewayKey;
     /**
@@ -1123,11 +1717,25 @@ declare class Agent {
      *
      * Streams output via callbacks, returns final response.
      */
+    /** Per-run TOML provider spend tracking (Kimi): write provider with
+     *  custom_headers before spawning. CLI reads config at startup, so each run
+     *  gets a fresh write. Extracted so the effort pin on this path is testable. */
+    private writeKimiPerRunConfig;
     run(options: RunOptions, callbacks?: StreamCallbacks): Promise<AgentResponse>;
     /**
      * Execute arbitrary command in sandbox
      */
     executeCommand(command: string, options?: ExecuteCommandOptions, callbacks?: StreamCallbacks): Promise<AgentResponse>;
+    /**
+     * Permanently revoke the model capability attached to this sandbox.
+     * This is intentionally fail-closed: configurations that may have placed
+     * other credentials in the sandbox cannot claim to be sealed.
+     */
+    sealCredentials(): Promise<void>;
+    /** Whether sealCredentials() has completed — the sandbox holds no revocable model credential. */
+    isSealed(): boolean;
+    /** Collect caller-declared files or directories after the credential boundary. */
+    collectArtifacts(paths: string[]): Promise<FileMap>;
     /**
      * Upload context files (to context/ folder)
      */
@@ -1136,6 +1744,24 @@ declare class Agent {
      * Upload files to working directory
      */
     uploadFiles(files: FileMap): Promise<void>;
+    /**
+     * Upload one LOCAL file into the sandbox by path, without holding its bytes
+     * in the process heap.
+     *
+     * uploadFiles() takes a FileMap — the bytes as a value — so a caller
+     * uploading a large artifact pays one full-size Buffer per concurrent
+     * upload. This takes the local path instead: the provider streams it off
+     * disk (or hands its own SDK the path), so peak memory is a chunk rather
+     * than the file. Use it for anything big enough that N concurrent uploads
+     * would matter; uploadFiles() stays the right call for small content.
+     *
+     * `sandboxPath` follows the uploadFiles() convention: absolute paths are
+     * used as-is, relative paths resolve under the working directory.
+     *
+     * Providers that expose no cheaper path than a plain write fall back to
+     * reading the file — correct everywhere, cheap where the provider helps.
+     */
+    uploadFileFromPath(sandboxPath: string, localPath: string): Promise<void>;
     /**
      * Get output files from output/ folder with optional schema validation
      *
@@ -1163,250 +1789,77 @@ declare class Agent {
      * Set session (sandbox ID) to connect to
      *
      * When reconnecting to an existing sandbox, we assume the agent
-     * may have already run commands, so we set hasRun=true to use
-     * the continue/resume command template instead of first-run.
-     */
-    setSession(sandboxId: string): Promise<void>;
-    /**
-     * Pause sandbox
-     */
-    pause(callbacks?: StreamCallbacks): Promise<void>;
-    /**
-     * Resume sandbox
-     */
-    resume(callbacks?: StreamCallbacks): Promise<void>;
-    /**
-     * Interrupt active command without killing the sandbox.
-     */
-    interrupt(callbacks?: StreamCallbacks): Promise<boolean>;
-    /**
-     * Get current runtime status for sandbox and agent.
-     */
-    status(): SessionStatus;
-    /**
-     * Kill sandbox (terminates all processes)
-     */
-    kill(callbacks?: StreamCallbacks): Promise<void>;
-    /**
-     * Get host URL for a port
-     */
-    getHost(port: number): Promise<string>;
-    /**
-     * Get agent type
-     */
-    getAgentType(): AgentType;
-    /**
-     * Get current session tag.
-     * Returns null if no active session (before sandbox creation or after kill()).
-     * Used for both observability (dashboard traces) and spend tracking (LiteLLM customer-id).
-     */
-    getSessionTag(): string | null;
-    /**
-     * Get current session timestamp
-     *
-     * Returns null if no session has started (run() not called yet).
-     */
-    getSessionTimestamp(): string | null;
-    /**
-     * Flush pending observability events without closing the session.
-     */
-    flushObservability(): Promise<void>;
-    /**
-     * Tear down the session logger and rotate the session tag.
-     * Preserves `previousSessionTag` only if this session had actual activity,
-     * so a double kill() or no-op lifecycle call doesn't clobber the real tag.
-     * @internal
-     */
-    private rotateSession;
-    /**
-     * Fetch spend data from dashboard API.
-     * @internal
-     */
-    private fetchSpend;
-    /**
-     * Resolve the session tag for cost queries.
-     * Uses the active session tag, or falls back to the previous tag after kill()/setSession().
-     * @internal
-     */
-    private resolveSpendTag;
-    /**
-     * Normalize run payloads for compatibility with older dashboard responses.
-     * Older responses may omit `asOf`, `isComplete`, or `truncated` inside `runs[]`.
-     * @internal
-     */
-    private normalizeRunCost;
-    /**
-     * Normalize session payloads so all `runs[]` conform to `RunCost`.
-     * @internal
-     */
-    private normalizeSessionCost;
-    /**
-     * Get cost breakdown for the current session (all runs).
-     *
-     * Queries the dashboard API which proxies to LiteLLM spend logs.
-     * Cost data has ~60s latency due to gateway batch writes.
-     * Also works after kill() for the most recent session only.
-     *
-     * Requires gateway mode (EVOLVE_API_KEY).
-     */
-    getSessionCost(): Promise<SessionCost>;
-    /**
-     * Get cost for a specific run by ID or index.
-     *
-     * @param run - Either `{ runId: string }` or `{ index: number }` (1-based, negative = from end)
-     *
-     * Also works after kill() for the most recent session only.
-     * Requires gateway mode (EVOLVE_API_KEY).
-     */
-    getRunCost(run: {
-        runId: string;
-    } | {
-        index: number;
-    }): Promise<RunCost>;
-}
-
-/**
- * Claude JSONL → ACP-style events parser.
- *
- * Native schema source (@anthropic-ai/claude-agent-sdk):
- *   MANUS-API/KNOWLEDGE/claude-agent-sdk/cc_sdk_typescript.md
- *   (SDKMessage, SDKAssistantMessage, SDKPartialAssistantMessage, Tool Input/Output types)
- *
- * Conversion logic reference:
- *   MANUS-API/KNOWLEDGE/claude-code-acp/src/tools.ts
- *   (toolInfoFromToolUse, toolUpdateFromToolResult)
- *
- * ACP output schema:
- *   MANUS-API/KNOWLEDGE/acp-typescript-sdk/src/schema/types.gen.ts
- */
-
-/**
- * Create a Claude parser instance with its own isolated cache.
- * Each Evolve instance should create its own parser for proper isolation.
- */
-declare function createClaudeParser(): (jsonLine: string) => OutputEvent[] | null;
-
-/**
- * Codex JSONL → ACP-style events parser.
- *
- * Native schema: codex-rs/exec/src/exec_events.rs
- *   - ThreadEvent: thread.started, turn.started, turn.completed, item.started, item.updated, item.completed
- *   - ThreadItemDetails: AgentMessage, Reasoning, CommandExecution, FileChange, McpToolCall, WebSearch, TodoList, Error
- *
- * ACP output: acp-typescript-sdk/src/schema/types.gen.ts
- *   - SessionUpdate: agent_message_chunk, agent_thought_chunk, tool_call, tool_call_update, plan
- *
- * Event mapping:
- *   reasoning         → agent_thought_chunk  (exec_events.rs:134 ReasoningItem { text })
- *   agent_message     → agent_message_chunk  (exec_events.rs:129 AgentMessageItem { text })
- *   mcp_tool_call     → tool_call/update     (exec_events.rs:215 McpToolCallItem)
- *   command_execution → tool_call/update     (exec_events.rs:151 CommandExecutionItem)
- *   file_change       → tool_call            (exec_events.rs:176 FileChangeItem)
- *   todo_list         → plan                 (exec_events.rs:245 TodoListItem { items: TodoItem[] })
- *   web_search        → tool_call            (exec_events.rs:227 WebSearchItem { query })
- */
-
-/**
- * Create a Codex parser instance.
- */
-declare function createCodexParser(): (jsonLine: string) => OutputEvent[] | null;
-
-/**
- * Droid exec parser.
- *
- * Supports the documented headless `--output-format stream-json` lines and the
- * raw `stream-jsonrpc` notification envelope used by Droid's low-level SDK.
- */
-
-declare function createDroidParser(): (jsonLine: string) => OutputEvent[] | null;
-
-/**
- * Gemini JSONL → ACP-style events parser.
- *
- * Native schema (gemini --output-format stream-json):
- *   gemini-cli/packages/core/src/output/types.ts
- *
- * Gemini events (types.ts:29-36 JsonStreamEventType):
- * - "init"        → types.ts:43-47 InitEvent { session_id, model }
- * - "message"     → types.ts:49-54 MessageEvent { role, content, delta? }
- * - "tool_use"    → types.ts:56-61 ToolUseEvent { tool_name, tool_id, parameters }
- * - "tool_result" → types.ts:63-72 ToolResultEvent { tool_id, status, output?, error? }
- * - "error"       → types.ts:74-78 ErrorEvent { severity, message }
- * - "result"      → types.ts:91-99 ResultEvent { status, error?, stats? }
- *
- * ACP output: acp-typescript-sdk/src/schema/types.gen.ts:2449-2464
- */
-
-/**
- * Create a Gemini parser instance.
- */
-declare function createGeminiParser(): (jsonLine: string) => OutputEvent[] | null;
-
-/**
- * Qwen NDJSON → ACP-style events parser.
- *
- * Native schema: KNOWLEDGE/qwen-code/packages/sdk-typescript/src/types/protocol.ts
- * ACP schema: KNOWLEDGE/acp-typescript-sdk/src/schema/types.gen.ts
- *
- * Qwen NDJSON message types (protocol.ts:428-433):
- * - type: "assistant"    → SDKAssistantMessage (protocol.ts:102-108)
- * - type: "stream_event" → SDKPartialAssistantMessage (protocol.ts:225-231)
- * - type: "user"         → SDKUserMessage (protocol.ts:93-100)
- * - type: "system"       → SDKSystemMessage (skipped)
- * - type: "result"       → SDKResultMessage (skipped)
- *
- * ContentBlock types (protocol.ts:72-76):
- * - TextBlock (protocol.ts:43-48): { type: 'text', text: string }
- * - ThinkingBlock (protocol.ts:49-54): { type: 'thinking', thinking: string }
- * - ToolUseBlock (protocol.ts:56-62): { type: 'tool_use', id, name, input }
- * - ToolResultBlock (protocol.ts:64-70): { type: 'tool_result', tool_use_id, content?, is_error? }
- *
- * StreamEvent types (protocol.ts:218-223):
- * - message_start, content_block_start, content_block_delta, content_block_stop, message_stop
- */
-
-/**
- * Stateless parser function (creates new parser per call).
- * Use createQwenParser() for stateful streaming parsing.
- *
- * @param line - Single line of NDJSON from qwen CLI
- * @returns Array of OutputEvent objects, or null if line couldn't be parsed
- */
-declare function parseQwenOutput(line: string): OutputEvent[] | null;
-
-/**
- * Unified Parser Entry Point
- *
- * Routes NDJSON lines to the appropriate agent-specific parser.
- * Simple line-based parsing - no buffering needed since CLIs output complete JSON per line.
- */
-
-/** Parser function type */
-type AgentParser = (jsonLine: string) => OutputEvent[] | null;
-/**
- * Create a parser instance for the given agent type.
- * Each Evolve instance should create its own parser for proper isolation.
- *
- * @param agentType - The agent type to create a parser for
- * @returns Parser function that takes NDJSON lines and returns OutputEvents
- */
-declare function createAgentParser(agentType: AgentType): AgentParser;
-/**
- * Parse a single NDJSON line from any agent (creates new parser per call - use createAgentParser for efficiency)
- *
- * @param agentType - The agent type to parse for
- * @param line - Single line of NDJSON output
- * @returns Array of OutputEvent objects, or null if line couldn't be parsed
- */
-declare function parseNdjsonLine(agentType: AgentType, line: string): OutputEvent[] | null;
-/**
- * Parse multiple NDJSON lines (convenience wrapper)
- *
- * @param agentType - The agent type to parse for
- * @param output - Multi-line NDJSON output
- * @returns Array of all parsed OutputEvent objects
- */
-declare function parseNdjsonOutput(agentType: AgentType, output: string): OutputEvent[];
+     * may have already run commands, so we set hasRun=true to use
+     * the continue/resume command template instead of first-run.
+     */
+    setSession(sandboxId: string): Promise<void>;
+    /**
+     * Pause sandbox
+     */
+    pause(callbacks?: StreamCallbacks): Promise<void>;
+    /**
+     * Resume sandbox
+     */
+    resume(callbacks?: StreamCallbacks): Promise<void>;
+    /**
+     * Interrupt active command without killing the sandbox.
+     */
+    interrupt(callbacks?: StreamCallbacks): Promise<boolean>;
+    /**
+     * Get current runtime status for sandbox and agent.
+     */
+    status(): SessionStatus;
+    /**
+     * Kill sandbox (terminates all processes)
+     */
+    kill(callbacks?: StreamCallbacks): Promise<void>;
+    /**
+     * Get host URL for a port
+     */
+    getHost(port: number): Promise<string>;
+    /**
+     * Get agent type
+     */
+    getAgentType(): AgentType;
+    /**
+     * Get current session tag.
+     * Returns null if no active session (before sandbox creation or after kill()).
+     * Used for both observability (dashboard traces) and spend tracking (gateway customer-id).
+     */
+    getSessionTag(): string | null;
+    /**
+     * Get current session timestamp
+     *
+     * Returns null if no session has started (run() not called yet).
+     */
+    getSessionTimestamp(): string | null;
+    /**
+     * Flush pending observability events without closing the session.
+     */
+    flushObservability(): Promise<void>;
+    /**
+     * Get cost breakdown for the current session (all runs).
+     *
+     * Cost data can lag live usage by about a minute.
+     * Also works after kill() for the most recent session only.
+     *
+     * Requires gateway mode (EVOLVE_API_KEY).
+     */
+    getSessionCost(): Promise<SessionCost>;
+    /**
+     * Get cost for a specific run by ID or index.
+     *
+     * @param run - Either `{ runId: string }` or `{ index: number }` (1-based, negative = from end)
+     *
+     * Also works after kill() for the most recent session only.
+     * Requires gateway mode (EVOLVE_API_KEY).
+     */
+    getRunCost(run: {
+        runId: string;
+    } | {
+        index: number;
+    }): Promise<RunCost>;
+}
 
 declare const BROWSER_LOGIN_MCP_SERVER_NAME = "browser-login";
 interface BrowserCredentialMetadata {
@@ -1489,52 +1942,6 @@ declare class BrowserProfilesClient {
 }
 declare function browserProfiles(config?: BrowserProfilesClientConfig): BrowserProfilesClient;
 
-/**
- * Evolve events
- *
- * Runtime streams:
- * - stdout: Raw NDJSON lines
- * - stderr: Process stderr
- * - content: Parsed OutputEvent
- * - lifecycle: Sandbox/agent lifecycle transitions
- */
-interface EvolveEvents {
-    stdout: (chunk: string) => void;
-    stderr: (chunk: string) => void;
-    content: (event: OutputEvent) => void;
-    lifecycle: (event: LifecycleEvent) => void;
-}
-interface EvolveConfig {
-    agent?: AgentConfig;
-    sandbox?: SandboxProvider;
-    workingDirectory?: string;
-    workspaceMode?: WorkspaceMode;
-    secrets?: Record<string, string>;
-    sandboxId?: string;
-    systemPrompt?: string;
-    context?: FileMap;
-    files?: FileMap;
-    mcpServers?: Record<string, McpServerConfig>;
-    /** Browser automation provider to enable explicitly */
-    browser?: BrowserConfig;
-    /** Browser login MCP setup for managed remote agent-browser runs */
-    browserCredentials?: BrowserCredentialsConfig;
-    /** Agent plugins/extensions to install before first run */
-    plugins?: AgentPluginConfig[];
-    /** Skills to enable (e.g., ["pdf", "dev-browser"]) */
-    skills?: SkillName[];
-    /** Schema for structured output (Zod or JSON Schema, auto-detected) */
-    schema?: z.ZodType<unknown> | JsonSchema;
-    /** Validation options for JSON Schema (ignored for Zod) */
-    schemaOptions?: SchemaValidationOptions;
-    sessionTagPrefix?: string;
-    /** Observability metadata for trace grouping (generic key-value, domain-agnostic) */
-    observability?: Record<string, unknown>;
-    /** Managed integrations config */
-    integrations?: IntegrationsSetup;
-    /** Storage configuration for checkpointing */
-    storage?: StorageConfig;
-}
 /**
  * Evolve orchestrator with builder pattern
  *
@@ -1568,6 +1975,11 @@ declare class Evolve extends EventEmitter {
      * Configure sandbox provider
      */
     withSandbox(provider?: SandboxProvider): this;
+    /**
+     * Configure provider-neutral options used whenever Evolve creates a sandbox.
+     * Evolve-owned runtime variables override conflicting env entries.
+     */
+    withSandboxCreateOptions(options: SandboxCreateOptions): this;
     /**
      * Set working directory path
      */
@@ -1576,12 +1988,19 @@ declare class Evolve extends EventEmitter {
      * Set workspace mode
      * - "knowledge": Creates context/, scripts/, temp/, output/ folders
      * - "swe": Same as knowledge + repo/ folder for code repositories
+     * - "task": Leaves the task-owned working directory untouched
      */
     withWorkspaceMode(mode: WorkspaceMode): this;
     /**
      * Add environment secrets
      */
     withSecrets(secrets: Record<string, string>): this;
+    /**
+     * Attach Dashboard-stored managed secrets to the sandbox.
+     *
+     * The sandbox receives opaque env var values; raw secret values stay server-side.
+     */
+    withManagedSecrets(secrets: ManagedSecretRef[]): this;
     /**
      * Connect to existing session
      */
@@ -1668,11 +2087,6 @@ declare class Evolve extends EventEmitter {
      * Set session tag prefix for observability
      */
     withSessionTagPrefix(prefix: string): this;
-    /**
-     * @internal Set observability metadata for trace grouping.
-     * Used internally by Swarm - not part of public API.
-     */
-    withObservability(meta: Record<string, unknown>): this;
     /**
      * Enable Evolve-managed integrations.
      *
@@ -1710,6 +2124,8 @@ declare class Evolve extends EventEmitter {
     static browserCredentials: typeof browserCredentials;
     /** Static browser profile client for listing and deleting reusable browser profiles. */
     static browserProfiles: typeof browserProfiles;
+    /** Static managed secrets client for listing Dashboard-stored secret metadata. */
+    static managedSecrets: typeof managedSecrets;
     /**
      * Initialize agent on first use
      */
@@ -1738,6 +2154,21 @@ declare class Evolve extends EventEmitter {
         timeoutMs?: number;
         background?: boolean;
     }): Promise<AgentResponse>;
+    /**
+     * Create and fully initialize the configured sandbox without starting an
+     * agent command. Durable orchestrators use this to persist the sandbox ID
+     * before handing execution to the agent.
+     */
+    prepareSandbox(): Promise<string>;
+    /**
+     * Irreversibly revoke Evolve-managed runtime credentials for this sandbox.
+     * Agent runs are disabled afterward; credential-free commands remain available.
+     */
+    sealCredentials(): Promise<void>;
+    /** Whether sealCredentials() has completed for the active sandbox. */
+    isSealed(): boolean;
+    /** Collect files or directories from the working directory after credentials are sealed. */
+    collectArtifacts(paths: string[]): Promise<FileMap>;
     /**
      * Interrupt active process without killing sandbox.
      */
@@ -1750,6 +2181,15 @@ declare class Evolve extends EventEmitter {
      * Upload files to workspace (runtime - immediate upload)
      */
     uploadFiles(files: FileMap): Promise<void>;
+    /**
+     * Upload one LOCAL file into the sandbox by path, streaming rather than
+     * buffering it (runtime - immediate upload).
+     *
+     * The memory-bounded counterpart to uploadFiles(): use it when the file is
+     * large enough that holding it in the heap — once per concurrent upload —
+     * would matter.
+     */
+    uploadFileFromPath(sandboxPath: string, localPath: string): Promise<void>;
     /**
      * Get output files from output/ folder with optional schema validation
      *
@@ -1941,7 +2381,7 @@ interface SwarmConfig {
     /** Per-worker timeout in ms (default: 1 hour) */
     timeoutMs?: number;
     /** Workspace mode (default: SDK default 'knowledge') */
-    workspaceMode?: WorkspaceMode;
+    workspaceMode?: Exclude<WorkspaceMode, "task">;
     /** Default retry configuration for all operations (per-operation config takes precedence) */
     retry?: RetryConfig;
     /** Default MCP servers for all operations (per-operation config takes precedence) */
@@ -2142,7 +2582,7 @@ interface VerifyInfo {
 type ItemInput = FileMap | SwarmResult<unknown>;
 type PromptFn = (files: FileMap, index: number) => string;
 type Prompt = string | PromptFn;
-/** @internal Pipeline context for observability (set by Pipeline, not user) */
+/** Pipeline context for observability (set by Pipeline, not user) — exported from the package root */
 interface PipelineContext {
     pipelineRunId: string;
     pipelineStepIndex: number;
@@ -2157,8 +2597,6 @@ interface MapParams<T> {
     name?: string;
     /** Optional system prompt */
     systemPrompt?: string;
-    /** @internal Pipeline context (set by Pipeline, not user) */
-    _pipelineContext?: PipelineContext;
     /** Schema for structured output (Zod or JSON Schema) */
     schema?: z.ZodType<T> | JsonSchema;
     /** Validation options for JSON Schema (ignored for Zod) */
@@ -2188,8 +2626,6 @@ interface FilterParams<T> {
     prompt: string;
     /** Optional operation name for observability */
     name?: string;
-    /** @internal Pipeline context (set by Pipeline, not user) */
-    _pipelineContext?: PipelineContext;
     /** Schema for structured output (Zod or JSON Schema) */
     schema: z.ZodType<T> | JsonSchema;
     /** Validation options for JSON Schema (ignored for Zod) */
@@ -2223,8 +2659,6 @@ interface ReduceParams<T> {
     name?: string;
     /** Optional system prompt */
     systemPrompt?: string;
-    /** @internal Pipeline context (set by Pipeline, not user) */
-    _pipelineContext?: PipelineContext;
     /** Schema for structured output (Zod or JSON Schema) */
     schema?: z.ZodType<T> | JsonSchema;
     /** Validation options for JSON Schema (ignored for Zod) */
@@ -2492,7 +2926,7 @@ interface ReduceConfig<T> extends BaseStepConfig {
     /** Retry configuration */
     retry?: RetryConfig<ReduceResult<T>>;
 }
-/** @internal Step representation */
+/** Step representation — reaches the public surface through Pipeline's constructor */
 type Step = {
     type: "map";
     config: MapConfig<unknown>;
@@ -2503,7 +2937,7 @@ type Step = {
     type: "reduce";
     config: ReduceConfig<unknown>;
 };
-/** @internal Step type literal */
+/** Step type literal — reaches the public surface as StepResult.type */
 type StepType = "map" | "filter" | "reduce";
 /** Result of a single pipeline step */
 interface StepResult<T = unknown> {
@@ -2685,176 +3119,203 @@ declare class TerminalPipeline<T> extends Pipeline<T> {
 }
 
 /**
- * Agent Registry
- *
- * Single source of truth for agent-specific behavior.
- * All differences between agents are data, not code.
- *
- * Evidence: sdk-rewrite-v3.md Agent Registry section
- */
-
-/** Model configuration */
-interface ModelInfo {
-    /** Model alias (short name used with --model) */
-    alias: string;
-    /** Full model ID */
-    modelId: string;
-    /** What this model is best for */
-    description: string;
-}
-/** MCP configuration for an agent */
-interface McpConfigInfo {
-    /** Settings directory (e.g., "~/.claude") */
-    settingsDir: string;
-    /** Config filename (e.g., "settings.json" or "config.toml") */
-    filename: string;
-    /** Config format */
-    format: "json" | "toml";
-    /** Whether to use workingDir for project-level config (Claude only) */
-    projectConfig?: boolean;
-}
-/** Options for building agent commands */
-interface BuildCommandOptions {
-    prompt: string;
-    model: string;
-    isResume: boolean;
-    sessionId?: string;
-    reasoningEffort?: string;
-    isDirectMode?: boolean;
-    /** Skills enabled for this run */
-    skills?: string[];
-}
-interface AgentRegistryEntry {
-    /** Sandbox image/template identifier (provider maps to its own concept) */
-    image: string;
-    /** Environment variable name for API key */
-    apiKeyEnv: string;
-    /** Environment variable name for OAuth (file path or token depending on agent) */
-    oauthEnv?: string;
-    /** OAuth credentials filename (e.g., "auth.json" for Codex, "oauth_creds.json" for Gemini) */
-    oauthFileName?: string;
-    /** Environment variable to set when OAuth is active (e.g., GOOGLE_GENAI_USE_GCA=true for Gemini) */
-    oauthActivationEnv?: {
-        key: string;
-        value: string;
-    };
-    /** Environment variable name for base URL, if this CLI supports one */
-    baseUrlEnv?: string;
-    /** Default model alias */
-    defaultModel: string;
-    /** Available models for this agent */
-    models: ModelInfo[];
-    /** System prompt filename (e.g., "CLAUDE.md") */
-    systemPromptFile: string;
-    /** MCP configuration */
-    mcpConfig: McpConfigInfo;
-    /** Build the CLI command for this agent */
-    buildCommand: (opts: BuildCommandOptions) => string;
-    /** Extra setup step (e.g., codex login) */
-    setupCommand?: string;
-    /** Gateway path prefix for CLIs that use a provider-native passthrough endpoint */
-    gatewayPath?: string;
-    /** Default base URL for direct mode (only needed if provider requires specific endpoint, e.g., Qwen → Dashscope) */
-    defaultBaseUrl?: string;
-    /** Available beta headers for this agent (for reference) */
-    availableBetas?: Record<string, string>;
-    /** Skills configuration for this agent */
-    skillsConfig: SkillsConfig;
-    /** Multi-provider env mapping: model prefix → keyEnv (for CLIs like OpenCode that resolve provider from model string) */
-    providerEnvMap?: Record<string, {
-        keyEnv: string;
-    }>;
-    /** Env var for inline config (e.g., OPENCODE_CONFIG_CONTENT) — used in gateway mode to set provider base URLs */
-    gatewayConfigEnv?: string;
-    /** Gateway-only model aliases for CLIs whose native model IDs differ from LiteLLM route names */
-    gatewayModelAliases?: Record<string, string>;
-    /** Direct-mode model aliases for CLIs whose public model names differ from CLI-native model IDs */
-    directModelAliases?: Record<string, string>;
-    /** Do not set provider API key env in gateway mode (used when routing via generated settings instead) */
-    skipApiKeyEnvInGateway?: boolean;
-    /** Dedicated Droid settings file for Evolve gateway custom model routing */
-    droidGatewaySettings?: {
-        settingsPath: string;
-        displayName: string;
-        provider: "generic-chat-completion-api" | "openai" | "anthropic";
-        maxOutputTokens?: number;
-    };
-    /** Environment variable that CLI reads for custom outbound HTTP headers */
-    customHeadersEnv?: string;
-    /** Format for custom headers env var: "newline" (Claude) or "comma" (Gemini). Default: "newline" */
-    customHeadersFormat?: "newline" | "comma";
-    /**
-     * Per-env-var spend tracking for CLIs that support env_http_headers in config
-     * (e.g., Codex TOML). Maps LiteLLM header names to env var names that the CLI
-     * reads at request time. Alternative to customHeadersEnv for agents without a
-     * single custom-headers env var.
-     */
-    spendTrackingEnvs?: {
-        /** Env var name for x-litellm-customer-id value */
-        sessionTagEnv: string;
-        /** Env var name for x-litellm-tags value */
-        runTagEnv: string;
-    };
-    /**
-     * Config-file-based spend tracking for CLIs that read custom headers from a
-     * JSON settings file (e.g., Qwen settings.json → model.generationConfig.customHeaders).
-     * The SDK writes headers to this file before each run.
-     * Source-verified: Qwen reads customHeaders from settings.json, not env vars.
-     */
-    spendTrackingJsonConfig?: {
-        /** JSON path to the customHeaders object (dot-separated) */
-        headersPath: string;
-    };
-    /**
-     * TOML provider-based spend tracking for CLIs that read custom_headers from a
-     * provider entry in config.toml (e.g., Kimi Code).
-     * The SDK writes a provider+model entry with custom_headers before each run.
-     * Source-verified: Kimi Code reads custom_headers from
-     * providers[name].custom_headers in ~/.kimi-code/config.toml.
-     */
-    spendTrackingTomlProvider?: {
-        /** Config file path (e.g., "~/.kimi-code/config.toml") */
-        configPath: string;
-        /** Provider name in config (e.g., "evolve-gateway") */
-        providerName: string;
-        /** Model entry name (e.g., "evolve-default") */
-        modelName: string;
-        /** Max context size for the model entry */
-        maxContextSize: number;
-    };
-    /** Additional directories to include in checkpoint tar (beyond mcpConfig.settingsDir).
-     *  Used for agents like OpenCode that spread state across XDG directories. */
-    checkpointDirs?: string[];
-    /** Additional relative paths to exclude from checkpoint tar. */
-    checkpointExcludes?: string[];
+ * Evolve SDK Constants
+ *
+ * Internal constants - not exposed to users.
+ */
+/**
+ * Sandbox providers the Dashboard runs on the customer's behalf.
+ *
+ * Managed mode means the customer holds one Evolve API key and no provider
+ * credential at all: the Dashboard authenticates the key, records ownership,
+ * and makes the provider call with platform credentials. Each provider has its
+ * own door under /api/managed/<provider>.
+ */
+declare const MANAGED_SANDBOX_PROVIDERS: readonly ["e2b", "daytona", "modal"];
+type ManagedSandboxProviderName = (typeof MANAGED_SANDBOX_PROVIDERS)[number];
+
+/**
+ * Sandbox Provider Resolution
+ *
+ * Resolves default sandbox provider from environment.
+ * Supports E2B, Daytona, and Modal providers.
+ */
+
+/**
+ * Sandbox-shape defaults a managed provider applies to every sandbox it
+ * creates. Per-create options (`.withSandboxCreateOptions()`) still win, and
+ * the values ride the same validated path as any create: providers and doors
+ * reject what they cannot enforce, never silently ignore it.
+ */
+interface ManagedSandboxCreateDefaults {
+    /** Lifetime cap (ms) for every sandbox this provider creates. */
+    timeoutMs?: number;
+    /** Compute sizing (cpu cores, memory/disk GiB) for every create. */
+    resources?: SandboxCreateOptions["resources"];
+}
+/** Options bag for `managedSandbox()`: the Evolve key plus create defaults. */
+interface ManagedSandboxOptions extends ManagedSandboxCreateDefaults {
+    /** Evolve API key. Default: the EVOLVE_API_KEY environment variable. */
+    apiKey?: string;
 }
 /**
- * Registry of all supported agents.
+ * A sandbox the platform runs for you.
  *
- * Each agent defines a buildCommand function that constructs the CLI command.
- * This is type-safe and handles conditional logic cleanly.
+ * ```ts
+ * const kit = new Evolve()
+ *   .withAgent({ agentType: "claude" })
+ *   .withSandbox(await managedSandbox("daytona", { timeoutMs: 7_200_000 }));
+ * ```
+ *
+ * Requires an Evolve API key and no provider credential of any kind. Omit the
+ * provider to take the platform default (E2B). The options bag carries the
+ * Evolve key plus sandbox-shape defaults (`timeoutMs`, `resources`) applied to
+ * every create; a bare string is still accepted as the key alone.
  */
-declare const AGENT_REGISTRY: Record<AgentType, AgentRegistryEntry>;
+declare function managedSandbox(provider?: ManagedSandboxProviderName, options?: string | ManagedSandboxOptions): Promise<SandboxProvider>;
+
 /**
- * Get registry entry for an agent type
+ * Claude JSONL → ACP-style events parser.
+ *
+ * Native schema source (@anthropic-ai/claude-agent-sdk):
+ *   MANUS-API/KNOWLEDGE/claude-agent-sdk/cc_sdk_typescript.md
+ *   (SDKMessage, SDKAssistantMessage, SDKPartialAssistantMessage, Tool Input/Output types)
+ *
+ * Conversion logic reference:
+ *   MANUS-API/KNOWLEDGE/claude-code-acp/src/tools.ts
+ *   (toolInfoFromToolUse, toolUpdateFromToolResult)
+ *
+ * ACP output schema:
+ *   MANUS-API/KNOWLEDGE/acp-typescript-sdk/src/schema/types.gen.ts
  */
-declare function getAgentConfig(agentType: AgentType): AgentRegistryEntry;
+
 /**
- * Check if an agent type is valid
+ * Create a Claude parser instance with its own isolated cache.
+ * Each Evolve instance should create its own parser for proper isolation.
  */
-declare function isValidAgentType(type: string): type is AgentType;
+declare function createClaudeParser(): (jsonLine: string) => OutputEvent[] | null;
+
 /**
- * Expand path with ~ to /home/user
+ * Codex JSONL → ACP-style events parser.
+ *
+ * Native schema: codex-rs/exec/src/exec_events.rs
+ *   - ThreadEvent: thread.started, turn.started, turn.completed, item.started, item.updated, item.completed
+ *   - ThreadItemDetails: AgentMessage, Reasoning, CommandExecution, FileChange, McpToolCall, WebSearch, TodoList, Error
+ *
+ * ACP output: acp-typescript-sdk/src/schema/types.gen.ts
+ *   - SessionUpdate: agent_message_chunk, agent_thought_chunk, tool_call, tool_call_update, plan
+ *
+ * Event mapping:
+ *   reasoning         → agent_thought_chunk  (exec_events.rs:134 ReasoningItem { text })
+ *   agent_message     → agent_message_chunk  (exec_events.rs:129 AgentMessageItem { text })
+ *   mcp_tool_call     → tool_call/update     (exec_events.rs:215 McpToolCallItem)
+ *   command_execution → tool_call/update     (exec_events.rs:151 CommandExecutionItem)
+ *   file_change       → tool_call            (exec_events.rs:176 FileChangeItem)
+ *   todo_list         → plan                 (exec_events.rs:245 TodoListItem { items: TodoItem[] })
+ *   web_search        → tool_call            (exec_events.rs:227 WebSearchItem { query })
  */
-declare function expandPath(path: string): string;
+
 /**
- * Get MCP settings path for an agent
+ * Create a Codex parser instance.
  */
-declare function getMcpSettingsPath(agentType: AgentType): string;
+declare function createCodexParser(): (jsonLine: string) => OutputEvent[] | null;
+
 /**
- * Get MCP settings directory for an agent
+ * Droid exec parser.
+ *
+ * Supports the documented headless `--output-format stream-json` lines and the
+ * raw `stream-jsonrpc` notification envelope used by Droid's low-level SDK.
+ */
+
+declare function createDroidParser(): (jsonLine: string) => OutputEvent[] | null;
+
+/**
+ * Gemini JSONL → ACP-style events parser.
+ *
+ * Native schema (gemini --output-format stream-json):
+ *   gemini-cli/packages/core/src/output/types.ts
+ *
+ * Gemini events (types.ts:29-36 JsonStreamEventType):
+ * - "init"        → types.ts:43-47 InitEvent { session_id, model }
+ * - "message"     → types.ts:49-54 MessageEvent { role, content, delta? }
+ * - "tool_use"    → types.ts:56-61 ToolUseEvent { tool_name, tool_id, parameters }
+ * - "tool_result" → types.ts:63-72 ToolResultEvent { tool_id, status, output?, error? }
+ * - "error"       → types.ts:74-78 ErrorEvent { severity, message }
+ * - "result"      → types.ts:91-99 ResultEvent { status, error?, stats? }
+ *
+ * ACP output: acp-typescript-sdk/src/schema/types.gen.ts:2449-2464
+ */
+
+/**
+ * Create a Gemini parser instance.
+ */
+declare function createGeminiParser(): (jsonLine: string) => OutputEvent[] | null;
+
+/**
+ * Qwen NDJSON → ACP-style events parser.
+ *
+ * Native schema: KNOWLEDGE/qwen-code/packages/sdk-typescript/src/types/protocol.ts
+ * ACP schema: KNOWLEDGE/acp-typescript-sdk/src/schema/types.gen.ts
+ *
+ * Qwen NDJSON message types (protocol.ts:428-433):
+ * - type: "assistant"    → SDKAssistantMessage (protocol.ts:102-108)
+ * - type: "stream_event" → SDKPartialAssistantMessage (protocol.ts:225-231)
+ * - type: "user"         → SDKUserMessage (protocol.ts:93-100)
+ * - type: "system"       → SDKSystemMessage (skipped)
+ * - type: "result"       → SDKResultMessage (skipped)
+ *
+ * ContentBlock types (protocol.ts:72-76):
+ * - TextBlock (protocol.ts:43-48): { type: 'text', text: string }
+ * - ThinkingBlock (protocol.ts:49-54): { type: 'thinking', thinking: string }
+ * - ToolUseBlock (protocol.ts:56-62): { type: 'tool_use', id, name, input }
+ * - ToolResultBlock (protocol.ts:64-70): { type: 'tool_result', tool_use_id, content?, is_error? }
+ *
+ * StreamEvent types (protocol.ts:218-223):
+ * - message_start, content_block_start, content_block_delta, content_block_stop, message_stop
+ */
+
+/**
+ * Stateless parser function (creates new parser per call).
+ * Use createQwenParser() for stateful streaming parsing.
+ *
+ * @param line - Single line of NDJSON from qwen CLI
+ * @returns Array of OutputEvent objects, or null if line couldn't be parsed
+ */
+declare function parseQwenOutput(line: string): OutputEvent[] | null;
+
+/**
+ * Unified Parser Entry Point
+ *
+ * Routes NDJSON lines to the appropriate agent-specific parser.
+ * Simple line-based parsing - no buffering needed since CLIs output complete JSON per line.
+ */
+
+/** Parser function type */
+type AgentParser = (jsonLine: string) => OutputEvent[] | null;
+/**
+ * Create a parser instance for the given agent type.
+ * Each Evolve instance should create its own parser for proper isolation.
+ *
+ * @param agentType - The agent type to create a parser for
+ * @returns Parser function that takes NDJSON lines and returns OutputEvents
+ */
+declare function createAgentParser(agentType: AgentType): AgentParser;
+/**
+ * Parse a single NDJSON line from any agent (creates new parser per call - use createAgentParser for efficiency)
+ *
+ * @param agentType - The agent type to parse for
+ * @param line - Single line of NDJSON output
+ * @returns Array of OutputEvent objects, or null if line couldn't be parsed
+ */
+declare function parseNdjsonLine(agentType: AgentType, line: string): OutputEvent[] | null;
+/**
+ * Parse multiple NDJSON lines (convenience wrapper)
+ *
+ * @param agentType - The agent type to parse for
+ * @param output - Multi-line NDJSON output
+ * @returns Array of all parsed OutputEvent objects
  */
-declare function getMcpSettingsDir(agentType: AgentType): string;
+declare function parseNdjsonOutput(agentType: AgentType, output: string): OutputEvent[];
 
 /**
  * MCP JSON Configuration Writer
@@ -2876,11 +3337,11 @@ declare function getMcpSettingsDir(agentType: AgentType): string;
  * 1. ${workingDir}/.mcp.json - project-level MCP servers
  * 2. ~/.claude/settings.json - enable project MCP servers
  */
-declare function writeClaudeMcpConfig(sandbox: SandboxInstance, workingDir: string, servers: Record<string, McpServerConfig>): Promise<void>;
+declare function writeClaudeMcpConfig(sandbox: SandboxInstance, workingDir: string, servers: Record<string, McpServerConfig>, homeDir?: string): Promise<void>;
 /** Write MCP config for Gemini agent */
-declare function writeGeminiMcpConfig(sandbox: SandboxInstance, servers: Record<string, McpServerConfig>): Promise<void>;
+declare function writeGeminiMcpConfig(sandbox: SandboxInstance, servers: Record<string, McpServerConfig>, homeDir?: string): Promise<void>;
 /** Write MCP config for Qwen agent */
-declare function writeQwenMcpConfig(sandbox: SandboxInstance, servers: Record<string, McpServerConfig>): Promise<void>;
+declare function writeQwenMcpConfig(sandbox: SandboxInstance, servers: Record<string, McpServerConfig>, homeDir?: string): Promise<void>;
 /**
  * Write MCP config for Droid agent
  *
@@ -2903,13 +3364,18 @@ interface DroidGatewaySettingsConfig {
  * The command passes this file with `droid --settings`, so it does not alter the
  * user's normal ~/.factory/settings.json inside the sandbox.
  */
-declare function writeDroidGatewaySettings(sandbox: SandboxInstance, config: DroidGatewaySettingsConfig, headers: Record<string, string>): Promise<void>;
+declare function writeDroidGatewaySettings(sandbox: SandboxInstance, config: DroidGatewaySettingsConfig, headers: Record<string, string>, homeDir?: string): Promise<void>;
 
 /**
  * MCP TOML Configuration Writer
  *
  * Handles MCP config for Codex agent which uses TOML format.
  * Uses registry for paths - no hardcoded values.
+ *
+ * Every writer here follows one pattern: parse the existing document into an
+ * object, mutate the object, re-serialize with smol-toml. Nothing inspects the
+ * raw text, so a commented-out section never masks a real one and a value
+ * containing newlines or quotes cannot break the file.
  */
 
 /**
@@ -2918,7 +3384,7 @@ declare function writeDroidGatewaySettings(sandbox: SandboxInstance, config: Dro
  * Codex stores MCP config in ~/.codex/config.toml using TOML format.
  * Format: [mcp_servers.server_name] sections
  */
-declare function writeCodexMcpConfig(sandbox: SandboxInstance, servers: Record<string, McpServerConfig>): Promise<void>;
+declare function writeCodexMcpConfig(sandbox: SandboxInstance, servers: Record<string, McpServerConfig>, homeDir?: string): Promise<void>;
 
 /**
  * MCP Configuration Module
@@ -2938,7 +3404,7 @@ declare function writeCodexMcpConfig(sandbox: SandboxInstance, servers: Record<s
  * - Droid: JSON to ${workingDir}/.factory/mcp.json
  * - OpenCode: JSON to ${workingDir}/opencode.json (mcp key)
  */
-declare function writeMcpConfig(agentType: AgentType, sandbox: SandboxInstance, workingDir: string, servers: Record<string, McpServerConfig>): Promise<void>;
+declare function writeMcpConfig(agentType: AgentType, sandbox: SandboxInstance, workingDir: string, servers: Record<string, McpServerConfig>, homeDir?: string): Promise<void>;
 
 /**
  * Prompt Templates
@@ -3008,6 +3474,12 @@ declare const VERIFY_PROMPT: string;
 declare const RETRY_FEEDBACK_PROMPT: string;
 /**
  * Apply template variables to a prompt
+ *
+ * ONE pass over the template: substituted values are emitted verbatim and
+ * never rescanned, so a value that itself contains `{{...}}` (user prompts,
+ * verifier feedback, criteria) is not re-expanded by a later variable — and
+ * `$`-replacement patterns in values stay literal (a function replacement's
+ * return value is never $-interpreted).
  */
 declare function applyTemplate(template: string, variables: Record<string, string>): string;
 /**
@@ -3078,16 +3550,37 @@ declare function readLocalDir(localPath: string, recursive?: boolean): FileMap;
  * const output = await agent.getOutputFiles(true);
  * saveLocalDir('./output', output.files);
  * // Creates: ./output/file.txt, ./output/subdir/nested.txt, etc.
+ *
+ * @throws If an entry's path escapes the target directory. The names come
+ * from sandbox output, so a hostile `../` or absolute entry must not write
+ * outside the directory the caller chose.
  */
 declare function saveLocalDir(localPath: string, files: FileMap): void;
 
+/**
+ * Configuration Utilities
+ */
+
+/**
+ * A configuration field the caller got wrong, reported by name.
+ *
+ * Without a check at the door the mistake travels: an empty model or a missing
+ * prompt reaches the command builder and comes back as
+ * `Cannot read properties of undefined (reading 'replace')` thrown by a
+ * shell-quoting helper, which names nothing the caller wrote and points at a
+ * file they have never opened.
+ */
+declare class EvolveConfigError extends Error {
+    /** The configuration field at fault, e.g. "model" or "prompt". */
+    readonly field: string;
+    constructor(field: string, message: string);
+}
+
 /**
  * Storage & Checkpointing Module
  *
  * Provides durable persistence for agent workspaces beyond sandbox lifetime.
  * Supports BYOK (user's S3 bucket) and Gateway (Evolve-managed) modes.
- *
- * Evidence: storage-checkpointing plan v2.2
  */
 
 /**
@@ -3206,4 +3699,240 @@ interface SessionsClient {
  */
 declare function sessions(config?: SessionsConfig): SessionsClient;
 
-export { AGENT_REGISTRY, AGENT_TYPES, type ActionbookBrowserConfig, Agent, type AgentBrowserConfig, type AgentConfig, type AgentOptions, type AgentOverride, type AgentParser, type AgentPluginConfig, type AgentRegistryEntry, type AgentResponse, type AgentRuntimeState, type AgentType, BROWSER_ACTIONBOOK_PROMPT, BROWSER_LOGIN_MCP_SERVER_NAME, type BaseMeta, type BestOfConfig, type BestOfParams, type BestOfResult, type BrowserConfig, type BrowserCredentialCreateInput, type BrowserCredentialDeleteInput, type BrowserCredentialListOptions, type BrowserCredentialMetadata, type BrowserCredentialScopeEntry, BrowserCredentialsClient, type BrowserCredentialsClientConfig, type BrowserCredentialsConfig, type BrowserProfileDeleteInput, type BrowserProfileMetadata, BrowserProfilesClient, type BrowserProfilesClientConfig, type BrowserProvider, type BrowserReplay, type BrowserReplayOptions, type BrowserRuntimeInfo, type CandidateCompleteEvent, type CheckpointInfo, type CodexAgentPluginConfig, type DefaultBrowserConfig, type DownloadCheckpointOptions, type DownloadFilesOptions, type DownloadSessionOptions, type EmitOption, type EventHandler, type EventName, Evolve, type EvolveConfig, type EvolveEvents, type ExecuteCommandOptions, type FileMap, type FilterConfig, type FilterParams, type GeminiAgentPluginConfig, type GetEventsOptions, type IndexedMeta, type IntegrationAccount, type IntegrationAccountDeleteParams, type IntegrationAccountDeleteResult, type IntegrationAccountListParams, type IntegrationAccountUpdateParams, type IntegrationAccountUpdateResult, type IntegrationAuthParams, type IntegrationAuthResult, type IntegrationToolsFilter, type IntegrationsConfig, type IntegrationsSetup, type ItemInput, type ItemRetryEvent, JUDGE_PROMPT, type JsonSchema, type JudgeCompleteEvent, type JudgeDecision, type JudgeMeta, type LifecycleEvent, type LifecycleReason, type ListSessionsOptions, type ManagedBrowserProvider, type MapConfig, type MapParams, type MarketplaceAgentPluginConfig, type McpConfigInfo, type McpServerConfig, type ModelInfo, type OnCandidateCompleteCallback, type OnItemRetryCallback, type OnJudgeCompleteCallback, type OnVerifierCompleteCallback, type OnWorkerCompleteCallback, type OperationType, type OutputEvent, type OutputResult, Pipeline, type PipelineContext, type PipelineEventMap, type PipelineEvents, type PipelineResult, type ProcessInfo, type Prompt, type PromptFn, RETRY_FEEDBACK_PROMPT, type ReasoningEffort, type ReduceConfig, type ReduceMeta, type ReduceParams, type ReduceResult, type ResolvedStorageConfig, type RetryConfig, type RunCost, type RunOptions, SCHEMA_PROMPT, SWARM_RESULT_BRAND, SYSTEM_PROMPT, type SandboxCommandHandle, type SandboxCommandResult, type SandboxCommands, type SandboxCreateOptions, type SandboxFiles, type SandboxInstance, type SandboxLifecycleState, type SandboxProvider, type SandboxRunOptions, type SandboxSpawnOptions, type SchemaValidationOptions, Semaphore, type SessionCost, type SessionEvent, type SessionInfo, type SessionPage, type SessionStatus, type SessionsClient, type SessionsConfig, type SkillName, type SkillsConfig, type StepCompleteEvent, type StepErrorEvent, type StepEvent, type StepResult, type StepStartEvent, type StorageClient, type StorageConfig, type StreamCallbacks, Swarm, type SwarmConfig, type SwarmResult, SwarmResultList, TerminalPipeline, VALIDATION_PRESETS, VERIFY_PROMPT, type ValidationMode, type VerifierCompleteEvent, type VerifyConfig, type VerifyDecision, type VerifyInfo, type VerifyMeta, WORKSPACE_PROMPT, WORKSPACE_SWE_PROMPT, type WorkerCompleteEvent, type WorkspaceMode, applyTemplate, browserCredentials, browserProfiles, buildWorkerSystemPrompt, createAgentParser, createClaudeParser, createCodexParser, createDroidParser, createGeminiParser, executeWithRetry, expandPath, getAgentConfig, getMcpSettingsDir, getMcpSettingsPath, isValidAgentType, isZodSchema, jsonSchemaToString, parseNdjsonLine, parseNdjsonOutput, parseQwenOutput, readLocalDir, resolveStorageConfig, saveLocalDir, sessions, storage, writeClaudeMcpConfig, writeCodexMcpConfig, writeDroidGatewaySettings, writeDroidMcpConfig, writeGeminiMcpConfig, writeMcpConfig, writeQwenMcpConfig, zodSchemaToJson };
+/**
+ * A typed failure from the hosted evals API.
+ *
+ * `message` is the server's own product sentence and `code` is the stable
+ * machine-readable identifier, so callers branch on codes and never on English.
+ * `code` is typed as the closed HostedErrorCode union (widened to string for
+ * forward compatibility with a newer server), which is what makes a typo like
+ * `insufficient_creidts` a compile error instead of a branch that never runs.
+ *
+ * `param` and `details` are the machine-readable half of the refusal:
+ *
+ *   catch (err) {
+ *     if (err instanceof EvolveApiError && err.code === "provider_unsupported") {
+ *       // every refused task WITH its reason — not a sentence to regex
+ *       const refused = err.details?.refused_tasks as { task_name: string }[];
+ *     }
+ *   }
+ *
+ * The server truncates the MESSAGE when a list is long and never truncates
+ * `details`, so the data is always complete even when the sentence says
+ * "and 8 more".
+ */
+declare class EvolveApiError extends Error {
+    /** HTTP status of the failed response */
+    readonly status: number;
+    /** Stable snake_case error code from the API ("unknown_error" when absent) */
+    readonly code: HostedErrorCode | "unknown_error" | (string & {});
+    /**
+     * The input field this refusal is about — a body path ("agents[0].name"),
+     * a query parameter ("limit"), or a multipart part name ("run_command").
+     * Undefined when the failure is not about a particular field.
+     */
+    readonly param?: string;
+    /** The complete machine-readable data behind the message. Never truncated. */
+    readonly details?: Record<string, unknown>;
+    /**
+     * Seconds to wait before retrying (429/503). Read from the body first and the
+     * Retry-After header second, because a browser fetch cannot always see the
+     * header on a cross-origin response.
+     */
+    readonly retryAfterSec?: number;
+    /** Server-side id for this failure; the string to quote in a support thread. */
+    readonly requestId?: string;
+    constructor(status: number, code: string, message: string, extra?: {
+        param?: string;
+        details?: Record<string, unknown>;
+        retryAfterSec?: number;
+        requestId?: string;
+    });
+    /** True when this code is one this SDK version knows about. */
+    isKnownCode(): boolean;
+}
+/**
+ * Thrown by datasets().getActive() when the named dataset exists but has no
+ * active version, so there is no runnable version to resolve. Use get() to
+ * inspect a dataset that may not have an active version yet.
+ */
+declare class NoActiveVersionError extends Error {
+    /** The dataset name that had no active version */
+    readonly dataset: string;
+    constructor(dataset: string);
+}
+/**
+ * Downloaded bytes did not match the digest the server stated for them.
+ *
+ * NOT an EvolveApiError: the request succeeded, so it gets its own type rather
+ * than an invented error code.
+ */
+declare class EvolveDigestMismatchError extends Error {
+    readonly expected: string;
+    readonly actual: string;
+    readonly name = "EvolveDigestMismatchError";
+    constructor(expected: string, actual: string);
+}
+/**
+ * A download ended early: fewer bytes arrived than Content-Length promised.
+ *
+ * Its own type because a truncated body is not a wrong body — the distinction
+ * tells a caller whether to retry (yes) or to stop trusting the stored object
+ * (that is the digest error).
+ */
+declare class EvolveIncompleteDownloadError extends Error {
+    readonly expectedBytes: number;
+    readonly receivedBytes: number;
+    readonly name = "EvolveIncompleteDownloadError";
+    constructor(expectedBytes: number, receivedBytes: number);
+}
+/**
+ * Create a DatasetsClient for the shared dataset catalog.
+ *
+ * Requires EVOLVE_API_KEY (or { apiKey } in config).
+ *
+ * @example
+ * ```ts
+ * import { datasets } from "@evolvingmachines/sdk";
+ *
+ * const d = datasets();
+ * const catalog = await d.list();
+ * const deepSwe = await d.get("deep-swe@1.1");
+ * ```
+ */
+declare function datasets(config?: HostedClientConfig): DatasetsClient;
+/**
+ * Create an AgentsClient for the caller's own private registered agents.
+ *
+ * Register an agent once, then name it in job `agents[].name` exactly
+ * like a built-in. Requires EVOLVE_API_KEY (or { apiKey } in config).
+ *
+ * @example
+ * ```ts
+ * import { agents, jobs } from "@evolvingmachines/sdk";
+ *
+ * const registered = agents();
+ * await registered.create({
+ *   name: "acme-cli",
+ *   install_script: "curl -fsSL https://acme.dev/install.sh | sh",
+ *   run_command: "acme-cli --headless",
+ * });
+ *
+ * await jobs().start({
+ *   datasets: [{ name: "deep-swe" }],
+ *   agents: [{ name: "acme-cli", model_name: "gpt-5.5" }],
+ *   max_trial_spend_usd: 25,
+ * });
+ * ```
+ */
+declare function agents(config?: HostedClientConfig): AgentsClient;
+/**
+ * Create a JobsClient for hosted jobs.
+ *
+ * Requires EVOLVE_API_KEY (or { apiKey } in config).
+ *
+ * @example
+ * ```ts
+ * import { jobs } from "@evolvingmachines/sdk";
+ *
+ * const client = jobs();
+ * // datasets: bare name = active version; { name, version } pins one
+ * const job = await client.start({
+ *   datasets: [{ name: "deep-swe" }],
+ *   agents: [{ name: "codex", model_name: "gpt-5.5" }],
+ *   n_attempts: 1,
+ *   n_concurrent_trials: 4,
+ *   max_trial_spend_usd: 25,
+ * });
+ * const final = await client.watch(job.id, {
+ *   onEvent: (event) => console.log(event.type, event.data),
+ * });
+ * ```
+ */
+declare function jobs(config?: HostedClientConfig): JobsClient;
+/**
+ * Create a TrialsClient. A trial id is globally addressable — no method here
+ * takes a job id; the trial body carries `job_id` as the reverse pointer.
+ *
+ * Requires EVOLVE_API_KEY (or { apiKey } in config).
+ */
+declare function trials(config?: HostedClientConfig): TrialsClient;
+/**
+ * Create an AuthClient for caller identity.
+ *
+ * Requires EVOLVE_API_KEY (or { apiKey } in config).
+ */
+declare function auth(config?: HostedClientConfig): AuthClient;
+/**
+ * The hosted surface, configured once.
+ *
+ * The four factories are the right decomposition — a dataset catalog, your own
+ * agent registrations, jobs, and globally addressable trials are genuinely
+ * different lifetimes — but they made you say the same thing four times:
+ *
+ *   const d = datasets({ apiKey, baseUrl });
+ *   const a = agents({ apiKey, baseUrl });     // again
+ *   const j = jobs({ apiKey, baseUrl });       // and again
+ *
+ * and any one of those going out of sync with the others is a bug that looks
+ * like a permissions problem. One door, one config:
+ *
+ *   const evolve = hosted({ apiKey });
+ *   const catalog = await evolve.datasets.list();
+ *   const job = await evolve.jobs.start({ ... });
+ *
+ * The clients are built LAZILY, on first access. That matters because they
+ * throw when no API key is present, and `meta()` needs no key at all — so
+ * `hosted().meta()` works on a signed-out page, while `hosted().jobs` still
+ * fails loudly and immediately the moment you reach for something that does
+ * need credentials.
+ */
+interface HostedEvolve {
+    /** The dataset catalog: list, get, publish, download, delete. */
+    readonly datasets: DatasetsClient;
+    /** Your own bring-your-own agent registrations. */
+    readonly agents: AgentsClient;
+    /** Jobs: start, watch, compare, resume, regrade, download. */
+    readonly jobs: JobsClient;
+    /** Globally addressable trials: get, trace, artifact, regrade, stop. */
+    readonly trials: TrialsClient;
+    /**
+     * The capability document — every agent, provider, status, limit, and
+     * error code the platform supports. Public: no API key required.
+     *
+     * Fetch it once and stop hardcoding. It is what tells you the legal agent
+     * names without having to send a bad one and read the 400.
+     */
+    meta(): Promise<CapabilityDocument>;
+}
+/**
+ * Open the hosted surface with one configuration.
+ *
+ * Named `hosted()` rather than `evolve()` deliberately: `Evolve` is already the
+ * local-sandbox SDK class in this same package, and two exports one shift key
+ * apart that do completely different things is a trap. `hosted()` says which
+ * half of the SDK you are reaching for.
+ *
+ * @example
+ * ```ts
+ * import { hosted } from "@evolvingmachines/sdk";
+ *
+ * const evolve = hosted();                    // EVOLVE_API_KEY from env
+ * const { agents } = await evolve.meta();     // no key needed for this one
+ * const job = await evolve.jobs.start({
+ *   datasets: [{ name: "deep-swe" }],
+ *   agents: [{ name: "claude", model_name: "claude-fable-5" }],
+ * });
+ * ```
+ */
+declare function hosted(config?: HostedClientConfig): HostedEvolve;
+/**
+ * Fetch the capability document.
+ *
+ * NO API KEY. The document is the same information the docs publish, and
+ * requiring credentials would mean a signed-out page could not populate its own
+ * agent picker — so this is the one hosted call that takes only a base URL.
+ */
+declare function meta(config?: HostedClientConfig): Promise<CapabilityDocument>;
+
+export { AGENT_REGISTRY, AGENT_TYPES, type ActionbookBrowserConfig, Agent, type AgentBrowserConfig, type AgentConfig, type AgentError, type AgentOptions, type AgentOverride, type AgentParser, type AgentPluginConfig, type AgentRegistryEntry, type AgentResponse, type AgentRuntimeState, type AgentType, AgentsClient, AuthClient, BINARY_EFFORT_VALUES, BROWSER_ACTIONBOOK_PROMPT, BROWSER_LOGIN_MCP_SERVER_NAME, type BaseMeta, type BestOfConfig, type BestOfParams, type BestOfResult, type BrowserConfig, type BrowserCredentialCreateInput, type BrowserCredentialDeleteInput, type BrowserCredentialListOptions, type BrowserCredentialMetadata, type BrowserCredentialScopeEntry, BrowserCredentialsClient, type BrowserCredentialsClientConfig, type BrowserCredentialsConfig, type BrowserProfileDeleteInput, type BrowserProfileMetadata, BrowserProfilesClient, type BrowserProfilesClientConfig, type BrowserProvider, type BrowserReplay, type BrowserReplayOptions, type BrowserRuntimeInfo, type CandidateCompleteEvent, CapabilityDocument, type CheckpointInfo, type CodexAgentPluginConfig, DEFAULT_REASONING_EFFORT, DatasetsClient, type DefaultBrowserConfig, type DownloadCheckpointOptions, type DownloadFilesOptions, type DownloadSessionOptions, type EffortSupport, type EmitOption, type EventHandler, type EventName, Evolve, EvolveApiError, type EvolveConfig, EvolveConfigError, EvolveDigestMismatchError, type EvolveEvents, EvolveIncompleteDownloadError, type ExecuteCommandOptions, type ExternalGatewayConfig, type FileMap, type FilterConfig, type FilterParams, type GeminiAgentPluginConfig, type GetEventsOptions, HostedClientConfig, HostedErrorCode, type HostedEvolve, type IndexedMeta, type IntegrationAccount, type IntegrationAccountDeleteParams, type IntegrationAccountDeleteResult, type IntegrationAccountListParams, type IntegrationAccountUpdateParams, type IntegrationAccountUpdateResult, type IntegrationAuthParams, type IntegrationAuthResult, type IntegrationToolsFilter, type IntegrationsConfig, type IntegrationsSetup, type ItemInput, type ItemRetryEvent, JUDGE_PROMPT, JobsClient, type JsonSchema, type JudgeCompleteEvent, type JudgeDecision, type JudgeMeta, type LifecycleEvent, type LifecycleReason, type ListSessionsOptions, MANAGED_SANDBOX_PROVIDERS, type ManagedBrowserProvider, type ManagedSandboxCreateDefaults, type ManagedSandboxOptions, type ManagedSandboxProviderName, type ManagedSecretMetadata, type ManagedSecretRef, type ManagedSecretsClient, type ManagedSecretsClientConfig, type MapConfig, type MapParams, type MarketplaceAgentPluginConfig, type McpConfigInfo, type McpServerConfig, type ModelInfo, NoActiveVersionError, type OnCandidateCompleteCallback, type OnItemRetryCallback, type OnJudgeCompleteCallback, type OnVerifierCompleteCallback, type OnWorkerCompleteCallback, type OperationType, type OutputEvent, type OutputResult, Pipeline, type PipelineContext, type PipelineEventMap, type PipelineEvents, type PipelineResult, type ProcessInfo, type Prompt, type PromptFn, REASONING_EFFORTS, RETRY_FEEDBACK_PROMPT, type ReasoningEffort, type ReduceConfig, type ReduceMeta, type ReduceParams, type ReduceResult, type ResolvedStorageConfig, type RetryConfig, type RunCost, type RunOptions, SCHEMA_PROMPT, SWARM_RESULT_BRAND, SYSTEM_PROMPT, type SandboxCommandHandle, type SandboxCommandResult, type SandboxCommands, type SandboxCreateOptions, type SandboxFiles, type SandboxInstance, type SandboxLifecycleState, type SandboxNetworkPolicy, type SandboxProvider, type SandboxRunOptions, type SandboxSpawnOptions, type SchemaValidationOptions, Semaphore, type SessionCost, type SessionEvent, type SessionInfo, type SessionPage, type SessionStatus, type SessionUpdate, type SessionsClient, type SessionsConfig, type SkillName, type SkillsConfig, type StepCompleteEvent, type StepErrorEvent, type StepEvent, type StepResult, type StepStartEvent, type StorageClient, type StorageConfig, type StreamCallbacks, Swarm, type SwarmConfig, type SwarmResult, SwarmResultList, TerminalPipeline, TrialsClient, VALIDATION_PRESETS, VERIFY_PROMPT, type ValidationMode, type VerifierCompleteEvent, type VerifyConfig, type VerifyDecision, type VerifyInfo, type VerifyMeta, WORKSPACE_PROMPT, WORKSPACE_SWE_PROMPT, type WorkerCompleteEvent, type WorkspaceMode, agents, applyTemplate, auth, browserCredentials, browserProfiles, buildWorkerSystemPrompt, createAgentParser, createClaudeParser, createCodexParser, createDroidParser, createGeminiParser, datasets, executeWithRetry, expandPath, getAgentConfig, getMcpSettingsDir, getMcpSettingsPath, harnessEffortVocabulary, hosted, isAgentWorkUpdate, isValidAgentType, isZodSchema, jobs, jsonSchemaToString, managedSandbox, managedSecrets, meta, parseNdjsonLine, parseNdjsonOutput, parseQwenOutput, readLocalDir, resolveStorageConfig, saveLocalDir, sessions, storage, trials, writeClaudeMcpConfig, writeCodexMcpConfig, writeDroidGatewaySettings, writeDroidMcpConfig, writeGeminiMcpConfig, writeMcpConfig, writeQwenMcpConfig, zodSchemaToJson };