@ai-sdk/harness 1.0.132 → 1.0.134

package/dist/agent/index.d.ts

@@ -1,10 +1,9 @@
-import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Experimental_SandboxSession, UserModelMessage, ToolResultPart, ProviderOptions, ToolSet, FlexibleSchema, Tool, Context, InferToolSetContext, SystemModelMessage, MaybePromiseLike, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
-import { ToolsContextSettings } from 'ai/internal';
-import { OutputInterface, AgentCallParameters, Prompt, StopCondition, GenerateTextOnStartCallback, GenerateTextOnStepStartCallback, OnLanguageModelCallStartCallback, OnLanguageModelCallEndCallback, OnToolExecutionStartCallback, OnToolExecutionEndCallback, GenerateTextOnStepEndCallback, GenerateTextOnEndCallback, ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
-import { z } from 'zod/v4';
-import { JSONSchema7, JSONValue, LanguageModelV4StreamPart, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, AISDKError } from '@ai-sdk/provider';
-
+import { AISDKError, JSONSchema7, JSONValue, LanguageModelV4CustomPart, LanguageModelV4FilePart, LanguageModelV4FinishReason, LanguageModelV4ReasoningFilePart, LanguageModelV4ReasoningPart, LanguageModelV4StreamPart, LanguageModelV4TextPart, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolApprovalResponsePart, LanguageModelV4ToolCall, LanguageModelV4ToolCallPart, LanguageModelV4ToolResult, LanguageModelV4ToolResultOutput, LanguageModelV4ToolResultPart, LanguageModelV4Usage } from "@ai-sdk/provider";
+import { Arrayable, Context, Experimental_SandboxSession, FlexibleSchema, InferToolSetContext, MaybePromiseLike, ModelMessage, ProviderOptions, SystemModelMessage, Tool, ToolApprovalResponse, ToolResultPart, ToolSet, UserModelMessage } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { ToolsContextSettings } from "ai/internal";
+import { ActiveTools, Agent, AgentCallParameters, AgentStreamParameters, GenerateTextOnEndCallback, GenerateTextOnStartCallback, GenerateTextOnStepEndCallback, GenerateTextOnStepStartCallback, GenerateTextResult, OnLanguageModelCallEndCallback, OnLanguageModelCallStartCallback, OnToolExecutionEndCallback, OnToolExecutionStartCallback, OutputInterface, Prompt, StopCondition, StreamTextResult, Telemetry, TelemetryOptions, ToolApprovalStatus } from "ai";
+//#region src/v1/harness-v1-bootstrap.d.ts
 /**
  * One file to write into the sandbox as part of an adapter's bootstrap recipe.
  * Absolute paths are used as-is. Relative paths are resolved against the
@@ -12,8 +11,8 @@ import { JSONSchema7, JSONValue, LanguageModelV4StreamPart, LanguageModelV4ToolC
  * {@link HarnessV1Bootstrap.bootstrapDir}.
  */
 interface HarnessV1BootstrapFile {
-    readonly path: string;
-    readonly content: string;
+  readonly path: string;
+  readonly content: string;
 }
 /**
  * One command to run in the sandbox as part of an adapter's bootstrap recipe.
@@ -21,7 +20,7 @@ interface HarnessV1BootstrapFile {
  * aborts the bootstrap.
  */
 interface HarnessV1BootstrapCommand {
-    readonly command: string;
+  readonly command: string;
 }
 /**
  * Adapter-owned bootstrap recipe. The adapter declares the files and commands
@@ -30,32 +29,33 @@ interface HarnessV1BootstrapCommand {
  * reuse, and applies the recipe idempotently before the bridge spawns.
  */
 interface HarnessV1Bootstrap {
-    /**
-     * Stable id of the adapter that owns this recipe. Conventionally matches
-     * {@link HarnessV1.harnessId}. Contributes to the recipe hash.
-     */
-    readonly harnessId: string;
-    /**
-     * Path inside the sandbox where this recipe writes its state. Absolute paths
-     * are used as-is. Relative paths are resolved against the harness state
-     * directory (`$HOME/.ai-sdk-harness`). The marker file lives directly under
-     * it. Files declared in {@link files} should also use this prefix so an
-     * adapter upgrade can sweep stale state by clearing the directory.
-     */
-    readonly bootstrapDir: string;
-    /** Files to write into the sandbox before any command runs. */
-    readonly files: ReadonlyArray<HarnessV1BootstrapFile>;
-    /** Commands to run from the bootstrap directory after files are written. */
-    readonly commands: ReadonlyArray<HarnessV1BootstrapCommand>;
+  /**
+   * Stable id of the adapter that owns this recipe. Conventionally matches
+   * {@link HarnessV1.harnessId}. Contributes to the recipe hash.
+   */
+  readonly harnessId: string;
+  /**
+   * Path inside the sandbox where this recipe writes its state. Absolute paths
+   * are used as-is. Relative paths are resolved against the harness state
+   * directory (`$HOME/.ai-sdk-harness`). The marker file lives directly under
+   * it. Files declared in {@link files} should also use this prefix so an
+   * adapter upgrade can sweep stale state by clearing the directory.
+   */
+  readonly bootstrapDir: string;
+  /** Files to write into the sandbox before any command runs. */
+  readonly files: ReadonlyArray<HarnessV1BootstrapFile>;
+  /** Commands to run from the bootstrap directory after files are written. */
+  readonly commands: ReadonlyArray<HarnessV1BootstrapCommand>;
 }
-
+//#endregion
+//#region src/v1/harness-v1-network-sandbox-session.d.ts
 /**
  * Connection details for a sandbox-exposed port. Headers are scoped to the
  * returned URL and must be included when opening the connection.
  */
 type HarnessV1PortEndpoint = {
-    readonly url: string;
-    readonly headers?: Readonly<Record<string, string>>;
+  readonly url: string;
+  readonly headers?: Readonly<Record<string, string>>;
 };
 /**
  * Network sandbox session returned by sandbox adapter creation and resume
@@ -69,94 +69,94 @@ type HarnessV1PortEndpoint = {
  * network access, or transform requests.
  */
 interface HarnessV1NetworkSandboxSession extends Experimental_SandboxSession {
-    /**
-     * Identifier for the sandbox session. Persist this separately from the
-     * harness session ID and resume state when reattaching across processes.
-     */
-    readonly id: string;
-    /**
-     * The sandbox's default working directory — the absolute path that
-     * `run`/`spawn` resolve relative commands against when no `workingDirectory`
-     * is given. Read from the live sandbox, never hardcoded.
-     *
-     * The framework composes each session's working directory underneath this
-     * path (`<defaultWorkingDirectory>/<harnessId>-<sessionId>`) so adapters do
-     * not bake a provider-specific base into their own paths.
-     */
-    readonly defaultWorkingDirectory: string;
-    /** Ports the sandbox exposes; resolvable via `getPortEndpoint`. */
-    readonly ports: ReadonlyArray<number>;
-    /**
-     * Resolve the connection details for a sandbox-exposed port. Bridge-backed
-     * adapters call this to open their WebSocket to the in-sandbox bridge.
-     */
-    readonly getPortEndpoint: (options: {
-        port: number;
-        protocol?: 'http' | 'https' | 'ws';
-    }) => PromiseLike<HarnessV1PortEndpoint>;
-    /**
-     * Resolve a publicly-reachable URL for a sandbox-exposed port.
-     *
-     * @deprecated Use `getPortEndpoint` instead.
-     */
-    readonly getPortUrl: (options: {
-        port: number;
-        protocol?: 'http' | 'https' | 'ws';
-    }) => PromiseLike<string>;
-    /** Stop the sandbox. Idempotent. */
-    readonly stop: () => PromiseLike<void>;
-    /**
-     * Stop the sandbox session, then perform any additional cleanup necessary
-     * to destroy it, such as deleting its backing resource or freeing resources.
-     * Implementations with no cleanup beyond stopping may delegate to `stop()`.
-     * Implementations must handle both a still-running sandbox and a previously
-     * stopped sandbox.
-     */
-    readonly destroy: () => PromiseLike<void>;
-    /**
-     * Update the sandbox's outbound network policy. Optional — implementations
-     * without a local enforcement primitive omit this. Callers
-     * use optional-call (`sandboxSession.setNetworkPolicy?.(policy)`); a
-     * missing implementation is a no-op.
-     */
-    readonly setNetworkPolicy?: (policy: HarnessV1NetworkPolicy) => PromiseLike<void>;
-    /**
-     * Replace the sandbox's outbound request-transformation rules. Optional —
-     * implementations expose this only when credentials can be injected outside
-     * the sandbox security boundary. Calling this method assumes authority over
-     * the complete transformation set; harness adapters should normally use
-     * `addRequestTransformations` instead. Adapters may preserve legacy
-     * credential-forwarding behavior when additive request transformations are
-     * unavailable.
-     */
-    readonly setRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
-    /**
-     * Add outbound request-transformation rules without replacing rules already
-     * managed by the sandbox session. Optional for the same reason as
-     * `setRequestTransformations`. Harness adapters should use this additive
-     * capability unless they explicitly own the complete transformation set.
-     */
-    readonly addRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
-    /**
-     * Replace the set of ports exposed by the sandbox. Full-replacement
-     * semantics: ports omitted from the array are deregistered. Optional —
-     * implementations that cannot expose ports omit this.
-     */
-    readonly setPorts?: (ports: ReadonlyArray<number>, options?: {
-        abortSignal?: AbortSignal;
-    }) => PromiseLike<void>;
-    /**
-     * Reduced view of this session, typed as the bare {@link SandboxSession}
-     * (file I/O, exec, spawn) — nothing that could stop the sandbox or change
-     * its network policy. Pass this to user-tool `execute()` calls and other
-     * code that must not reach the infra surface.
-     *
-     * The returned object points at exactly the same underlying sandbox
-     * resource as the network sandbox session it was produced from; it is only a
-     * narrower surface over the same resource, not a separate sandbox. In
-     * particular, it cannot mutate network access or request transformations.
-     */
-    readonly restricted: () => Experimental_SandboxSession;
+  /**
+   * Identifier for the sandbox session. Persist this separately from the
+   * harness session ID and resume state when reattaching across processes.
+   */
+  readonly id: string;
+  /**
+   * The sandbox's default working directory — the absolute path that
+   * `run`/`spawn` resolve relative commands against when no `workingDirectory`
+   * is given. Read from the live sandbox, never hardcoded.
+   *
+   * The framework composes each session's working directory underneath this
+   * path (`<defaultWorkingDirectory>/<harnessId>-<sessionId>`) so adapters do
+   * not bake a provider-specific base into their own paths.
+   */
+  readonly defaultWorkingDirectory: string;
+  /** Ports the sandbox exposes; resolvable via `getPortEndpoint`. */
+  readonly ports: ReadonlyArray<number>;
+  /**
+   * Resolve the connection details for a sandbox-exposed port. Bridge-backed
+   * adapters call this to open their WebSocket to the in-sandbox bridge.
+   */
+  readonly getPortEndpoint: (options: {
+    port: number;
+    protocol?: 'http' | 'https' | 'ws';
+  }) => PromiseLike<HarnessV1PortEndpoint>;
+  /**
+   * Resolve a publicly-reachable URL for a sandbox-exposed port.
+   *
+   * @deprecated Use `getPortEndpoint` instead.
+   */
+  readonly getPortUrl: (options: {
+    port: number;
+    protocol?: 'http' | 'https' | 'ws';
+  }) => PromiseLike<string>;
+  /** Stop the sandbox. Idempotent. */
+  readonly stop: () => PromiseLike<void>;
+  /**
+   * Stop the sandbox session, then perform any additional cleanup necessary
+   * to destroy it, such as deleting its backing resource or freeing resources.
+   * Implementations with no cleanup beyond stopping may delegate to `stop()`.
+   * Implementations must handle both a still-running sandbox and a previously
+   * stopped sandbox.
+   */
+  readonly destroy: () => PromiseLike<void>;
+  /**
+   * Update the sandbox's outbound network policy. Optional — implementations
+   * without a local enforcement primitive omit this. Callers
+   * use optional-call (`sandboxSession.setNetworkPolicy?.(policy)`); a
+   * missing implementation is a no-op.
+   */
+  readonly setNetworkPolicy?: (policy: HarnessV1NetworkPolicy) => PromiseLike<void>;
+  /**
+   * Replace the sandbox's outbound request-transformation rules. Optional —
+   * implementations expose this only when credentials can be injected outside
+   * the sandbox security boundary. Calling this method assumes authority over
+   * the complete transformation set; harness adapters should normally use
+   * `addRequestTransformations` instead. Adapters may preserve legacy
+   * credential-forwarding behavior when additive request transformations are
+   * unavailable.
+   */
+  readonly setRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
+  /**
+   * Add outbound request-transformation rules without replacing rules already
+   * managed by the sandbox session. Optional for the same reason as
+   * `setRequestTransformations`. Harness adapters should use this additive
+   * capability unless they explicitly own the complete transformation set.
+   */
+  readonly addRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
+  /**
+   * Replace the set of ports exposed by the sandbox. Full-replacement
+   * semantics: ports omitted from the array are deregistered. Optional —
+   * implementations that cannot expose ports omit this.
+   */
+  readonly setPorts?: (ports: ReadonlyArray<number>, options?: {
+    abortSignal?: AbortSignal;
+  }) => PromiseLike<void>;
+  /**
+   * Reduced view of this session, typed as the bare {@link SandboxSession}
+   * (file I/O, exec, spawn) — nothing that could stop the sandbox or change
+   * its network policy. Pass this to user-tool `execute()` calls and other
+   * code that must not reach the infra surface.
+   *
+   * The returned object points at exactly the same underlying sandbox
+   * resource as the network sandbox session it was produced from; it is only a
+   * narrower surface over the same resource, not a separate sandbox. In
+   * particular, it cannot mutate network access or request transformations.
+   */
+  readonly restricted: () => Experimental_SandboxSession;
 }
 /**
  * Outbound network policy applied by the sandbox runtime.
@@ -174,37 +174,37 @@ interface HarnessV1NetworkSandboxSession extends Experimental_SandboxSession {
  * equivalent to `'deny-all'`.
  */
 type HarnessV1NetworkPolicy = {
-    mode: 'allow-all';
+  mode: 'allow-all';
 } | {
-    mode: 'deny-all';
+  mode: 'deny-all';
 } | {
-    mode: 'custom';
-    allowedHosts: ReadonlyArray<string>;
-    allowedCIDRs?: ReadonlyArray<string>;
-    deniedCIDRs?: ReadonlyArray<string>;
+  mode: 'custom';
+  allowedHosts: ReadonlyArray<string>;
+  allowedCIDRs?: ReadonlyArray<string>;
+  deniedCIDRs?: ReadonlyArray<string>;
 } | {
-    mode: 'custom';
-    allowedHosts?: ReadonlyArray<string>;
-    allowedCIDRs: ReadonlyArray<string>;
-    deniedCIDRs?: ReadonlyArray<string>;
+  mode: 'custom';
+  allowedHosts?: ReadonlyArray<string>;
+  allowedCIDRs: ReadonlyArray<string>;
+  deniedCIDRs?: ReadonlyArray<string>;
 };
 type HarnessV1RequestTransformationPathMatcher = {
-    exact: string;
+  exact: string;
 } | {
-    startsWith: string;
+  startsWith: string;
 } | {
-    regex: string;
+  regex: string;
 };
 type HarnessV1RequestTransformationKeyValuePartMatcher = {
-    exact: string;
+  exact: string;
 } | {
-    startsWith: string;
+  startsWith: string;
 } | {
-    regex: string;
+  regex: string;
 };
 type HarnessV1RequestTransformationKeyValueMatcher = {
-    readonly key?: HarnessV1RequestTransformationKeyValuePartMatcher;
-    readonly value?: HarnessV1RequestTransformationKeyValuePartMatcher;
+  readonly key?: HarnessV1RequestTransformationKeyValuePartMatcher;
+  readonly value?: HarnessV1RequestTransformationKeyValuePartMatcher;
 };
 /**
  * Outbound HTTPS request transformation applied outside the sandbox security
@@ -218,25 +218,26 @@ type HarnessV1RequestTransformationKeyValueMatcher = {
  * making transformed values available inside it.
  */
 type HarnessV1RequestTransformation = {
-    readonly match: {
-        readonly host: string;
-        readonly path?: HarnessV1RequestTransformationPathMatcher;
-        readonly method?: ReadonlyArray<string>;
-        readonly queryString?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
-        readonly headers?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
-    };
-    readonly transform: {
-        readonly headers: Readonly<Record<string, string>>;
-    };
+  readonly match: {
+    readonly host: string;
+    readonly path?: HarnessV1RequestTransformationPathMatcher;
+    readonly method?: ReadonlyArray<string>;
+    readonly queryString?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
+    readonly headers?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
+  };
+  readonly transform: {
+    readonly headers: Readonly<Record<string, string>>;
+  };
 };
-
+//#endregion
+//#region src/v1/harness-v1-diagnostic.d.ts
 /** Severity of a diagnostic, ordered most → least severe. */
 declare const harnessV1DebugLevelSchema: z.ZodEnum<{
-    error: "error";
-    warn: "warn";
-    info: "info";
-    debug: "debug";
-    trace: "trace";
+  error: "error";
+  warn: "warn";
+  info: "info";
+  debug: "debug";
+  trace: "trace";
 }>;
 type HarnessV1DebugLevel = z.infer<typeof harnessV1DebugLevelSchema>;
 /**
@@ -246,15 +247,15 @@ type HarnessV1DebugLevel = z.infer<typeof harnessV1DebugLevelSchema>;
  * prefix; console capture is independent of the subsystem filter.
  */
 declare const harnessV1DebugConfigSchema: z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    level: z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        warn: "warn";
-        info: "info";
-        debug: "debug";
-        trace: "trace";
-    }>>;
-    subsystems: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  level: z.ZodOptional<z.ZodEnum<{
+    error: "error";
+    warn: "warn";
+    info: "info";
+    debug: "debug";
+    trace: "trace";
+  }>>;
+  subsystems: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 type HarnessV1DebugConfig = z.infer<typeof harnessV1DebugConfigSchema>;
 /**
@@ -263,32 +264,33 @@ type HarnessV1DebugConfig = z.infer<typeof harnessV1DebugConfigSchema>;
  * emission shape, that is the external consumption shape.
  */
 type HarnessV1Diagnostic = {
-    /** Severity. */
-    readonly level: HarnessV1DebugLevel;
-    /** Human-readable line (console capture) or message (structured event). */
-    readonly message: string;
-    /** Dotted subsystem (`sandbox.log.<source>` for console capture). */
-    readonly subsystem: string;
-    /** `'log'` = captured console line; `'event'` = structured emission. */
-    readonly kind: 'log' | 'event';
-    /** Originating source label (console capture). */
-    readonly source?: string;
-    /** Which standard stream the line came from (console capture). */
-    readonly stream?: 'stdout' | 'stderr';
-    /** Structured attributes (structured events only). */
-    readonly attrs?: Record<string, unknown>;
-    /** Error payload (structured events only). */
-    readonly error?: {
-        name?: string;
-        message: string;
-        stack?: string;
-    };
-    /** The harness session this diagnostic originated from. */
-    readonly sessionId?: string;
-    /** Emission time (epoch ms). */
-    readonly timestamp: number;
+  /** Severity. */
+  readonly level: HarnessV1DebugLevel;
+  /** Human-readable line (console capture) or message (structured event). */
+  readonly message: string;
+  /** Dotted subsystem (`sandbox.log.<source>` for console capture). */
+  readonly subsystem: string;
+  /** `'log'` = captured console line; `'event'` = structured emission. */
+  readonly kind: 'log' | 'event';
+  /** Originating source label (console capture). */
+  readonly source?: string;
+  /** Which standard stream the line came from (console capture). */
+  readonly stream?: 'stdout' | 'stderr';
+  /** Structured attributes (structured events only). */
+  readonly attrs?: Record<string, unknown>;
+  /** Error payload (structured events only). */
+  readonly error?: {
+    name?: string;
+    message: string;
+    stack?: string;
+  };
+  /** The harness session this diagnostic originated from. */
+  readonly sessionId?: string;
+  /** Emission time (epoch ms). */
+  readonly timestamp: number;
 };
-
+//#endregion
+//#region src/v1/harness-v1-observability.d.ts
 /**
  * Diagnostics wiring the framework hands to an adapter's `doStart`. `report` is
  * the general emission sink: a bridge adapter normalizes each wire frame into a
@@ -298,12 +300,13 @@ type HarnessV1Diagnostic = {
  * Absent when the consumer has not enabled diagnostics.
  */
 type HarnessV1Observability = {
-    /** Per-session debug config gating what the adapter captures/emits. */
-    readonly debug?: HarnessV1DebugConfig;
-    /** General emission sink — any adapter reports a `HarnessV1Diagnostic` here. */
-    readonly report?: (diagnostic: HarnessV1Diagnostic) => void;
+  /** Per-session debug config gating what the adapter captures/emits. */
+  readonly debug?: HarnessV1DebugConfig;
+  /** General emission sink — any adapter reports a `HarnessV1Diagnostic` here. */
+  readonly report?: (diagnostic: HarnessV1Diagnostic) => void;
 };
-
+//#endregion
+//#region src/v1/harness-v1-permission-mode.d.ts
 /**
  * Baseline permission mode for adapter-native built-in tools.
  *
@@ -312,7 +315,8 @@ type HarnessV1Observability = {
  * status map.
  */
 type HarnessV1PermissionMode = 'allow-reads' | 'allow-edits' | 'allow-all';
-
+//#endregion
+//#region src/v1/harness-v1-prompt.d.ts
 /**
  * Prompt shape passed to `HarnessV1Session.doPromptTurn`.
  *
@@ -322,7 +326,8 @@ type HarnessV1PermissionMode = 'allow-reads' | 'allow-edits' | 'allow-all';
  * `UserModelMessage`.
  */
 type HarnessV1Prompt = string | UserModelMessage;
-
+//#endregion
+//#region src/v1/harness-v1-prompt-control.d.ts
 /**
  * Bidirectional control surface returned by `doPromptTurn`.
  *
@@ -333,41 +338,41 @@ type HarnessV1Prompt = string | UserModelMessage;
  * messages require `submitUserMessage`).
  */
 type HarnessV1PromptControl = {
-    /**
-     * Provide a result for a `tool-call` the adapter emitted. The adapter
-     * forwards the result to the underlying runtime so the model can continue.
-     */
-    submitToolResult(input: {
-        toolCallId: string;
-        output: unknown;
-        isError?: boolean;
-        toolResult?: ToolResultPart;
-    }): PromiseLike<void>;
-    /**
-     * Respond to a `tool-approval-request` the adapter emitted.
-     */
-    submitToolApproval?(input: {
-        approvalId: string;
-        approved: boolean;
-        reason?: string;
-    }): PromiseLike<void>;
-    /**
-     * Inject a fresh user message into a turn that is still in flight.
-     * Supported only by runtimes that accept interactive input.
-     */
-    submitUserMessage?(text: string): PromiseLike<void>;
-    /**
-     * Resolves when the adapter has finished the turn (success or failure).
-     * Rejects with the underlying error when the turn fails.
-     */
-    readonly done: PromiseLike<void>;
+  /**
+   * Provide a result for a `tool-call` the adapter emitted. The adapter
+   * forwards the result to the underlying runtime so the model can continue.
+   */
+  submitToolResult(input: {
+    toolCallId: string;
+    output: unknown;
+    isError?: boolean;
+    toolResult?: ToolResultPart;
+  }): PromiseLike<void>;
+  /**
+   * Respond to a `tool-approval-request` the adapter emitted.
+   */
+  submitToolApproval?(input: {
+    approvalId: string;
+    approved: boolean;
+    reason?: string;
+  }): PromiseLike<void>;
+  /**
+   * Inject a fresh user message into a turn that is still in flight.
+   * Supported only by runtimes that accept interactive input.
+   */
+  submitUserMessage?(text: string): PromiseLike<void>;
+  /**
+   * Resolves when the adapter has finished the turn (success or failure).
+   * Rejects with the underlying error when the turn fails.
+   */
+  readonly done: PromiseLike<void>;
 };
-
+//#endregion
+//#region src/v1/harness-v1-response-format.d.ts
 type HarnessV1JSONValue = null | boolean | number | string | HarnessV1JSONArray | HarnessV1JSONObject;
-interface HarnessV1JSONArray extends Array<HarnessV1JSONValue> {
-}
+interface HarnessV1JSONArray extends Array<HarnessV1JSONValue> {}
 interface HarnessV1JSONObject {
-    [key: string]: HarnessV1JSONValue | undefined;
+  [key: string]: HarnessV1JSONValue | undefined;
 }
 type HarnessV1JSONSchema = HarnessV1JSONObject;
 /**
@@ -379,46 +384,48 @@ type HarnessV1JSONSchema = HarnessV1JSONObject;
  * contract can cross process and package boundaries.
  */
 type HarnessV1ResponseFormat = {
-    readonly type: 'text';
+  readonly type: 'text';
 } | {
-    readonly type: 'json';
-    readonly schema?: HarnessV1JSONSchema;
-    readonly name?: string;
-    readonly description?: string;
+  readonly type: 'json';
+  readonly schema?: HarnessV1JSONSchema;
+  readonly name?: string;
+  readonly description?: string;
 };
-
+//#endregion
+//#region src/v1/harness-v1-skill.d.ts
 /**
  * A self-contained instruction bundle the underlying runtime can load into
  * its context. Adapters decide how to surface skills to the runtime.
  */
 type HarnessV1Skill = {
-    /** Stable identifier for the skill (kebab-case slug). */
-    readonly name: string;
-    /**
-     * Short, model-facing description. This is what the runtime sees to
-     * decide whether the skill is relevant.
-     */
-    readonly description: string;
-    /** Full skill content the model loads when the skill is active. */
-    readonly content: string;
-    /**
-     * Additional files that belong to this skill. Adapters with native skill
-     * directories materialize these next to `SKILL.md`; adapters without native
-     * skill files include them with the skill content.
-     */
-    readonly files?: ReadonlyArray<HarnessV1SkillFile>;
+  /** Stable identifier for the skill (kebab-case slug). */
+  readonly name: string;
+  /**
+   * Short, model-facing description. This is what the runtime sees to
+   * decide whether the skill is relevant.
+   */
+  readonly description: string;
+  /** Full skill content the model loads when the skill is active. */
+  readonly content: string;
+  /**
+   * Additional files that belong to this skill. Adapters with native skill
+   * directories materialize these next to `SKILL.md`; adapters without native
+   * skill files include them with the skill content.
+   */
+  readonly files?: ReadonlyArray<HarnessV1SkillFile>;
 };
 type HarnessV1SkillFile = {
-    /**
-     * Skill-relative POSIX path, for example `reference.md` or
-     * `references/codes.md`. Absolute paths and `..` segments are rejected by
-     * adapters before writing.
-     */
-    readonly path: string;
-    /** UTF-8 text content for the file. */
-    readonly content: string;
+  /**
+   * Skill-relative POSIX path, for example `reference.md` or
+   * `references/codes.md`. Absolute paths and `..` segments are rejected by
+   * adapters before writing.
+   */
+  readonly path: string;
+  /** UTF-8 text content for the file. */
+  readonly content: string;
 };
-
+//#endregion
+//#region src/v1/harness-v1-tool-spec.d.ts
 /**
  * Description of a host-defined tool that the harness should make available
  * to the underlying agent runtime.
@@ -430,43 +437,44 @@ type HarnessV1SkillFile = {
  * `submitToolResult` from the caller.
  */
 type HarnessV1ToolSpec = {
-    /**
-     * Tool name the agent runtime sees. Must match the name on incoming
-     * `tool-call` events.
-     */
-    readonly name: string;
-    /**
-     * Human-readable description handed to the runtime, used to help the model
-     * decide when to call the tool.
-     */
-    readonly description?: string;
-    /**
-     * JSON Schema describing the expected input for the tool. Optional because
-     * some runtimes accept tools without schemas (free-form arguments).
-     */
-    readonly inputSchema?: JSONSchema7;
+  /**
+   * Tool name the agent runtime sees. Must match the name on incoming
+   * `tool-call` events.
+   */
+  readonly name: string;
+  /**
+   * Human-readable description handed to the runtime, used to help the model
+   * decide when to call the tool.
+   */
+  readonly description?: string;
+  /**
+   * JSON Schema describing the expected input for the tool. Optional because
+   * some runtimes accept tools without schemas (free-form arguments).
+   */
+  readonly inputSchema?: JSONSchema7;
 };
-
+//#endregion
+//#region src/v1/harness-v1-lifecycle-state.d.ts
 type HarnessV1PendingToolApproval = {
-    readonly approvalId: string;
-    readonly toolCallId: string;
-    readonly toolName: string;
-    readonly input: string;
-    readonly kind: 'builtin' | 'custom';
-    readonly providerExecuted?: boolean;
-    readonly nativeName?: string;
+  readonly approvalId: string;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: string;
+  readonly kind: 'builtin' | 'custom';
+  readonly providerExecuted?: boolean;
+  readonly nativeName?: string;
 };
 type HarnessV1PendingToolResult = {
-    readonly toolCallId: string;
-    readonly toolName: string;
-    readonly input: string;
-    readonly providerOptions?: ProviderOptions;
-    /** Executed while suspending; submit on resume without running the tool again. */
-    readonly completedResult?: {
-        readonly output: unknown;
-        readonly isError?: boolean;
-        readonly toolResult?: ToolResultPart;
-    };
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: string;
+  readonly providerOptions?: ProviderOptions;
+  /** Executed while suspending; submit on resume without running the tool again. */
+  readonly completedResult?: {
+    readonly output: unknown;
+    readonly isError?: boolean;
+    readonly toolResult?: ToolResultPart;
+  };
 };
 /**
  * Framework-owned settings captured when a turn begins. The same settings are
@@ -474,47 +482,47 @@ type HarnessV1PendingToolResult = {
  * so a resumed continuation cannot pick up configuration from a later turn.
  */
 type HarnessV1TurnSettings = {
-    /**
-     * Model identifier selected for this turn. Adapters interpret this value
-     * according to the underlying harness runtime. Rerun-based continuations
-     * reuse it when reconstructing the turn.
-     */
-    readonly model?: string;
-    /**
-     * Skills made available to the underlying runtime for this turn. Adapters
-     * must replace skills from the preceding completed turn before starting a
-     * fresh turn. Rerun-based continuations use them to reconstruct the turn.
-     */
-    readonly skills: ReadonlyArray<HarnessV1Skill>;
-    /**
-     * Free-form instructions for this turn. Adapters should apply them through
-     * the runtime's native system or developer instruction mechanism when
-     * supported. Rerun-based continuations use them to reconstruct the turn.
-     */
-    readonly instructions?: string;
-    /**
-     * Host-defined tools made available to the underlying runtime for this turn.
-     * The harness emits `tool-call` events when the runtime calls one and waits
-     * for `submitToolResult`. Rerun-based continuations use them to reconstruct
-     * the turn.
-     */
-    readonly tools: ReadonlyArray<HarnessV1ToolSpec>;
+  /**
+   * Model identifier selected for this turn. Adapters interpret this value
+   * according to the underlying harness runtime. Rerun-based continuations
+   * reuse it when reconstructing the turn.
+   */
+  readonly model?: string;
+  /**
+   * Skills made available to the underlying runtime for this turn. Adapters
+   * must replace skills from the preceding completed turn before starting a
+   * fresh turn. Rerun-based continuations use them to reconstruct the turn.
+   */
+  readonly skills: ReadonlyArray<HarnessV1Skill>;
+  /**
+   * Free-form instructions for this turn. Adapters should apply them through
+   * the runtime's native system or developer instruction mechanism when
+   * supported. Rerun-based continuations use them to reconstruct the turn.
+   */
+  readonly instructions?: string;
+  /**
+   * Host-defined tools made available to the underlying runtime for this turn.
+   * The harness emits `tool-call` events when the runtime calls one and waits
+   * for `submitToolResult`. Rerun-based continuations use them to reconstruct
+   * the turn.
+   */
+  readonly tools: ReadonlyArray<HarnessV1ToolSpec>;
 };
 type HarnessV1LifecycleStateBase = {
-    /**
-     * Identifier of the harness that produced this state. Used by adapters to
-     * refuse mismatched payloads.
-     */
-    readonly harnessId: string;
-    /**
-     * Spec version of the harness that produced this state.
-     */
-    readonly specificationVersion: 'harness-v1';
-    /**
-     * Adapter-defined payload. May be persisted as JSON; the adapter is
-     * responsible for any necessary encoding.
-     */
-    readonly data: JSONValue;
+  /**
+   * Identifier of the harness that produced this state. Used by adapters to
+   * refuse mismatched payloads.
+   */
+  readonly harnessId: string;
+  /**
+   * Spec version of the harness that produced this state.
+   */
+  readonly specificationVersion: 'harness-v1';
+  /**
+   * Adapter-defined payload. May be persisted as JSON; the adapter is
+   * responsible for any necessary encoding.
+   */
+  readonly data: JSONValue;
 };
 /**
  * Opaque payload returned by between-turn session lifecycle methods and
@@ -522,12 +530,12 @@ type HarnessV1LifecycleStateBase = {
  * underlying session before starting a new turn.
  */
 type HarnessV1ResumeSessionState = HarnessV1LifecycleStateBase & {
-    readonly type: 'resume-session';
-    /**
-     * Optional unfinished-turn state. When present, the session must be resumed
-     * before the turn is continued.
-     */
-    readonly continueFrom?: HarnessV1ContinueTurnState;
+  readonly type: 'resume-session';
+  /**
+   * Optional unfinished-turn state. When present, the session must be resumed
+   * before the turn is continued.
+   */
+  readonly continueFrom?: HarnessV1ContinueTurnState;
 };
 /**
  * Opaque payload returned by `doSuspendTurn` and accepted by a future
@@ -535,27 +543,28 @@ type HarnessV1ResumeSessionState = HarnessV1LifecycleStateBase & {
  * continuing the suspended turn.
  */
 type HarnessV1ContinueTurnState = HarnessV1LifecycleStateBase & {
-    readonly type: 'continue-turn';
-    /**
-     * Framework-owned pending approval records. These are intentionally outside
-     * adapter-defined `data` so callers can persist the entire lifecycle payload
-     * without the harness framework owning storage.
-     */
-    readonly pendingToolApprovals?: readonly HarnessV1PendingToolApproval[];
-    /**
-     * Framework-owned client tool calls that are waiting for a caller-provided
-     * result before the underlying turn can continue.
-     */
-    readonly pendingToolResults?: readonly HarnessV1PendingToolResult[];
-    /**
-     * Framework-owned settings captured when the unfinished turn began. They
-     * are persisted outside adapter data so a resumed continuation cannot pick
-     * up settings prepared for a later turn.
-     */
-    readonly turnSettings?: HarnessV1TurnSettings;
+  readonly type: 'continue-turn';
+  /**
+   * Framework-owned pending approval records. These are intentionally outside
+   * adapter-defined `data` so callers can persist the entire lifecycle payload
+   * without the harness framework owning storage.
+   */
+  readonly pendingToolApprovals?: readonly HarnessV1PendingToolApproval[];
+  /**
+   * Framework-owned client tool calls that are waiting for a caller-provided
+   * result before the underlying turn can continue.
+   */
+  readonly pendingToolResults?: readonly HarnessV1PendingToolResult[];
+  /**
+   * Framework-owned settings captured when the unfinished turn began. They
+   * are persisted outside adapter data so a resumed continuation cannot pick
+   * up settings prepared for a later turn.
+   */
+  readonly turnSettings?: HarnessV1TurnSettings;
 };
 type HarnessV1LifecycleState = HarnessV1ResumeSessionState | HarnessV1ContinueTurnState;
-
+//#endregion
+//#region src/v1/harness-v1-call-warning.d.ts
 /**
  * Warning emitted by a harness adapter during a call.
  *
@@ -564,18 +573,19 @@ type HarnessV1LifecycleState = HarnessV1ResumeSessionState | HarnessV1ContinueTu
  * in the harness namespace.
  */
 type HarnessV1CallWarning = {
-    type: 'unsupported-setting';
-    setting: string;
-    details?: string;
+  type: 'unsupported-setting';
+  setting: string;
+  details?: string;
 } | {
-    type: 'unsupported-tool';
-    tool: string;
-    details?: string;
+  type: 'unsupported-tool';
+  tool: string;
+  details?: string;
 } | {
-    type: 'other';
-    message: string;
+  type: 'other';
+  message: string;
 };
-
+//#endregion
+//#region src/v1/harness-v1-metadata.d.ts
 /**
  * Adapter-namespaced opaque data attached to harness events.
  *
@@ -587,7 +597,8 @@ type HarnessV1CallWarning = {
  * JSON-serializable data the adapter chooses to surface to callers.
  */
 type HarnessV1Metadata = Record<string, Record<string, JSONValue>>;
-
+//#endregion
+//#region src/v1/harness-v1-stream-part.d.ts
 /**
  * One event emitted by a harness adapter during a prompt turn.
  *
@@ -603,92 +614,154 @@ type HarnessV1Metadata = Record<string, Record<string, JSONValue>>;
  * agent rebinds it when forwarding to AI SDK consumers.
  */
 type HarnessV1StreamPart = {
-    type: 'stream-start';
-    warnings?: ReadonlyArray<HarnessV1CallWarning>;
-    /**
-     * The model the runtime actually resolved to for this turn, when the
-     * adapter learns it at stream start (e.g. Claude Code's `init` message
-     * reports the resolved/default model). Surfaced into telemetry as
-     * `gen_ai.request.model`. Omitted when the adapter doesn't know it here.
-     */
-    modelId?: string;
+  type: 'stream-start';
+  warnings?: ReadonlyArray<HarnessV1CallWarning>;
+  /**
+   * The model the runtime actually resolved to for this turn, when the
+   * adapter learns it at stream start (e.g. Claude Code's `init` message
+   * reports the resolved/default model). Surfaced into telemetry as
+   * `gen_ai.request.model`. Omitted when the adapter doesn't know it here.
+   */
+  modelId?: string;
 } | {
-    type: 'text-start';
-    id: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'text-start';
+  id: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'text-delta';
-    id: string;
-    delta: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'text-delta';
+  id: string;
+  delta: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'text-end';
-    id: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'text-end';
+  id: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'reasoning-start';
-    id: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'reasoning-start';
+  id: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'reasoning-delta';
-    id: string;
-    delta: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'reasoning-delta';
+  id: string;
+  delta: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'reasoning-end';
-    id: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'reasoning-end';
+  id: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | Extract<LanguageModelV4StreamPart, {
-    type: 'tool-input-start';
+  type: 'tool-input-start';
 }> | Extract<LanguageModelV4StreamPart, {
-    type: 'tool-input-delta';
+  type: 'tool-input-delta';
 }> | Extract<LanguageModelV4StreamPart, {
-    type: 'tool-input-end';
+  type: 'tool-input-end';
 }> | (LanguageModelV4ToolCall & {
-    nativeName?: string;
-    /**
-     * Total tool calls in the current model step, when known before tool
-     * execution begins. Populate this on every tool call in the step.
-     */
-    stepToolCallCount?: number;
+  nativeName?: string;
+  /**
+   * Total tool calls in the current model step, when known before tool
+   * execution begins. Populate this on every tool call in the step.
+   */
+  stepToolCallCount?: number;
 }) | LanguageModelV4ToolApprovalRequest | LanguageModelV4ToolResult | {
-    type: 'finish-step';
-    finishReason: LanguageModelV4FinishReason;
-    usage: LanguageModelV4Usage;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'finish-step';
+  finishReason: LanguageModelV4FinishReason;
+  usage: LanguageModelV4Usage;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'finish';
-    finishReason: LanguageModelV4FinishReason;
-    totalUsage: LanguageModelV4Usage;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'finish';
+  finishReason: LanguageModelV4FinishReason;
+  totalUsage: LanguageModelV4Usage;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'file-change';
-    event: 'create' | 'modify' | 'delete';
-    path: string;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'file-change';
+  event: 'create' | 'modify' | 'delete';
+  path: string;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'compaction';
-    trigger: 'manual' | 'auto';
-    summary: string;
-    tokensBefore?: number;
-    tokensAfter?: number;
-    harnessMetadata?: HarnessV1Metadata;
+  type: 'compaction';
+  trigger: 'manual' | 'auto';
+  summary: string;
+  tokensBefore?: number;
+  tokensAfter?: number;
+  harnessMetadata?: HarnessV1Metadata;
 } | {
-    type: 'error';
-    error: unknown;
+  type: 'error';
+  error: unknown;
 } | {
-    type: 'raw';
-    rawValue: unknown;
+  type: 'raw';
+  rawValue: unknown;
+};
+//#endregion
+//#region src/v1/harness-v1-message.d.ts
+type LanguageModelV4ToolResultContentPart = Extract<LanguageModelV4ToolResultOutput, {
+  type: 'content';
+}>['value'][number];
+type HarnessV1TextPart = Omit<LanguageModelV4TextPart, 'providerOptions'>;
+type HarnessV1FilePart = Omit<LanguageModelV4FilePart, 'providerOptions'>;
+type HarnessV1CustomPart = Omit<LanguageModelV4CustomPart, 'providerOptions'>;
+type HarnessV1ReasoningPart = Omit<LanguageModelV4ReasoningPart, 'providerOptions'>;
+type HarnessV1ReasoningFilePart = Omit<LanguageModelV4ReasoningFilePart, 'providerOptions'>;
+type HarnessV1ToolCallPart = Omit<LanguageModelV4ToolCallPart, 'providerOptions'> & {
+  nativeName?: string;
+};
+type HarnessV1ToolResultOutput = Omit<Extract<LanguageModelV4ToolResultOutput, {
+  type: 'text';
+}>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
+  type: 'json';
+}>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
+  type: 'execution-denied';
+}>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
+  type: 'error-text';
+}>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
+  type: 'error-json';
+}>, 'providerOptions'> | {
+  type: 'content';
+  value: Array<Omit<Extract<LanguageModelV4ToolResultContentPart, {
+    type: 'text';
+  }>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultContentPart, {
+    type: 'file';
+  }>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultContentPart, {
+    type: 'custom';
+  }>, 'providerOptions'>>;
+};
+type HarnessV1ToolResultPart = Omit<LanguageModelV4ToolResultPart, 'output' | 'providerOptions'> & {
+  output: HarnessV1ToolResultOutput;
+};
+type HarnessV1ToolApprovalResponsePart = Omit<LanguageModelV4ToolApprovalResponsePart, 'providerOptions'>;
+type HarnessV1UserMessage = {
+  readonly role: 'user';
+  readonly content: Array<HarnessV1TextPart | HarnessV1FilePart>;
+  readonly at?: string;
+  readonly harnessMetadata?: HarnessV1Metadata;
 };
-
+type HarnessV1AssistantMessage = {
+  readonly role: 'assistant';
+  readonly content: Array<HarnessV1TextPart | HarnessV1FilePart | HarnessV1CustomPart | HarnessV1ReasoningPart | HarnessV1ReasoningFilePart | HarnessV1ToolCallPart | HarnessV1ToolResultPart>;
+  readonly at?: string;
+  readonly harnessMetadata?: HarnessV1Metadata;
+};
+type HarnessV1ToolMessage = {
+  readonly role: 'tool';
+  readonly content: Array<HarnessV1ToolResultPart | HarnessV1ToolApprovalResponsePart>;
+  readonly at?: string;
+  readonly harnessMetadata?: HarnessV1Metadata;
+};
+/**
+ * A persisted harness message using V4 prompt content shapes and metadata
+ * scoped to the adapter that produced it.
+ */
+type HarnessV1Message = HarnessV1UserMessage | HarnessV1AssistantMessage | HarnessV1ToolMessage;
+//#endregion
+//#region src/v1/harness-v1-tool-filtering.d.ts
 type HarnessV1BuiltinToolFiltering = {
-    mode: 'allow';
-    toolNames: string[];
+  mode: 'allow';
+  toolNames: string[];
 } | {
-    mode: 'deny';
-    toolNames: string[];
+  mode: 'deny';
+  toolNames: string[];
 };
-
+//#endregion
+//#region src/v1/harness-v1-session.d.ts
 /**
  * Options passed to `HarnessV1.doStart`.
  *
@@ -697,93 +770,101 @@ type HarnessV1BuiltinToolFiltering = {
  * calling the adapter, so adapters never need to derive provider-specific paths.
  */
 type HarnessV1StartOptions = {
-    /**
-     * Additional normalized HTTP headers to send with model requests.
-     */
-    readonly headers?: Readonly<Record<string, string>>;
-    /**
-     * Stable identifier for this harness session. Used as the underlying
-     * resource name where the adapter has a notion of a named session
-     * (sandbox name, native session id, …).
-     */
-    readonly sessionId: string;
-    /**
-     * Optional resume payload returned by a prior session lifecycle method. When
-     * provided, the adapter should resume the existing session before accepting a
-     * new prompt or continuing a nested unfinished turn.
-     */
-    readonly resumeFrom?: HarnessV1ResumeSessionState;
-    /**
-     * Optional continuation payload returned by `doSuspendTurn`, or nested in
-     * `resumeFrom`. When provided, the adapter should resume the existing session
-     * in a shape ready for `doContinueTurn` rather than for a fresh prompt.
-     */
-    readonly continueFrom?: HarnessV1ContinueTurnState;
-    /**
-     * Approval policy for built-in adapter-native tool use. Custom host-executed
-     * tools are approved by the framework before results are submitted back to
-     * the adapter.
-     */
-    readonly permissionMode?: HarnessV1PermissionMode;
-    /**
-     * Adapter-native built-in tools that should be available for this session.
-     * Custom host-executed tools are filtered by the framework before they reach
-     * the adapter.
-     */
-    readonly builtinToolFiltering?: HarnessV1BuiltinToolFiltering;
-    /**
-     * Signal that aborts startup. The adapter must propagate cancellation to
-     * any spawned processes or network calls.
-     */
-    readonly abortSignal?: AbortSignal;
-    /**
-     * Diagnostics wiring. The framework populates this; the adapter only
-     * forwards `observability.onDiagnostic` into its `SandboxChannel` and
-     * `observability.debug` into the bridge `start` message. Absent when the
-     * consumer has not enabled diagnostics.
-     */
-    readonly observability?: HarnessV1Observability;
-    /**
-     * Sandbox session the adapter operates against. Network sandbox sessions
-     * expose optional infrastructure capabilities for bridge wiring; caller-
-     * provided basic sandbox sessions expose only filesystem and process APIs.
-     * Adapters must not stop or destroy the sandbox themselves.
-     */
-    readonly sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
-    /**
-     * Absolute path the adapter runs the agent in for this session. Composed
-     * underneath the sandbox's resolved default working directory and created
-     * before `doStart`.
-     */
-    readonly sessionWorkDir: string;
+  /**
+   * Additional normalized HTTP headers to send with model requests.
+   */
+  readonly headers?: Readonly<Record<string, string>>;
+  /**
+   * Stable identifier for this harness session. Used as the underlying
+   * resource name where the adapter has a notion of a named session
+   * (sandbox name, native session id, …).
+   */
+  readonly sessionId: string;
+  /**
+   * Optional resume payload returned by a prior session lifecycle method. When
+   * provided, the adapter should resume the existing session before accepting a
+   * new prompt or continuing a nested unfinished turn.
+   */
+  readonly resumeFrom?: HarnessV1ResumeSessionState;
+  /**
+   * Optional continuation payload returned by `doSuspendTurn`, or nested in
+   * `resumeFrom`. When provided, the adapter should resume the existing session
+   * in a shape ready for `doContinueTurn` rather than for a fresh prompt.
+   */
+  readonly continueFrom?: HarnessV1ContinueTurnState;
+  /**
+   * Approval policy for built-in adapter-native tool use. Custom host-executed
+   * tools are approved by the framework before results are submitted back to
+   * the adapter.
+   */
+  readonly permissionMode?: HarnessV1PermissionMode;
+  /**
+   * Adapter-native built-in tools that should be available for this session.
+   * Custom host-executed tools are filtered by the framework before they reach
+   * the adapter.
+   */
+  readonly builtinToolFiltering?: HarnessV1BuiltinToolFiltering;
+  /**
+   * Signal that aborts startup. The adapter must propagate cancellation to
+   * any spawned processes or network calls.
+   */
+  readonly abortSignal?: AbortSignal;
+  /**
+   * Diagnostics wiring. The framework populates this; the adapter only
+   * forwards `observability.onDiagnostic` into its `SandboxChannel` and
+   * `observability.debug` into the bridge `start` message. Absent when the
+   * consumer has not enabled diagnostics.
+   */
+  readonly observability?: HarnessV1Observability;
+  /**
+   * Sandbox session the adapter operates against. Network sandbox sessions
+   * expose optional infrastructure capabilities for bridge wiring; caller-
+   * provided basic sandbox sessions expose only filesystem and process APIs.
+   * Adapters must not stop or destroy the sandbox themselves.
+   */
+  readonly sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+  /**
+   * Absolute path the adapter runs the agent in for this session. Composed
+   * underneath the sandbox's resolved default working directory and created
+   * before `doStart`.
+   */
+  readonly sessionWorkDir: string;
+};
+/**
+ * Result of `HarnessV1Session.doReadHistory`.
+ */
+type HarnessV1ReadHistoryResult = {
+  readonly messages: ReadonlyArray<HarnessV1Message>;
+  /** Opaque position; pass back as `since` to read only what follows. */
+  readonly cursor: string;
 };
 /**
  * Options passed to `HarnessV1Session.doPromptTurn`.
  */
 type HarnessV1PromptTurnOptions = HarnessV1TurnSettings & {
-    /**
-     * Fresh input for this turn — either a plain string or a single
-     * `ModelMessage`. The harness session owns its own conversation history,
-     * so prior turns are never replayed across the contract.
-     */
-    readonly prompt: HarnessV1Prompt;
-    /**
-     * Response format requested for this turn. Adapters that cannot honor a
-     * JSON response format must throw `HarnessCapabilityUnsupportedError`.
-     */
-    readonly responseFormat?: HarnessV1ResponseFormat;
-    /**
-     * Signal that aborts the in-flight turn. The adapter must cancel any
-     * underlying work and resolve `done` (with an error if appropriate).
-     */
-    readonly abortSignal?: AbortSignal;
-    /**
-     * Callback invoked once for each event the adapter produces during the
-     * turn. The adapter is responsible for the ordering and completeness of
-     * events. `done` resolves once the adapter has emitted all events for the
-     * turn (success or failure).
-     */
-    readonly emit: (event: HarnessV1StreamPart) => void;
+  /**
+   * Fresh input for this turn — either a plain string or a single
+   * `ModelMessage`. The harness session owns its own conversation history,
+   * so prior turns are never replayed across the contract.
+   */
+  readonly prompt: HarnessV1Prompt;
+  /**
+   * Response format requested for this turn. Adapters that cannot honor a
+   * JSON response format must throw `HarnessCapabilityUnsupportedError`.
+   */
+  readonly responseFormat?: HarnessV1ResponseFormat;
+  /**
+   * Signal that aborts the in-flight turn. The adapter must cancel any
+   * underlying work and resolve `done` (with an error if appropriate).
+   */
+  readonly abortSignal?: AbortSignal;
+  /**
+   * Callback invoked once for each event the adapter produces during the
+   * turn. The adapter is responsible for the ordering and completeness of
+   * events. `done` resolves once the adapter has emitted all events for the
+   * turn (success or failure).
+   */
+  readonly emit: (event: HarnessV1StreamPart) => void;
 };
 /**
  * Options passed to `HarnessV1Session.doContinueTurn`.
@@ -793,21 +874,21 @@ type HarnessV1PromptTurnOptions = HarnessV1TurnSettings & {
  * that was previously suspended temporarily, e.g. by the workflow slice loop.
  */
 type HarnessV1ContinueTurnOptions = HarnessV1TurnSettings & {
-    /**
-     * Response format of the in-flight turn. Rerun-based adapters use this when
-     * reconstructing the turn; attach-based adapters may ignore it.
-     */
-    readonly responseFormat?: HarnessV1ResponseFormat;
-    /**
-     * Signal that aborts the continued turn. The adapter must cancel any
-     * underlying work and resolve `done` (with an error if appropriate).
-     */
-    readonly abortSignal?: AbortSignal;
-    /**
-     * Callback invoked once for each event the adapter produces while the
-     * continued turn runs. Same contract as `doPromptTurn`'s `emit`.
-     */
-    readonly emit: (event: HarnessV1StreamPart) => void;
+  /**
+   * Response format of the in-flight turn. Rerun-based adapters use this when
+   * reconstructing the turn; attach-based adapters may ignore it.
+   */
+  readonly responseFormat?: HarnessV1ResponseFormat;
+  /**
+   * Signal that aborts the continued turn. The adapter must cancel any
+   * underlying work and resolve `done` (with an error if appropriate).
+   */
+  readonly abortSignal?: AbortSignal;
+  /**
+   * Callback invoked once for each event the adapter produces while the
+   * continued turn runs. Same contract as `doPromptTurn`'s `emit`.
+   */
+  readonly emit: (event: HarnessV1StreamPart) => void;
 };
 /**
  * Active harness session, returned by `HarnessV1.doStart`.
@@ -818,94 +899,122 @@ type HarnessV1ContinueTurnOptions = HarnessV1TurnSettings & {
  * instance via `doDetach`, `doStop`, or `doDestroy`.
  */
 type HarnessV1Session = {
-    /**
-     * Stable identifier for this session. Same value the host passed in via
-     * `HarnessV1StartOptions.sessionId`.
-     */
-    readonly sessionId: string;
-    /**
-     * Whether this session was created from `resumeFrom` or `continueFrom`. Fresh
-     * sessions report `false`; resumed sessions report `true`.
-     */
-    readonly isResume: boolean;
-    /**
-     * Run one prompt turn. Returns a control handle the host uses to feed
-     * tool results, approvals, and user messages back into the turn while it
-     * is in flight. The handle's `done` promise resolves when the turn ends.
-     */
-    doPromptTurn(options: HarnessV1PromptTurnOptions): PromiseLike<HarnessV1PromptControl>;
-    /**
-     * Request that the underlying runtime compact its context. The runtime owns
-     * the compaction — the harness neither implements nor schedules it; this is
-     * only the trigger. When compaction completes, the adapter surfaces a
-     * `compaction` stream part on the next/active turn.
-     *
-     * Required, but not every runtime can honour it: adapters whose transport
-     * exposes no manual compaction (e.g. Codex over `codex exec`, which still
-     * auto-compacts on its own) throw `HarnessCapabilityUnsupportedError`.
-     * `customInstructions`, when supported, steer the compaction summary.
-     */
-    doCompact(customInstructions?: string): PromiseLike<void>;
-    /**
-     * Continue the in-flight turn **without a new user prompt**, returning the
-     * same control surface as `doPromptTurn`. Used to keep consuming a turn that
-     * was suspended at a process boundary (the workflow slice loop), after the
-     * session itself has been resumed via `doStart({ continueFrom })`:
-     *
-     *  - When the runtime's turn is still live and reachable (bridge `attach` /
-     *    `replay`), the adapter subscribes to its events and resolves `done` on
-     *    the turn's `finish` — **without** re-driving it. Lossless.
-     *  - When the live turn is gone (bridge respawned `rerun`, or a host-resident
-     *    runtime like Pi whose turn cannot survive its process), the adapter
-     *    re-drives the runtime's own thread from its persisted state. Lossy: work
-     *    in flight at the suspension is recomputed.
-     *
-     * Required on every adapter. The behaviour an adapter can guarantee follows
-     * from its architecture; the contract is uniform.
-     */
-    doContinueTurn(options: HarnessV1ContinueTurnOptions): PromiseLike<HarnessV1PromptControl>;
-    /**
-     * Gracefully freeze the active turn **at a precise cursor while keeping the
-     * runtime alive**, returning the continuation payload.
-     *
-     * This is the slice-boundary primitive. The adapter stops host-side
-     * consumption of the in-flight turn without telling the runtime to stop:
-     * for a bridge adapter it closes the host socket (the bridge keeps the turn
-     * running and accumulates events for replay) and resolves the active
-     * `doPromptTurn`/`doContinueTurn` `done` **cleanly** (not as an error) once buffered
-     * events have drained, so the cursor in the returned state equals the last
-     * event delivered to the host — guaranteeing the next slice's attach replays
-     * with no gap and no duplicate. A host-resident adapter (Pi) cannot keep its
-     * turn alive, so it persists what it can and the in-flight tail is recomputed
-     * on continue.
-     *
-     * Like `doDetach`, the sandbox/runtime is left running. Unlike `doDetach`,
-     * this is for an active turn at a slice boundary rather than a between-turn
-     * session handoff. Required on every adapter.
-     */
-    doSuspendTurn(): PromiseLike<HarnessV1ContinueTurnState>;
-    /**
-     * Detach from the underlying runtime without tearing it down, returning a
-     * payload the host can later pass to
-     * `HarnessV1.doStart({ resumeFrom })` to reconnect before a new turn. After
-     * `doDetach`, no further methods on this session instance may be called.
-     *
-     * Required. Adapters that cannot keep a live runtime parked still return the
-     * best resume session state they can while leaving the sandbox running.
-     */
-    doDetach(): PromiseLike<HarnessV1ResumeSessionState>;
-    /**
-     * Persist enough state to resume later, then stop the underlying runtime.
-     * After `doStop`, no further methods on this session instance may be called.
-     */
-    doStop(): PromiseLike<HarnessV1ResumeSessionState>;
-    /**
-     * Stop the underlying runtime without returning lifecycle state. After
-     * `doDestroy`, no further methods on this session instance may be called.
-     */
-    doDestroy(): PromiseLike<void>;
+  /**
+   * Stable identifier for this session. Same value the host passed in via
+   * `HarnessV1StartOptions.sessionId`.
+   */
+  readonly sessionId: string;
+  /**
+   * Whether this session was created from `resumeFrom` or `continueFrom`. Fresh
+   * sessions report `false`; resumed sessions report `true`.
+   */
+  readonly isResume: boolean;
+  /**
+   * Run one prompt turn. Returns a control handle the host uses to feed
+   * tool results, approvals, and user messages back into the turn while it
+   * is in flight. The handle's `done` promise resolves when the turn ends.
+   */
+  doPromptTurn(options: HarnessV1PromptTurnOptions): PromiseLike<HarnessV1PromptControl>;
+  /**
+   * Request that the underlying runtime compact its context. The runtime owns
+   * the compaction — the harness neither implements nor schedules it; this is
+   * only the trigger. When compaction completes, the adapter surfaces a
+   * `compaction` stream part on the next/active turn.
+   *
+   * Required, but not every runtime can honour it: adapters whose transport
+   * exposes no manual compaction (e.g. Codex over `codex exec`, which still
+   * auto-compacts on its own) throw `HarnessCapabilityUnsupportedError`.
+   * `customInstructions`, when supported, steer the compaction summary.
+   */
+  doCompact(customInstructions?: string): PromiseLike<void>;
+  /**
+   * Read the conversation history the runtime itself persisted, normalized
+   * to `HarnessV1Message`.
+   *
+   * The session's history can grow outside the harness contract: the same
+   * runtime conversation may be continued interactively (`claude --resume`),
+   * by another process, or before this session attached. Hosts that render a
+   * continuous record of the conversation — not just the turns they drove —
+   * need to read that history back, and the runtime's own store is the only
+   * source that has it. The adapter owns its runtime's persistence format,
+   * so the read belongs here rather than in every host.
+   *
+   * `since` is the `cursor` from a previous read; the result then contains
+   * only messages recorded after it. The cursor is adapter-owned and opaque
+   * to the host.
+   *
+   * Optional capability: adapters that cannot read their runtime's store
+   * omit the method entirely, and the agent surfaces that as
+   * `HarnessCapabilityUnsupportedError`. An adapter that implements it but
+   * cannot reach the store from the current environment (e.g. it lives
+   * inside a remote sandbox) throws `HarnessHistoryUnavailableError`. A
+   * conversation with no recorded messages yet is not an error — it resolves
+   * to an empty `messages` array.
+   */
+  doReadHistory?(options: {
+    readonly since?: string;
+  }): PromiseLike<HarnessV1ReadHistoryResult>;
+  /**
+   * Continue the in-flight turn **without a new user prompt**, returning the
+   * same control surface as `doPromptTurn`. Used to keep consuming a turn that
+   * was suspended at a process boundary (the workflow slice loop), after the
+   * session itself has been resumed via `doStart({ continueFrom })`:
+   *
+   *  - When the runtime's turn is still live and reachable (bridge `attach` /
+   *    `replay`), the adapter subscribes to its events and resolves `done` on
+   *    the turn's `finish` — **without** re-driving it. Lossless.
+   *  - When the live turn is gone (bridge respawned `rerun`, or a host-resident
+   *    runtime like Pi whose turn cannot survive its process), the adapter
+   *    re-drives the runtime's own thread from its persisted state. Lossy: work
+   *    in flight at the suspension is recomputed.
+   *
+   * Required on every adapter. The behaviour an adapter can guarantee follows
+   * from its architecture; the contract is uniform.
+   */
+  doContinueTurn(options: HarnessV1ContinueTurnOptions): PromiseLike<HarnessV1PromptControl>;
+  /**
+   * Gracefully freeze the active turn **at a precise cursor while keeping the
+   * runtime alive**, returning the continuation payload.
+   *
+   * This is the slice-boundary primitive. The adapter stops host-side
+   * consumption of the in-flight turn without telling the runtime to stop:
+   * for a bridge adapter it closes the host socket (the bridge keeps the turn
+   * running and accumulates events for replay) and resolves the active
+   * `doPromptTurn`/`doContinueTurn` `done` **cleanly** (not as an error) once buffered
+   * events have drained, so the cursor in the returned state equals the last
+   * event delivered to the host — guaranteeing the next slice's attach replays
+   * with no gap and no duplicate. A host-resident adapter (Pi) cannot keep its
+   * turn alive, so it persists what it can and the in-flight tail is recomputed
+   * on continue.
+   *
+   * Like `doDetach`, the sandbox/runtime is left running. Unlike `doDetach`,
+   * this is for an active turn at a slice boundary rather than a between-turn
+   * session handoff. Required on every adapter.
+   */
+  doSuspendTurn(): PromiseLike<HarnessV1ContinueTurnState>;
+  /**
+   * Detach from the underlying runtime without tearing it down, returning a
+   * payload the host can later pass to
+   * `HarnessV1.doStart({ resumeFrom })` to reconnect before a new turn. After
+   * `doDetach`, no further methods on this session instance may be called.
+   *
+   * Required. Adapters that cannot keep a live runtime parked still return the
+   * best resume session state they can while leaving the sandbox running.
+   */
+  doDetach(): PromiseLike<HarnessV1ResumeSessionState>;
+  /**
+   * Persist enough state to resume later, then stop the underlying runtime.
+   * After `doStop`, no further methods on this session instance may be called.
+   */
+  doStop(): PromiseLike<HarnessV1ResumeSessionState>;
+  /**
+   * Stop the underlying runtime without returning lifecycle state. After
+   * `doDestroy`, no further methods on this session instance may be called.
+   */
+  doDestroy(): PromiseLike<void>;
 };
-
+//#endregion
+//#region src/v1/harness-v1.d.ts
 /**
  * Versioned specification for a harness adapter — the integration point for
  * one third-party coding-agent runtime (Claude Code, Codex, …).
@@ -920,73 +1029,74 @@ type HarnessV1Session = {
  * capability.
  */
 type HarnessV1<TBuiltinTools extends ToolSet = ToolSet> = {
-    /**
-     * Spec version this adapter implements. Always the literal `'harness-v1'`.
-     */
-    readonly specificationVersion: 'harness-v1';
-    /**
-     * Stable identifier for this harness, used as the key inside
-     * `HarnessV1Metadata` objects. Conventionally a kebab-case slug matching
-     * the package name (`'claude-code'`, `'codex'`).
-     */
-    readonly harnessId: string;
-    /**
-     * Tools the adapter's underlying runtime exposes natively, as a `ToolSet`
-     * keyed by what the bridge emits on `tool-call` events
-     * (`commonName ?? nativeName`). Each entry is a `HarnessV1BuiltinTool`
-     * (a `Tool` plus harness-specific `nativeName` / `commonName` metadata).
-     *
-     * The agent merges this with consumer-supplied user tools when validating
-     * inbound tool calls and when typing the consumer-facing stream.
-     */
-    readonly builtinTools: TBuiltinTools;
-    /**
-     * Whether the adapter can emit approval requests for built-in tools when
-     * `permissionMode` is not `'allow-all'`.
-     *
-     * Custom host-executed tool approvals are handled by `HarnessAgent`, so this
-     * only describes adapter-native tool approval support.
-     */
-    readonly supportsBuiltinToolApprovals?: boolean;
-    /**
-     * Whether the adapter can prevent its underlying runtime from seeing or
-     * calling inactive built-in tools for every tool in `builtinTools`.
-     *
-     * Adapters without native filtering can still support `activeTools` and
-     * `inactiveTools` for built-ins when `supportsBuiltinToolApprovals` is
-     * `true`: the framework routes inactive built-in tool calls through the
-     * approval path and auto-denies them before they execute.
-     */
-    readonly supportsBuiltinToolFiltering?: boolean;
-    /**
-     * Optional schema for the adapter-defined `data` payload returned by session
-     * lifecycle methods. When present, the adapter promises that exported state
-     * validated by this schema can be re-imported in a future
-     * `doStart({ resumeFrom })` or `doStart({ continueFrom })` call.
-     */
-    readonly lifecycleStateSchema?: FlexibleSchema<unknown>;
-    /**
-     * Optional bootstrap recipe. When defined, the harness session manager
-     * computes a stable identity from the recipe, passes it (along with a
-     * one-time recipe-application hook) to the sandbox provider, and applies
-     * the recipe idempotently after the provider returns the handle.
-     *
-     * Adapters with no bootstrap needs omit this. Adapters that need to install
-     * deps or ship bridge files into the sandbox declare them here so the
-     * provider can cache the result across sessions via snapshots when
-     * supported.
-     */
-    readonly getBootstrap?: (options?: {
-        abortSignal?: AbortSignal;
-    }) => PromiseLike<HarnessV1Bootstrap>;
-    /**
-     * Start a fresh session, resume a parked session via `resumeFrom`, or resume
-     * a suspended turn via `continueFrom`. The host then issues prompts against
-     * the returned session, ending with `doDetach`, `doStop`, or `doDestroy`.
-     */
-    doStart(options: HarnessV1StartOptions): PromiseLike<HarnessV1Session>;
+  /**
+   * Spec version this adapter implements. Always the literal `'harness-v1'`.
+   */
+  readonly specificationVersion: 'harness-v1';
+  /**
+   * Stable identifier for this harness, used as the key inside
+   * `HarnessV1Metadata` objects. Conventionally a kebab-case slug matching
+   * the package name (`'claude-code'`, `'codex'`).
+   */
+  readonly harnessId: string;
+  /**
+   * Tools the adapter's underlying runtime exposes natively, as a `ToolSet`
+   * keyed by what the bridge emits on `tool-call` events
+   * (`commonName ?? nativeName`). Each entry is a `HarnessV1BuiltinTool`
+   * (a `Tool` plus harness-specific `nativeName` / `commonName` metadata).
+   *
+   * The agent merges this with consumer-supplied user tools when validating
+   * inbound tool calls and when typing the consumer-facing stream.
+   */
+  readonly builtinTools: TBuiltinTools;
+  /**
+   * Whether the adapter can emit approval requests for built-in tools when
+   * `permissionMode` is not `'allow-all'`.
+   *
+   * Custom host-executed tool approvals are handled by `HarnessAgent`, so this
+   * only describes adapter-native tool approval support.
+   */
+  readonly supportsBuiltinToolApprovals?: boolean;
+  /**
+   * Whether the adapter can prevent its underlying runtime from seeing or
+   * calling inactive built-in tools for every tool in `builtinTools`.
+   *
+   * Adapters without native filtering can still support `activeTools` and
+   * `inactiveTools` for built-ins when `supportsBuiltinToolApprovals` is
+   * `true`: the framework routes inactive built-in tool calls through the
+   * approval path and auto-denies them before they execute.
+   */
+  readonly supportsBuiltinToolFiltering?: boolean;
+  /**
+   * Optional schema for the adapter-defined `data` payload returned by session
+   * lifecycle methods. When present, the adapter promises that exported state
+   * validated by this schema can be re-imported in a future
+   * `doStart({ resumeFrom })` or `doStart({ continueFrom })` call.
+   */
+  readonly lifecycleStateSchema?: FlexibleSchema<unknown>;
+  /**
+   * Optional bootstrap recipe. When defined, the harness session manager
+   * computes a stable identity from the recipe, passes it (along with a
+   * one-time recipe-application hook) to the sandbox provider, and applies
+   * the recipe idempotently after the provider returns the handle.
+   *
+   * Adapters with no bootstrap needs omit this. Adapters that need to install
+   * deps or ship bridge files into the sandbox declare them here so the
+   * provider can cache the result across sessions via snapshots when
+   * supported.
+   */
+  readonly getBootstrap?: (options?: {
+    abortSignal?: AbortSignal;
+  }) => PromiseLike<HarnessV1Bootstrap>;
+  /**
+   * Start a fresh session, resume a parked session via `resumeFrom`, or resume
+   * a suspended turn via `continueFrom`. The host then issues prompts against
+   * the returned session, ending with `doDetach`, `doStop`, or `doDestroy`.
+   */
+  doStart(options: HarnessV1StartOptions): PromiseLike<HarnessV1Session>;
 };
-
+//#endregion
+//#region src/v1/harness-v1-builtin-tool.d.ts
 /**
  * Cross-harness vocabulary of common built-in tool names with their baseline
  * input schemas. Adapters that declare a built-in with one of these
@@ -997,64 +1107,64 @@ type HarnessV1<TBuiltinTools extends ToolSet = ToolSet> = {
  * a vocabulary source — `HarnessV1BuiltinToolName` is derived from its keys.
  */
 declare const HARNESS_V1_BUILTIN_TOOLS: {
-    readonly read: Tool<{
-        file_path: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly write: Tool<{
-        file_path: string;
-        content: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly edit: Tool<{
-        file_path: string;
-        old_string: string;
-        new_string: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly bash: Tool<{
-        command: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly grep: Tool<{
-        pattern: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly glob: Tool<{
-        pattern: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly webSearch: Tool<{
-        query: string;
-    }, unknown, _ai_sdk_provider_utils.Context>;
-    readonly askUserQuestions: _ai_sdk_provider_utils.FunctionTool<{
-        allowPartialAnswers: boolean;
-        questions: {
-            id: string;
-            question: string;
-            header?: string | undefined;
-            options?: {
-                id: string;
-                label: string;
-                description?: string | undefined;
-                preview?: string | undefined;
-            }[] | undefined;
-            allowMultiple?: boolean | undefined;
-            allowFreeForm?: boolean | {
-                secret: boolean;
-            } | undefined;
-        }[];
-    }, {
-        action: "answered";
-        answers: Record<string, {
-            optionIds: string[];
-            freeform?: string | undefined;
-        }>;
-    } | {
-        action: "partially-answered";
-        answers: Record<string, {
-            optionIds: string[];
-            freeform?: string | undefined;
-        }>;
-    } | {
-        action: "declined";
-    } | {
-        action: "cancelled";
+  readonly read: Tool<{
+    file_path: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly write: Tool<{
+    file_path: string;
+    content: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly edit: Tool<{
+    file_path: string;
+    old_string: string;
+    new_string: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly bash: Tool<{
+    command: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly grep: Tool<{
+    pattern: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly glob: Tool<{
+    pattern: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly webSearch: Tool<{
+    query: string;
+  }, unknown, import("@ai-sdk/provider-utils").Context>;
+  readonly askUserQuestions: import("@ai-sdk/provider-utils").FunctionTool<{
+    allowPartialAnswers: boolean;
+    questions: {
+      id: string;
+      question: string;
+      header?: string | undefined;
+      options?: {
+        id: string;
+        label: string;
+        description?: string | undefined;
+        preview?: string | undefined;
+      }[] | undefined;
+      allowMultiple?: boolean | undefined;
+      allowFreeForm?: boolean | {
+        secret: boolean;
+      } | undefined;
+    }[];
+  }, {
+    action: "answered";
+    answers: Record<string, {
+      optionIds: string[];
+      freeform?: string | undefined;
+    }>;
+  } | {
+    action: "partially-answered";
+    answers: Record<string, {
+      optionIds: string[];
+      freeform?: string | undefined;
     }>;
+  } | {
+    action: "declined";
+  } | {
+    action: "cancelled";
+  }>;
 };
 type HarnessV1BuiltinToolName = keyof typeof HARNESS_V1_BUILTIN_TOOLS;
 type HarnessV1BuiltinToolUseKind = 'readonly' | 'edit' | 'bash';
@@ -1077,11 +1187,12 @@ type HarnessV1BuiltinToolUseKind = 'readonly' | 'edit' | 'bash';
  * (declare the tool with the AI SDK's `tool()` directly).
  */
 type HarnessV1BuiltinTool<INPUT = unknown, OUTPUT = unknown> = Tool<INPUT, OUTPUT, any> & {
-    readonly nativeName?: string;
-    readonly commonName?: HarnessV1BuiltinToolName;
-    readonly toolUseKind?: HarnessV1BuiltinToolUseKind;
+  readonly nativeName?: string;
+  readonly commonName?: HarnessV1BuiltinToolName;
+  readonly toolUseKind?: HarnessV1BuiltinToolUseKind;
 };
-
+//#endregion
+//#region src/v1/harness-v1-sandbox-provider.d.ts
 /**
  * Provider that produces network sandbox sessions for harness sessions. Lives at
  * module scope as a stable, synchronous object — analogous to
@@ -1090,72 +1201,74 @@ type HarnessV1BuiltinTool<INPUT = unknown, OUTPUT = unknown> = Tool<INPUT, OUTPU
  */
 /** @deprecated Supply a sandbox session to `HarnessAgent.createSession()` instead. */
 interface HarnessV1SandboxProvider {
-    readonly specificationVersion: 'harness-sandbox-v1';
-    readonly providerId: string;
-    /**
-     * Providers should throw `HarnessSandboxAuthenticationError` when sandbox
-     * acquisition fails because credentials are missing, invalid, or not
-     * authorized. This lets framework integrations distinguish configuration
-     * failures from general sandbox infrastructure errors.
+  readonly specificationVersion: 'harness-sandbox-v1';
+  readonly providerId: string;
+  /**
+   * Providers should throw `HarnessSandboxAuthenticationError` when sandbox
+   * acquisition fails because credentials are missing, invalid, or not
+   * authorized. This lets framework integrations distinguish configuration
+   * failures from general sandbox infrastructure errors.
+   */
+  readonly createSession: (options?: {
+    /**
+     * Stable per-session identifier. When supplied, the provider names the
+     * underlying resource deterministically so a future call to `resume`
+     * (potentially from a different process) can find the same sandbox.
+     * Omitted from prewarm and other paths that don't need a resumable
+     * resource — in that case the provider falls back to its native
+     * auto-naming.
+     */
+    sessionId?: string;
+    abortSignal?: AbortSignal;
+    /**
+     * Stable identity for snapshot-based reuse. Providers that support
+     * persistence/snapshots use this as part of the persistent sandbox
+     * name; subsequent calls with the same identity resume from snapshot.
+     *
+     * Ignored when the provider is wrapping a caller-provided sandbox.
      */
-    readonly createSession: (options?: {
-        /**
-         * Stable per-session identifier. When supplied, the provider names the
-         * underlying resource deterministically so a future call to `resume`
-         * (potentially from a different process) can find the same sandbox.
-         * Omitted from prewarm and other paths that don't need a resumable
-         * resource — in that case the provider falls back to its native
-         * auto-naming.
-         */
-        sessionId?: string;
-        abortSignal?: AbortSignal;
-        /**
-         * Stable identity for snapshot-based reuse. Providers that support
-         * persistence/snapshots use this as part of the persistent sandbox
-         * name; subsequent calls with the same identity resume from snapshot.
-         *
-         * Ignored when the provider is wrapping a caller-provided sandbox.
-         */
-        identity?: string;
-        /**
-         * Called exactly once per identity, on fresh creation. Snapshot-capable
-         * providers wire this into the platform's one-time-setup hook so the
-         * side effects are baked into the snapshot. Providers without snapshot
-         * support run it immediately after fresh create.
-         *
-         * Not called when the provider is wrapping a caller-provided sandbox
-         * (the caller owns the sandbox; the framework applies its own
-         * idempotent bootstrap post-create instead).
-         */
-        onFirstCreate?: (session: Experimental_SandboxSession, opts: {
-            abortSignal?: AbortSignal;
-        }) => Promise<void>;
-    }) => PromiseLike<HarnessV1NetworkSandboxSession>;
+    identity?: string;
     /**
-     * Reattach to an existing sandbox previously created with the same
-     * `sessionId`. Optional — providers that cannot rehydrate by id omit
-     * this; the harness throws
-     * `HarnessCapabilityUnsupportedError` when resume is attempted against
-     * them.
+     * Called exactly once per identity, on fresh creation. Snapshot-capable
+     * providers wire this into the platform's one-time-setup hook so the
+     * side effects are baked into the snapshot. Providers without snapshot
+     * support run it immediately after fresh create.
      *
-     * The provider derives the sandbox identifier from `sessionId` using the
-     * same deterministic naming scheme it used in `createSession`. Returns a
-     * network sandbox session bound to the existing resource.
+     * Not called when the provider is wrapping a caller-provided sandbox
+     * (the caller owns the sandbox; the framework applies its own
+     * idempotent bootstrap post-create instead).
      */
-    readonly resumeSession?: (options: {
-        sessionId: string;
-        abortSignal?: AbortSignal;
-    }) => PromiseLike<HarnessV1NetworkSandboxSession>;
+    onFirstCreate?: (session: Experimental_SandboxSession, opts: {
+      abortSignal?: AbortSignal;
+    }) => Promise<void>;
+  }) => PromiseLike<HarnessV1NetworkSandboxSession>;
+  /**
+   * Reattach to an existing sandbox previously created with the same
+   * `sessionId`. Optional — providers that cannot rehydrate by id omit
+   * this; the harness throws
+   * `HarnessCapabilityUnsupportedError` when resume is attempted against
+   * them.
+   *
+   * The provider derives the sandbox identifier from `sessionId` using the
+   * same deterministic naming scheme it used in `createSession`. Returns a
+   * network sandbox session bound to the existing resource.
+   */
+  readonly resumeSession?: (options: {
+    sessionId: string;
+    abortSignal?: AbortSignal;
+  }) => PromiseLike<HarnessV1NetworkSandboxSession>;
 }
-
+//#endregion
+//#region src/v1/harness-v1-sandbox-template.d.ts
 type HarnessV1SandboxTemplate = {
-    readonly identity: string;
-    readonly prepare: (options: {
-        readonly session: Experimental_SandboxSession;
-        readonly abortSignal?: AbortSignal;
-    }) => Promise<void>;
+  readonly identity: string;
+  readonly prepare: (options: {
+    readonly session: Experimental_SandboxSession;
+    readonly abortSignal?: AbortSignal;
+  }) => Promise<void>;
 };
-
+//#endregion
+//#region src/agent/observability/types.d.ts
 /** Severity of a diagnostic. */
 type HarnessDebugLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
 /**
@@ -1165,12 +1278,12 @@ type HarnessDebugLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
  * fill any unset field — a convenience default, never the only path.
  */
 type HarnessDebugConfig = {
-    /** Master switch. Nothing is captured or forwarded when false/unset. */
-    readonly enabled?: boolean;
-    /** Threshold; events at or above this severity are emitted. Default `debug`. */
-    readonly level?: HarnessDebugLevel;
-    /** Dotted-prefix subsystem filter for structured events. */
-    readonly subsystems?: ReadonlyArray<string>;
+  /** Master switch. Nothing is captured or forwarded when false/unset. */
+  readonly enabled?: boolean;
+  /** Threshold; events at or above this severity are emitted. Default `debug`. */
+  readonly level?: HarnessDebugLevel;
+  /** Dotted-prefix subsystem filter for structured events. */
+  readonly subsystems?: ReadonlyArray<string>;
 };
 /**
  * A forwarded bridge diagnostic, normalized for host consumers.
@@ -1182,37 +1295,37 @@ type HarnessDebugConfig = {
  * kept first-class and per-line — they are never folded into telemetry spans.
  */
 type HarnessDiagnostic = {
-    /**
-     * Severity. Structured events carry their own level; captured console lines
-     * map `stderr` → `'warn'` and `stdout` → `'info'`.
-     */
-    readonly level: HarnessDebugLevel;
-    /** Human-readable line (console capture) or message (structured event). */
-    readonly message: string;
-    /**
-     * Dotted subsystem. For captured console output this is
-     * `sandbox.log.<source>`; for structured events it is the adapter-supplied
-     * subsystem (e.g. `bridge.turn`).
-     */
-    readonly subsystem: string;
-    /** `'log'` = captured console line; `'event'` = structured `bridgeLog`. */
-    readonly kind: 'log' | 'event';
-    /** Originating sandbox source label (console capture). */
-    readonly source?: string;
-    /** Which standard stream the line came from (console capture). */
-    readonly stream?: 'stdout' | 'stderr';
-    /** Structured attributes (structured events only). */
-    readonly attrs?: Record<string, unknown>;
-    /** Error payload (structured events only). */
-    readonly error?: {
-        name?: string;
-        message: string;
-        stack?: string;
-    };
-    /** The harness session this diagnostic originated from. */
-    readonly sessionId?: string;
-    /** Host receipt time (epoch ms). */
-    readonly timestamp: number;
+  /**
+   * Severity. Structured events carry their own level; captured console lines
+   * map `stderr` → `'warn'` and `stdout` → `'info'`.
+   */
+  readonly level: HarnessDebugLevel;
+  /** Human-readable line (console capture) or message (structured event). */
+  readonly message: string;
+  /**
+   * Dotted subsystem. For captured console output this is
+   * `sandbox.log.<source>`; for structured events it is the adapter-supplied
+   * subsystem (e.g. `bridge.turn`).
+   */
+  readonly subsystem: string;
+  /** `'log'` = captured console line; `'event'` = structured `bridgeLog`. */
+  readonly kind: 'log' | 'event';
+  /** Originating sandbox source label (console capture). */
+  readonly source?: string;
+  /** Which standard stream the line came from (console capture). */
+  readonly stream?: 'stdout' | 'stderr';
+  /** Structured attributes (structured events only). */
+  readonly attrs?: Record<string, unknown>;
+  /** Error payload (structured events only). */
+  readonly error?: {
+    name?: string;
+    message: string;
+    stack?: string;
+  };
+  /** The harness session this diagnostic originated from. */
+  readonly sessionId?: string;
+  /** Host receipt time (epoch ms). */
+  readonly timestamp: number;
 };
 /**
  * A telemetry integration that also wants the per-line diagnostics stream. The
@@ -1222,9 +1335,10 @@ type HarnessDiagnostic = {
  * `telemetry.integrations` receives both spans and logs.
  */
 interface HarnessDiagnosticConsumer {
-    ingestDiagnostic?(diagnostic: HarnessDiagnostic): void;
+  ingestDiagnostic?(diagnostic: HarnessDiagnostic): void;
 }
-
+//#endregion
+//#region src/agent/harness-agent-types.d.ts
 type HarnessAgentAdapter<TBuiltinTools extends ToolSet = ToolSet> = HarnessV1<TBuiltinTools>;
 type HarnessSandboxTemplate = HarnessV1SandboxTemplate;
 type HarnessAgentBuiltinTool<INPUT = unknown, OUTPUT = unknown> = HarnessV1BuiltinTool<INPUT, OUTPUT>;
@@ -1246,7 +1360,8 @@ type HarnessAgentPendingToolApproval = HarnessV1PendingToolApproval;
 type HarnessAgentPendingToolResult = HarnessV1PendingToolResult;
 type HarnessAgentSkill = HarnessV1Skill;
 type HarnessAgentPermissionMode = HarnessV1PermissionMode;
-
+//#endregion
+//#region src/agent/harness-agent-tool-types.d.ts
 /** Extract the builtin tool set type from a harness adapter parameter. */
 type HarnessBuiltinToolsOf<H> = H extends HarnessAgentAdapter<infer T> ? T : never;
 /**
@@ -1254,46 +1369,47 @@ type HarnessBuiltinToolsOf<H> = H extends HarnessAgentAdapter<infer T> ? T : nev
  * User tools override builtins on key collision.
  */
 type HarnessAllTools<THarness extends HarnessAgentAdapter<any>, TUserTools extends ToolSet> = Omit<HarnessBuiltinToolsOf<THarness>, keyof TUserTools> & TUserTools;
-
+//#endregion
+//#region src/agent/harness-agent-settings.d.ts
 type HarnessAgentToolApprovalConfiguration = Readonly<Record<string, ToolApprovalStatus>>;
 type HarnessAgentSandboxConfig = {
-    /**
-     * Optional fixed working directory for all sessions, relative to the
-     * sandbox's default working directory. Use `'.'` to use the default
-     * working directory itself. When omitted, sessions keep the existing
-     * `<harnessId>-<sessionId>` work directory.
-     */
-    readonly workDir?: string;
-    /**
-     * Caller-controlled identity for `onBootstrap`. Change this whenever the
-     * bootstrap side effects should invalidate the reusable sandbox snapshot.
-     */
-    readonly bootstrapHash?: string;
-    /**
-     * Called during sandbox template creation after the harness adapter's own
-     * bootstrap has run and before snapshot-capable providers publish a snapshot.
-     *
-     * `bootstrapHash` must be provided with this callback.
-     */
-    readonly onBootstrap?: (opts: {
-        readonly session: Experimental_SandboxSession;
-        readonly workDir: string;
-        readonly abortSignal?: AbortSignal;
-    }) => Promise<void>;
-    /**
-     * Called after each sandbox session is acquired and the session work
-     * directory exists, before the harness adapter starts. Runs for fresh and
-     * resumed sessions.
-     *
-     * Use this to write per-session config, install lightweight tools, activate
-     * licenses, or prepare files in `sessionWorkDir`. Keep it idempotent if the
-     * agent may resume sessions.
-     */
-    readonly onSession?: (opts: {
-        readonly session: Experimental_SandboxSession;
-        readonly sessionWorkDir: string;
-        readonly abortSignal?: AbortSignal;
-    }) => Promise<void>;
+  /**
+   * Optional fixed working directory for all sessions, relative to the
+   * sandbox's default working directory. Use `'.'` to use the default
+   * working directory itself. When omitted, sessions keep the existing
+   * `<harnessId>-<sessionId>` work directory.
+   */
+  readonly workDir?: string;
+  /**
+   * Caller-controlled identity for `onBootstrap`. Change this whenever the
+   * bootstrap side effects should invalidate the reusable sandbox snapshot.
+   */
+  readonly bootstrapHash?: string;
+  /**
+   * Called during sandbox template creation after the harness adapter's own
+   * bootstrap has run and before snapshot-capable providers publish a snapshot.
+   *
+   * `bootstrapHash` must be provided with this callback.
+   */
+  readonly onBootstrap?: (opts: {
+    readonly session: Experimental_SandboxSession;
+    readonly workDir: string;
+    readonly abortSignal?: AbortSignal;
+  }) => Promise<void>;
+  /**
+   * Called after each sandbox session is acquired and the session work
+   * directory exists, before the harness adapter starts. Runs for fresh and
+   * resumed sessions.
+   *
+   * Use this to write per-session config, install lightweight tools, activate
+   * licenses, or prepare files in `sessionWorkDir`. Keep it idempotent if the
+   * agent may resume sessions.
+   */
+  readonly onSession?: (opts: {
+    readonly session: Experimental_SandboxSession;
+    readonly sessionWorkDir: string;
+    readonly abortSignal?: AbortSignal;
+  }) => Promise<void>;
 };
 type HarnessTools<TOOLS extends ToolSet> = ActiveTools<NoInfer<TOOLS>>;
 /**
@@ -1307,215 +1423,217 @@ type HarnessTools<TOOLS extends ToolSet> = ActiveTools<NoInfer<TOOLS>>;
  * from custom call options.
  */
 type HarnessAgentToolFilteringSettings<TOOLS extends ToolSet> = {
-    /**
-     * Limits the tools that are available for the harness to call without
-     * changing the tool call and result types in the result.
-     */
-    readonly activeTools?: HarnessTools<TOOLS>;
-    readonly inactiveTools?: never;
+  /**
+   * Limits the tools that are available for the harness to call without
+   * changing the tool call and result types in the result.
+   */
+  readonly activeTools?: HarnessTools<TOOLS>;
+  readonly inactiveTools?: never;
 } | {
-    readonly activeTools?: never;
-    /**
-     * Excludes tools from the set that is available for the harness to call
-     * without changing the tool call and result types in the result.
-     */
-    readonly inactiveTools?: HarnessTools<TOOLS>;
+  readonly activeTools?: never;
+  /**
+   * Excludes tools from the set that is available for the harness to call
+   * without changing the tool call and result types in the result.
+   */
+  readonly inactiveTools?: HarnessTools<TOOLS>;
 };
 type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never, CALL_OPTIONS = never> = {
-    /**
-     * The harness adapter driving the underlying agent runtime. Its
-     * `builtinTools` are merged with the user-defined `tools` and exposed to
-     * AI SDK consumers in the typed `tool-call` stream.
-     */
-    readonly harness: THarness;
-    /**
-     * Stable identifier for this agent instance. Exposed via `agent.id`.
-     * If omitted, `agent.id` is `undefined`.
-     */
-    readonly id?: string;
-    /**
-     * Model identifier used by the harness adapter. Supported values are
-     * defined by the selected harness. `prepareCall` can replace it between
-     * completed turns.
-     */
-    readonly model?: string;
-    /**
-     * Tools available to the underlying runtime in addition to the harness's
-     * own builtins. The agent forwards each tool to the harness as a
-     * `HarnessAgentToolSpec`; when the runtime calls one, the agent executes
-     * `tool.execute()` on the host and submits the result back to the harness.
-     *
-     * User tools take precedence over harness builtins on key collision —
-     * declare a tool with the same name as a builtin to override.
-     */
-    readonly tools?: TUserTools;
-    /**
-     * Per-tool context passed to host-executed tools. Each entry is validated
-     * against the matching tool's `contextSchema` before execution.
-     * `prepareCall` can replace it for each new turn.
-     */
-    readonly toolsContext?: InferToolSetContext<TUserTools>;
-    /**
-     * Runtime context passed to lifecycle callbacks and telemetry.
-     * `prepareCall` can replace it for each new turn.
-     */
-    readonly runtimeContext?: RUNTIME_CONTEXT;
-    /**
-     * Skills made available to the underlying runtime. Each adapter decides how
-     * to surface skills. `prepareCall` can replace them between completed turns.
-     */
-    readonly skills?: ReadonlyArray<HarnessAgentSkill>;
-    /**
-     * Instructions for the underlying agent runtime. Adapters append these to a
-     * native system or developer prompt when supported. Otherwise, they prepend
-     * them to the user message. `prepareCall` can replace them between completed
-     * turns. When a `SystemModelMessage` is provided, only its `content` is
-     * forwarded to the harness adapter.
-     */
-    readonly instructions?: string | SystemModelMessage;
-    /**
-     * Additional HTTP headers to be sent with every model request.
-     *
-     * `authorization`, `x-api-key`, `user-agent`, and `x-client-app` are
-     * managed by the harness and are not allowed.
-     */
-    readonly headers?: Record<string, string | undefined>;
-    /**
-     * Schema for validating the custom options passed to each agent call.
-     */
-    readonly callOptionsSchema?: FlexibleSchema<CALL_OPTIONS>;
-    /**
-     * Prepares the prompt and the settings that may vary between completed
-     * turns. The prepared values are frozen for the lifetime of the turn,
-     * including any suspended-turn continuations.
-     *
-     * Preserve the remaining arguments with the rest-spread pattern when a
-     * field should be removable by returning `undefined`:
-     *
-     * ```ts
-     * prepareCall: ({ options, ...rest }) => ({
-     *   ...rest,
-     *   instructions: options.instructions,
-     * })
-     * ```
-     */
-    readonly prepareCall?: (options: Omit<AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT>, 'abortSignal' | 'timeout' | 'onStart' | 'experimental_onStart' | 'onStepStart' | 'experimental_onStepStart' | 'onToolExecutionStart' | 'experimental_onToolCallStart' | 'onToolExecutionEnd' | 'experimental_onToolCallFinish' | 'onStepEnd' | 'onStepFinish' | 'onEnd' | 'onFinish' | 'experimental_sandbox'> & Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools' | 'runtimeContext'> & {
-        toolsContext: InferToolSetContext<TUserTools>;
-    }) => MaybePromiseLike<Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools' | 'runtimeContext'> & {
-        toolsContext: InferToolSetContext<TUserTools>;
-    } & Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>>;
-    /**
-     * Optional specification for generating typed output. The same output
-     * requirement is active for every turn run by this agent.
-     */
-    readonly output?: OUTPUT;
-    /**
-     * Conditions that stop the current result after a completed harness tool
-     * step that can continue into another model step. The underlying turn remains
-     * unfinished and can be suspended and continued.
-     *
-     * A terminal text-only step finishes naturally and is not stopped early.
-     *
-     * When omitted, the harness runs until the turn naturally finishes or pauses.
-     */
-    readonly stopWhen?: Arrayable<StopCondition<NoInfer<HarnessAllTools<THarness, TUserTools>>, RUNTIME_CONTEXT>>;
-    /**
-     * Called when an agent call begins, before any model steps.
-     */
-    readonly onStart?: GenerateTextOnStartCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, RUNTIME_CONTEXT, NoInfer<OUTPUT>>;
-    /**
-     * Called when a model step begins.
-     */
-    readonly onStepStart?: GenerateTextOnStepStartCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
-    /**
-     * Called immediately before the harness begins emitting a model response.
-     */
-    readonly onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
-    /**
-     * Called after a model response is complete and before its tool execution
-     * lifecycle callbacks are delivered.
-     */
-    readonly onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>>;
-    /**
-     * Called before each harness or host tool execution is reported.
-     */
-    readonly onToolExecutionStart?: OnToolExecutionStartCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>>;
-    /**
-     * Called after each harness or host tool execution is reported.
-     */
-    readonly onToolExecutionEnd?: OnToolExecutionEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>>;
-    /**
-     * Called after each completed model step.
-     */
-    readonly onStepEnd?: GenerateTextOnStepEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, NoInfer<RUNTIME_CONTEXT>>;
-    /**
-     * Called when an agent call completes successfully.
-     */
-    readonly onEnd?: GenerateTextOnEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, NoInfer<RUNTIME_CONTEXT>>;
-    /**
-     * Built-in tool permission mode. Defaults to `'allow-all'`, preserving the
-     * existing bypass-permissions behavior unless users opt in.
-     */
-    readonly permissionMode?: HarnessAgentPermissionMode;
-    /**
-     * Per custom-tool approval statuses. This mirrors AI SDK `toolApproval`
-     * object configuration for host-executed tools, without callback support.
-     *
-     * `not-applicable` and `approved` run the tool, `user-approval` pauses the
-     * turn for a user decision, and `denied` immediately submits an
-     * `execution-denied` result.
-     */
-    readonly toolApproval?: HarnessAgentToolApprovalConfiguration;
-    /**
-     * Optional sandbox provider used to create or resume network sandbox
-     * sessions. When omitted, every `createSession()` call must provide an
-     * existing network sandbox session.
-     */
-    /** @deprecated Supply `sandboxSession` to `HarnessAgent.createSession()` instead. */
-    readonly sandbox?: HarnessV1SandboxProvider;
-    /**
-     * Sandbox working-directory and lifecycle hook configuration.
-     */
-    readonly sandboxConfig?: HarnessAgentSandboxConfig;
-    /** @deprecated Use `sandboxConfig.onSession` instead. */
-    readonly onSandboxSession?: HarnessAgentSandboxConfig['onSession'];
-    /**
-     * Telemetry configuration. The harness drives AI SDK's pluggable
-     * `Telemetry` integration contract from the turn lifecycle, so a harness turn
-     * appears in a consumer's traces with the same span shape as `streamText`.
-     * Register an integration here (e.g. `@ai-sdk/otel`) or globally via
-     * `registerTelemetry`. The harness itself stays OpenTelemetry-agnostic.
-     */
-    readonly telemetry?: TelemetryOptions;
-    /**
-     * Diagnostics configuration. Enables bridge log forwarding (sandbox
-     * console + structured `debug-event`s) and the `HARNESS_DEBUG` stderr default.
-     * Set `{ enabled: true }` to turn it on in code; env vars fill unset fields.
-     */
-    readonly debug?: HarnessDebugConfig;
-    /**
-     * Programmatic sink for forwarded bridge diagnostics. Receives every
-     * captured console line and structured event, normalized. Independent of the
-     * stderr default — wire this to capture diagnostics in code.
-     */
-    readonly onLog?: (event: HarnessDiagnostic) => void;
+  /**
+   * The harness adapter driving the underlying agent runtime. Its
+   * `builtinTools` are merged with the user-defined `tools` and exposed to
+   * AI SDK consumers in the typed `tool-call` stream.
+   */
+  readonly harness: THarness;
+  /**
+   * Stable identifier for this agent instance. Exposed via `agent.id`.
+   * If omitted, `agent.id` is `undefined`.
+   */
+  readonly id?: string;
+  /**
+   * Model identifier used by the harness adapter. Supported values are
+   * defined by the selected harness. `prepareCall` can replace it between
+   * completed turns.
+   */
+  readonly model?: string;
+  /**
+   * Tools available to the underlying runtime in addition to the harness's
+   * own builtins. The agent forwards each tool to the harness as a
+   * `HarnessAgentToolSpec`; when the runtime calls one, the agent executes
+   * `tool.execute()` on the host and submits the result back to the harness.
+   *
+   * User tools take precedence over harness builtins on key collision —
+   * declare a tool with the same name as a builtin to override.
+   */
+  readonly tools?: TUserTools;
+  /**
+   * Per-tool context passed to host-executed tools. Each entry is validated
+   * against the matching tool's `contextSchema` before execution.
+   * `prepareCall` can replace it for each new turn.
+   */
+  readonly toolsContext?: InferToolSetContext<TUserTools>;
+  /**
+   * Runtime context passed to lifecycle callbacks and telemetry.
+   * `prepareCall` can replace it for each new turn.
+   */
+  readonly runtimeContext?: RUNTIME_CONTEXT;
+  /**
+   * Skills made available to the underlying runtime. Each adapter decides how
+   * to surface skills. `prepareCall` can replace them between completed turns.
+   */
+  readonly skills?: ReadonlyArray<HarnessAgentSkill>;
+  /**
+   * Instructions for the underlying agent runtime. Adapters append these to a
+   * native system or developer prompt when supported. Otherwise, they prepend
+   * them to the user message. `prepareCall` can replace them between completed
+   * turns. When a `SystemModelMessage` is provided, only its `content` is
+   * forwarded to the harness adapter.
+   */
+  readonly instructions?: string | SystemModelMessage;
+  /**
+   * Additional HTTP headers to be sent with every model request.
+   *
+   * `authorization`, `x-api-key`, `user-agent`, and `x-client-app` are
+   * managed by the harness and are not allowed.
+   */
+  readonly headers?: Record<string, string | undefined>;
+  /**
+   * Schema for validating the custom options passed to each agent call.
+   */
+  readonly callOptionsSchema?: FlexibleSchema<CALL_OPTIONS>;
+  /**
+   * Prepares the prompt and the settings that may vary between completed
+   * turns. The prepared values are frozen for the lifetime of the turn,
+   * including any suspended-turn continuations.
+   *
+   * Preserve the remaining arguments with the rest-spread pattern when a
+   * field should be removable by returning `undefined`:
+   *
+   * ```ts
+   * prepareCall: ({ options, ...rest }) => ({
+   *   ...rest,
+   *   instructions: options.instructions,
+   * })
+   * ```
+   */
+  readonly prepareCall?: (options: Omit<AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT>, 'abortSignal' | 'timeout' | 'onStart' | 'experimental_onStart' | 'onStepStart' | 'experimental_onStepStart' | 'onToolExecutionStart' | 'experimental_onToolCallStart' | 'onToolExecutionEnd' | 'experimental_onToolCallFinish' | 'onStepEnd' | 'onStepFinish' | 'onEnd' | 'onFinish' | 'experimental_sandbox'> & Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools' | 'runtimeContext'> & {
+    toolsContext: InferToolSetContext<TUserTools>;
+  }) => MaybePromiseLike<Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools' | 'runtimeContext'> & {
+    toolsContext: InferToolSetContext<TUserTools>;
+  } & Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>>;
+  /**
+   * Optional specification for generating typed output. The same output
+   * requirement is active for every turn run by this agent.
+   */
+  readonly output?: OUTPUT;
+  /**
+   * Conditions that stop the current result after a completed harness tool
+   * step that can continue into another model step. The underlying turn remains
+   * unfinished and can be suspended and continued.
+   *
+   * A terminal text-only step finishes naturally and is not stopped early.
+   *
+   * When omitted, the harness runs until the turn naturally finishes or pauses.
+   */
+  readonly stopWhen?: Arrayable<StopCondition<NoInfer<HarnessAllTools<THarness, TUserTools>>, RUNTIME_CONTEXT>>;
+  /**
+   * Called when an agent call begins, before any model steps.
+   */
+  readonly onStart?: GenerateTextOnStartCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, RUNTIME_CONTEXT, NoInfer<OUTPUT>>;
+  /**
+   * Called when a model step begins.
+   */
+  readonly onStepStart?: GenerateTextOnStepStartCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
+  /**
+   * Called immediately before the harness begins emitting a model response.
+   */
+  readonly onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
+  /**
+   * Called after a model response is complete and before its tool execution
+   * lifecycle callbacks are delivered.
+   */
+  readonly onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>>;
+  /**
+   * Called before each harness or host tool execution is reported.
+   */
+  readonly onToolExecutionStart?: OnToolExecutionStartCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>>;
+  /**
+   * Called after each harness or host tool execution is reported.
+   */
+  readonly onToolExecutionEnd?: OnToolExecutionEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>>;
+  /**
+   * Called after each completed model step.
+   */
+  readonly onStepEnd?: GenerateTextOnStepEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, NoInfer<RUNTIME_CONTEXT>>;
+  /**
+   * Called when an agent call completes successfully.
+   */
+  readonly onEnd?: GenerateTextOnEndCallback<NoInfer<HarnessAllTools<THarness, TUserTools>>, NoInfer<RUNTIME_CONTEXT>>;
+  /**
+   * Built-in tool permission mode. Defaults to `'allow-all'`, preserving the
+   * existing bypass-permissions behavior unless users opt in.
+   */
+  readonly permissionMode?: HarnessAgentPermissionMode;
+  /**
+   * Per custom-tool approval statuses. This mirrors AI SDK `toolApproval`
+   * object configuration for host-executed tools, without callback support.
+   *
+   * `not-applicable` and `approved` run the tool, `user-approval` pauses the
+   * turn for a user decision, and `denied` immediately submits an
+   * `execution-denied` result.
+   */
+  readonly toolApproval?: HarnessAgentToolApprovalConfiguration;
+  /**
+   * Optional sandbox provider used to create or resume network sandbox
+   * sessions. When omitted, every `createSession()` call must provide an
+   * existing network sandbox session.
+   */
+  /** @deprecated Supply `sandboxSession` to `HarnessAgent.createSession()` instead. */
+  readonly sandbox?: HarnessV1SandboxProvider;
+  /**
+   * Sandbox working-directory and lifecycle hook configuration.
+   */
+  readonly sandboxConfig?: HarnessAgentSandboxConfig;
+  /** @deprecated Use `sandboxConfig.onSession` instead. */
+  readonly onSandboxSession?: HarnessAgentSandboxConfig['onSession'];
+  /**
+   * Telemetry configuration. The harness drives AI SDK's pluggable
+   * `Telemetry` integration contract from the turn lifecycle, so a harness turn
+   * appears in a consumer's traces with the same span shape as `streamText`.
+   * Register an integration here (e.g. `@ai-sdk/otel`) or globally via
+   * `registerTelemetry`. The harness itself stays OpenTelemetry-agnostic.
+   */
+  readonly telemetry?: TelemetryOptions;
+  /**
+   * Diagnostics configuration. Enables bridge log forwarding (sandbox
+   * console + structured `debug-event`s) and the `HARNESS_DEBUG` stderr default.
+   * Set `{ enabled: true }` to turn it on in code; env vars fill unset fields.
+   */
+  readonly debug?: HarnessDebugConfig;
+  /**
+   * Programmatic sink for forwarded bridge diagnostics. Receives every
+   * captured console line and structured event, normalized. Independent of the
+   * stderr default — wire this to capture diagnostics in code.
+   */
+  readonly onLog?: (event: HarnessDiagnostic) => void;
 } & ToolsContextSettings<TUserTools> & HarnessAgentToolFilteringSettings<HarnessAllTools<THarness, TUserTools>>;
-
+//#endregion
+//#region src/agent/internal/turn-telemetry.d.ts
 type HarnessAgentLifecycleCallbacks<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface> = {
-    onStart?: GenerateTextOnStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-    onStepStart?: GenerateTextOnStepStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-    onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
-    onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<TOOLS>;
-    onToolExecutionStart?: OnToolExecutionStartCallback<TOOLS>;
-    onToolExecutionEnd?: OnToolExecutionEndCallback<TOOLS>;
-    onStepEnd?: GenerateTextOnStepEndCallback<TOOLS, RUNTIME_CONTEXT>;
-    onEnd?: GenerateTextOnEndCallback<TOOLS, RUNTIME_CONTEXT>;
+  onStart?: GenerateTextOnStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+  onStepStart?: GenerateTextOnStepStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+  onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
+  onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<TOOLS>;
+  onToolExecutionStart?: OnToolExecutionStartCallback<TOOLS>;
+  onToolExecutionEnd?: OnToolExecutionEndCallback<TOOLS>;
+  onStepEnd?: GenerateTextOnStepEndCallback<TOOLS, RUNTIME_CONTEXT>;
+  onEnd?: GenerateTextOnEndCallback<TOOLS, RUNTIME_CONTEXT>;
 };
-
+//#endregion
+//#region src/agent/harness-agent-session.d.ts
 type HarnessAgentTurnResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface> = {
-    result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-    done: Promise<void>;
-    ready: Promise<void>;
+  result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+  done: Promise<void>;
+  ready: Promise<void>;
 };
 type HarnessAgentTurnState = 'idle' | 'running' | 'awaiting-approval' | 'awaiting-tool-result' | 'suspended';
 /**
@@ -1530,162 +1648,181 @@ type HarnessAgentTurnState = 'idle' | 'running' | 'awaiting-approval' | 'awaitin
  * After any lifecycle method has resolved, the session is unusable — any
  * subsequent `generate`/`stream` call against it throws.
  */
-declare class HarnessAgentSession {
-    /**
-     * Stable identifier the harness adapter saw in `doStart`. The same
-     * string callers persist when they intend to resume the session in a
-     * future process.
-     */
-    readonly sessionId: string;
-    private readonly harness;
-    private readonly sessionWorkDir;
-    private readonly ownsSandboxLifecycle;
-    private underlyingSession;
-    private sandboxSession;
-    private readonly toolApproval;
-    private readonly pendingToolApprovals;
-    private readonly pendingToolResults;
-    private sessionState;
-    private turnState;
-    private turnSequence;
-    private activeTurnSequence;
-    private activePromptDone;
-    private activePromptControl;
-    private suspendedTurnState;
-    private activeTurnSettings;
-    private persistedTurnSettings;
-    private readonly resumedToolsContext;
-    private readonly resumedRuntimeContext;
-    /**
-     * Whether this session was created from `resumeFrom` or `continueFrom`.
-     * Captured at construction so it survives lifecycle cleanup.
-     */
-    readonly isResume: boolean;
-    constructor(options: {
-        sessionId: string;
-        harness: HarnessAgentAdapter;
-        underlyingSession: HarnessAgentAdapterSession;
-        sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
-        ownsSandboxLifecycle?: boolean;
-        sessionWorkDir: string;
-        toolApproval: HarnessAgentToolApprovalConfiguration | undefined;
-        pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
-        pendingToolResults?: readonly HarnessAgentPendingToolResult[];
-        turnSettings?: HarnessV1TurnSettings;
-        resumedToolsContext?: Record<string, Context | undefined>;
-        resumedRuntimeContext?: Context;
-        turnState?: HarnessAgentTurnState;
-    });
-    hasUnfinishedTurn(): boolean;
-    promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
-        prompt: HarnessAgentPrompt;
-        model: string | undefined;
-        skills: ReadonlyArray<HarnessV1Skill>;
-        instructions: string | undefined;
-        tools: TOOLS;
-        toolsContext: InferToolSetContext<TOOLS>;
-        activeTools: ToolSet;
-        toolSpecs: HarnessAgentToolSpec[];
-        builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
-        runtimeContext: RUNTIME_CONTEXT;
-        abortSignal: AbortSignal | undefined;
-        responseFormat: HarnessV1ResponseFormat | undefined;
-        output: OUTPUT | undefined;
-        telemetry: TelemetryOptions | undefined;
-        callbacks: HarnessAgentLifecycleCallbacks<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-        stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
-    }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-    continueTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
-        model: string | undefined;
-        skills: ReadonlyArray<HarnessV1Skill>;
-        instructions: string | undefined;
-        tools: TOOLS;
-        toolsContext: InferToolSetContext<TOOLS>;
-        activeTools: ToolSet;
-        toolSpecs: HarnessAgentToolSpec[];
-        builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
-        runtimeContext: RUNTIME_CONTEXT;
-        abortSignal: AbortSignal | undefined;
-        responseFormat: HarnessV1ResponseFormat | undefined;
-        output: OUTPUT | undefined;
-        telemetry: TelemetryOptions | undefined;
-        callbacks: HarnessAgentLifecycleCallbacks<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-        stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
-        toolApprovalContinuations?: readonly ToolApprovalResponse[] | undefined;
-        toolResultContinuations?: readonly ToolResultPart[] | undefined;
-    }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
-    /**
-     * Ask the underlying runtime to compact its context. The runtime performs
-     * the compaction itself; when it completes, a `compaction` part appears on
-     * the active (or next) turn's stream. Safe to call between turns for
-     * runtimes whose compaction is session-scoped (e.g. Pi).
-     *
-     * Throws `HarnessCapabilityUnsupportedError` for harnesses that cannot
-     * trigger compaction manually (e.g. Codex, which still auto-compacts under
-     * the hood). Throws if the session has ended.
-     */
-    compact(customInstructions?: string): Promise<void>;
-    /**
-     * Submit another user message to the active turn.
-     *
-     * The runtime accepts the message for its next safe input boundary. Output
-     * caused by the message remains part of the active turn's result stream.
-     */
-    experimental_steerTurn(text: string): Promise<void>;
-    /**
-     * Park the session, returning a payload the caller can persist and later
-     * pass to `agent.createSession({ sessionId, resumeFrom })` to reconnect.
-     * The runtime and sandbox keep running; this local session handle becomes
-     * unusable.
-     */
-    detach(): Promise<HarnessAgentResumeSessionState>;
-    /**
-     * Persist enough state to resume later, then stop the runtime and any
-     * harness-owned sandbox.
-     * Returns the resume state for a future
-     * `agent.createSession({ sessionId, resumeFrom })` call.
-     */
-    stop(): Promise<HarnessAgentResumeSessionState>;
-    /**
-     * Stop the runtime and discard resumability. A harness-owned network
-     * sandbox is stopped and destroyed through its `destroy()` method.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Gracefully freeze the active turn at the slice boundary and return the
-     * continuation payload, **leaving the sandbox/runtime running** so the next
-     * process can continue. Resolves once the in-flight `stream()` /
-     * `continueStream()` has cleanly wound down at a precise cursor (see
-     * `doSuspendTurn`).
-     *
-     * After this call the session is detached. This in-process handle no
-     * longer drives turns; a future slice creates a fresh session from the
-     * returned state. The sandbox is **not** stopped because bridge-backed
-     * adapters may still have a live bridge.
-     */
-    suspendTurn(): Promise<HarnessAgentContinueTurnState>;
-    private getPendingToolApprovals;
-    private getPendingToolResults;
-    private addPendingToolState;
-    private suspendCurrentTurn;
-    private finalizeCurrentTurnSuspension;
-    private captureStopConditionBoundary;
-    private toResumeStateWithContinuation;
-    private requirePromptableTurn;
-    private requireContinuableTurn;
-    private markAwaitingApprovalIfActive;
-    private markAwaitingToolResultIfActive;
-    private startTrackedTurn;
-    private setPromptControl;
-    private waitForPromptControl;
-    private settleActivePromptControl;
-    private clearActivePromptControl;
-    private finishTrackedTurn;
-    private resolveActiveTurnSettings;
-    private endLocalHandle;
-    private requireReusableSession;
+export declare class HarnessAgentSession {
+  /**
+   * Stable identifier the harness adapter saw in `doStart`. The same
+   * string callers persist when they intend to resume the session in a
+   * future process.
+   */
+  readonly sessionId: string;
+  private readonly harness;
+  private readonly sessionWorkDir;
+  private readonly ownsSandboxLifecycle;
+  private underlyingSession;
+  private sandboxSession;
+  private readonly toolApproval;
+  private readonly pendingToolApprovals;
+  private readonly pendingToolResults;
+  private sessionState;
+  private turnState;
+  private turnSequence;
+  private activeTurnSequence;
+  private activePromptDone;
+  private activePromptControl;
+  private suspendedTurnState;
+  private activeTurnSettings;
+  private persistedTurnSettings;
+  private readonly resumedToolsContext;
+  private readonly resumedRuntimeContext;
+  /**
+   * Whether this session was created from `resumeFrom` or `continueFrom`.
+   * Captured at construction so it survives lifecycle cleanup.
+   */
+  readonly isResume: boolean;
+  constructor(options: {
+    sessionId: string;
+    harness: HarnessAgentAdapter;
+    underlyingSession: HarnessAgentAdapterSession;
+    sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+    ownsSandboxLifecycle?: boolean;
+    sessionWorkDir: string;
+    toolApproval: HarnessAgentToolApprovalConfiguration | undefined;
+    pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
+    pendingToolResults?: readonly HarnessAgentPendingToolResult[];
+    turnSettings?: HarnessV1TurnSettings;
+    resumedToolsContext?: Record<string, Context | undefined>;
+    resumedRuntimeContext?: Context;
+    turnState?: HarnessAgentTurnState;
+  });
+  hasUnfinishedTurn(): boolean;
+  promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
+    prompt: HarnessAgentPrompt;
+    model: string | undefined;
+    skills: ReadonlyArray<HarnessV1Skill>;
+    instructions: string | undefined;
+    tools: TOOLS;
+    toolsContext: InferToolSetContext<TOOLS>;
+    activeTools: ToolSet;
+    toolSpecs: HarnessAgentToolSpec[];
+    builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
+    runtimeContext: RUNTIME_CONTEXT;
+    abortSignal: AbortSignal | undefined;
+    responseFormat: HarnessV1ResponseFormat | undefined;
+    output: OUTPUT | undefined;
+    telemetry: TelemetryOptions | undefined;
+    callbacks: HarnessAgentLifecycleCallbacks<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+    stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
+  }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+  continueTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
+    model: string | undefined;
+    skills: ReadonlyArray<HarnessV1Skill>;
+    instructions: string | undefined;
+    tools: TOOLS;
+    toolsContext: InferToolSetContext<TOOLS>;
+    activeTools: ToolSet;
+    toolSpecs: HarnessAgentToolSpec[];
+    builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
+    runtimeContext: RUNTIME_CONTEXT;
+    abortSignal: AbortSignal | undefined;
+    responseFormat: HarnessV1ResponseFormat | undefined;
+    output: OUTPUT | undefined;
+    telemetry: TelemetryOptions | undefined;
+    callbacks: HarnessAgentLifecycleCallbacks<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+    stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
+    toolApprovalContinuations?: readonly ToolApprovalResponse[] | undefined;
+    toolResultContinuations?: readonly ToolResultPart[] | undefined;
+  }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
+  /**
+   * Ask the underlying runtime to compact its context. The runtime performs
+   * the compaction itself; when it completes, a `compaction` part appears on
+   * the active (or next) turn's stream. Safe to call between turns for
+   * runtimes whose compaction is session-scoped (e.g. Pi).
+   *
+   * Throws `HarnessCapabilityUnsupportedError` for harnesses that cannot
+   * trigger compaction manually (e.g. Codex, which still auto-compacts under
+   * the hood). Throws if the session has ended.
+   */
+  compact(customInstructions?: string): Promise<void>;
+  /**
+   * Submit another user message to the active turn.
+   *
+   * The runtime accepts the message for its next safe input boundary. Output
+   * caused by the message remains part of the active turn's result stream.
+   */
+  experimental_steerTurn(text: string): Promise<void>;
+  /**
+   * Park the session, returning a payload the caller can persist and later
+   * pass to `agent.createSession({ sessionId, resumeFrom })` to reconnect.
+   * The runtime and sandbox keep running; this local session handle becomes
+   * unusable.
+   */
+  detach(): Promise<HarnessAgentResumeSessionState>;
+  /**
+   * Read the conversation history the runtime itself persisted, normalized
+   * by the adapter. Includes exchanges that happened outside this process —
+   * the same conversation continued interactively in the agent's own CLI,
+   * for instance — which the live event stream never saw.
+   *
+   * Pass a previous result's `cursor` as `since` to read only the delta. A
+   * conversation with no recorded messages yet resolves to an empty
+   * `messages` array.
+   *
+   * Throws `HarnessCapabilityUnsupportedError` when the adapter does not
+   * implement history reads, and
+   * `HarnessHistoryUnavailableError` when the adapter supports them but
+   * cannot reach the runtime's store from this environment.
+   */
+  readHistory(options?: {
+    since?: string;
+  }): Promise<HarnessV1ReadHistoryResult>;
+  /**
+   * Persist enough state to resume later, then stop the runtime and any
+   * harness-owned sandbox.
+   * Returns the resume state for a future
+   * `agent.createSession({ sessionId, resumeFrom })` call.
+   */
+  stop(): Promise<HarnessAgentResumeSessionState>;
+  /**
+   * Stop the runtime and discard resumability. A harness-owned network
+   * sandbox is stopped and destroyed through its `destroy()` method.
+   */
+  destroy(): Promise<void>;
+  /**
+   * Gracefully freeze the active turn at the slice boundary and return the
+   * continuation payload, **leaving the sandbox/runtime running** so the next
+   * process can continue. Resolves once the in-flight `stream()` /
+   * `continueStream()` has cleanly wound down at a precise cursor (see
+   * `doSuspendTurn`).
+   *
+   * After this call the session is detached. This in-process handle no
+   * longer drives turns; a future slice creates a fresh session from the
+   * returned state. The sandbox is **not** stopped because bridge-backed
+   * adapters may still have a live bridge.
+   */
+  suspendTurn(): Promise<HarnessAgentContinueTurnState>;
+  private getPendingToolApprovals;
+  private getPendingToolResults;
+  private addPendingToolState;
+  private suspendCurrentTurn;
+  private finalizeCurrentTurnSuspension;
+  private captureStopConditionBoundary;
+  private toResumeStateWithContinuation;
+  private requirePromptableTurn;
+  private requireContinuableTurn;
+  private markAwaitingApprovalIfActive;
+  private markAwaitingToolResultIfActive;
+  private startTrackedTurn;
+  private setPromptControl;
+  private waitForPromptControl;
+  private settleActivePromptControl;
+  private clearActivePromptControl;
+  private finishTrackedTurn;
+  private resolveActiveTurnSettings;
+  private endLocalHandle;
+  private requireReusableSession;
 }
-
+//#endregion
+//#region src/agent/harness-agent.d.ts
 /**
  * Required `session` extension on every `HarnessAgent.generate` /
  * `HarnessAgent.stream` call. The agent operates exclusively on the
@@ -1693,11 +1830,11 @@ declare class HarnessAgentSession {
  * state of its own.
  */
 interface HarnessAgentCallExtensions {
-    /**
-     * Active session returned by `agent.createSession(...)`. Drives the
-     * underlying harness adapter for this turn.
-     */
-    session: HarnessAgentSession;
+  /**
+   * Active session returned by `agent.createSession(...)`. Drives the
+   * underlying harness adapter for this turn.
+   */
+  session: HarnessAgentSession;
 }
 /**
  * AI SDK `Agent` implementation that drives a third-party agent runtime
@@ -1734,133 +1871,135 @@ interface HarnessAgentCallExtensions {
  *    remain owned by the caller and are not stopped or destroyed by the
  *    harness layer.
  */
-declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never, CALL_OPTIONS = never> implements Agent<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT> {
-    readonly version: "agent-v1";
-    readonly id: string | undefined;
-    /**
-     * Merged tool set exposed to AI SDK consumers: harness builtins +
-     * user-defined tools, with user tools overriding builtins on key
-     * collision. Built once at construction time so the typed surface is
-     * stable across calls.
-     */
-    readonly tools: HarnessAllTools<THarness, TUserTools>;
-    private readonly settings;
-    private readonly stopConditions;
-    private readonly sandboxConfig;
-    private readonly builtinToolFiltering;
-    private readonly permissionMode;
-    private readonly headers;
-    constructor(settings: HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, OUTPUT, CALL_OPTIONS>);
-    /** Identifier of the harness backing this agent. */
-    get harnessId(): string;
-    /** Whether this agent parses completed turns with its configured output. */
-    get hasOutput(): boolean;
-    getSandboxTemplate(): Promise<HarnessSandboxTemplate | undefined>;
-    /**
-     * Start a fresh session, or resume from state previously returned by
-     * `session.detach()` or `session.stop()`. The returned
-     * `HarnessAgentSession` must be passed to subsequent `generate` / `stream`
-     * calls; end it with `session.detach()`, `session.stop()`, or
-     * `session.destroy()`.
-     */
-    createSession(options?: {
-        /**
-         * Optional stable identifier for the underlying sandbox/session.
-         * When omitted the agent generates one. Supply the original
-         * `session.sessionId` together with `resumeFrom` to reattach a
-         * previously ended session across processes.
-         */
-        sessionId?: string;
-        /**
-         * Resume payload returned by a prior `session.detach()` or
-         * `session.stop()`. Must be accompanied by the original `sessionId`; the
-         * framework validates it against `harness.lifecycleStateSchema` before
-         * handing it to the adapter.
-         */
-        resumeFrom?: HarnessAgentResumeSessionState;
-        /**
-         * Continuation payload returned by a prior `session.suspendTurn()`. Must be
-         * accompanied by the original `sessionId`; the framework validates it before
-         * handing it to the adapter.
-         */
-        continueFrom?: HarnessAgentContinueTurnState;
-        /**
-         * Rebinds host-only tool context for an unfinished turn resumed with
-         * `continueFrom` (directly or through `resumeFrom`). Tool context is not
-         * serialized into lifecycle state because it may contain credentials or
-         * non-serializable host objects.
-         */
-        toolsContext?: ToolsContextSettings<TUserTools>['toolsContext'];
-        /**
-         * Rebinds host-only runtime context for an unfinished turn resumed with
-         * `continueFrom` (directly or through `resumeFrom`). Runtime context is
-         * not serialized into lifecycle state.
-         */
-        runtimeContext?: RUNTIME_CONTEXT;
-        /**
-         * Existing sandbox session to run the harness in. When provided, the
-         * caller retains ownership of the sandbox lifecycle.
-         */
-        sandboxSession?: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
-        abortSignal?: AbortSignal;
-    }): Promise<HarnessAgentSession>;
-    generate(options: AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
-    stream(options: AgentStreamParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
-    /**
-     * Continue the in-flight turn **without a new prompt**, draining it like
-     * {@link generate}. Used after `createSession({ continueFrom })` to finish
-     * consuming a turn that crossed a process boundary.
-     */
-    continueGenerate(options: {
-        session: HarnessAgentSession;
-        toolApprovalContinuations?: readonly ToolApprovalResponse[];
-        toolResultContinuations?: readonly ToolResultPart[];
-        abortSignal?: AbortSignal;
-    }): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
-    /**
-     * Continue the in-flight turn **without a new prompt**, streaming its events
-     * like {@link stream}. Used to keep consuming a turn that is still running
-     * (or finished) in the runtime after a process boundary — the workflow slice
-     * loop calls this on every slice after the first. Routes through the adapter's
-     * `doContinueTurn`; what it can guarantee (lossless attach vs. lossy rerun)
-     * follows from how the adapter resumed the session.
-     */
-    continueStream(options: {
-        session: HarnessAgentSession;
-        toolApprovalContinuations?: readonly ToolApprovalResponse[];
-        toolResultContinuations?: readonly ToolResultPart[];
-        abortSignal?: AbortSignal;
-    }): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
-    /**
-     * Submit another user message to a currently running session turn.
-     *
-     * The returned promise resolves after the runtime has accepted the message
-     * for its next safe input boundary. Output caused by the message remains in
-     * the current turn's stream.
-     */
-    experimental_steer(options: {
-        session: HarnessAgentSession;
-        text: string;
-    }): Promise<void>;
-    private _startPromptTurn;
-    private _startContinueTurn;
-    private _buildTurnOptions;
-    private _resolveLifecycleCallbacks;
-    private _resolveContinueTurnInput;
-    private _resolvePromptTurnInput;
-    private _preparePromptTurnInput;
-    private _prepareContinueTurnInput;
-    private _prepareTurnSettings;
-    private _toToolSpecs;
-    private _toGenerateResult;
-    private _resolveResponseFormat;
+export declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never, CALL_OPTIONS = never> implements Agent<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT> {
+  readonly version: "agent-v1";
+  readonly id: string | undefined;
+  /**
+   * Merged tool set exposed to AI SDK consumers: harness builtins +
+   * user-defined tools, with user tools overriding builtins on key
+   * collision. Built once at construction time so the typed surface is
+   * stable across calls.
+   */
+  readonly tools: HarnessAllTools<THarness, TUserTools>;
+  private readonly settings;
+  private readonly stopConditions;
+  private readonly sandboxConfig;
+  private readonly builtinToolFiltering;
+  private readonly permissionMode;
+  private readonly headers;
+  constructor(settings: HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, OUTPUT, CALL_OPTIONS>);
+  /** Identifier of the harness backing this agent. */
+  get harnessId(): string;
+  /** Whether this agent parses completed turns with its configured output. */
+  get hasOutput(): boolean;
+  getSandboxTemplate(): Promise<HarnessSandboxTemplate | undefined>;
+  /**
+   * Start a fresh session, or resume from state previously returned by
+   * `session.detach()` or `session.stop()`. The returned
+   * `HarnessAgentSession` must be passed to subsequent `generate` / `stream`
+   * calls; end it with `session.detach()`, `session.stop()`, or
+   * `session.destroy()`.
+   */
+  createSession(options?: {
+    /**
+     * Optional stable identifier for the underlying sandbox/session.
+     * When omitted the agent generates one. Supply the original
+     * `session.sessionId` together with `resumeFrom` to reattach a
+     * previously ended session across processes.
+     */
+    sessionId?: string;
+    /**
+     * Resume payload returned by a prior `session.detach()` or
+     * `session.stop()`. Must be accompanied by the original `sessionId`; the
+     * framework validates it against `harness.lifecycleStateSchema` before
+     * handing it to the adapter.
+     */
+    resumeFrom?: HarnessAgentResumeSessionState;
+    /**
+     * Continuation payload returned by a prior `session.suspendTurn()`. Must be
+     * accompanied by the original `sessionId`; the framework validates it before
+     * handing it to the adapter.
+     */
+    continueFrom?: HarnessAgentContinueTurnState;
+    /**
+     * Rebinds host-only tool context for an unfinished turn resumed with
+     * `continueFrom` (directly or through `resumeFrom`). Tool context is not
+     * serialized into lifecycle state because it may contain credentials or
+     * non-serializable host objects.
+     */
+    toolsContext?: ToolsContextSettings<TUserTools>['toolsContext'];
+    /**
+     * Rebinds host-only runtime context for an unfinished turn resumed with
+     * `continueFrom` (directly or through `resumeFrom`). Runtime context is
+     * not serialized into lifecycle state.
+     */
+    runtimeContext?: RUNTIME_CONTEXT;
+    /**
+     * Existing sandbox session to run the harness in. When provided, the
+     * caller retains ownership of the sandbox lifecycle.
+     */
+    sandboxSession?: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+    abortSignal?: AbortSignal;
+  }): Promise<HarnessAgentSession>;
+  generate(options: AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+  stream(options: AgentStreamParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+  /**
+   * Continue the in-flight turn **without a new prompt**, draining it like
+   * {@link generate}. Used after `createSession({ continueFrom })` to finish
+   * consuming a turn that crossed a process boundary.
+   */
+  continueGenerate(options: {
+    session: HarnessAgentSession;
+    toolApprovalContinuations?: readonly ToolApprovalResponse[];
+    toolResultContinuations?: readonly ToolResultPart[];
+    abortSignal?: AbortSignal;
+  }): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+  /**
+   * Continue the in-flight turn **without a new prompt**, streaming its events
+   * like {@link stream}. Used to keep consuming a turn that is still running
+   * (or finished) in the runtime after a process boundary — the workflow slice
+   * loop calls this on every slice after the first. Routes through the adapter's
+   * `doContinueTurn`; what it can guarantee (lossless attach vs. lossy rerun)
+   * follows from how the adapter resumed the session.
+   */
+  continueStream(options: {
+    session: HarnessAgentSession;
+    toolApprovalContinuations?: readonly ToolApprovalResponse[];
+    toolResultContinuations?: readonly ToolResultPart[];
+    abortSignal?: AbortSignal;
+  }): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+  /**
+   * Submit another user message to a currently running session turn.
+   *
+   * The returned promise resolves after the runtime has accepted the message
+   * for its next safe input boundary. Output caused by the message remains in
+   * the current turn's stream.
+   */
+  experimental_steer(options: {
+    session: HarnessAgentSession;
+    text: string;
+  }): Promise<void>;
+  private _startPromptTurn;
+  private _startContinueTurn;
+  private _buildTurnOptions;
+  private _resolveLifecycleCallbacks;
+  private _resolveContinueTurnInput;
+  private _resolvePromptTurnInput;
+  private _preparePromptTurnInput;
+  private _prepareContinueTurnInput;
+  private _prepareTurnSettings;
+  private _toToolSpecs;
+  private _toGenerateResult;
+  private _resolveResponseFormat;
 }
-
-declare function createHarnessSandboxTemplate(options: {
-    readonly harnesses: ReadonlyArray<HarnessAgentAdapter>;
-    readonly sandboxConfig?: Omit<HarnessAgentSandboxConfig, 'onSession'>;
+//#endregion
+//#region src/agent/create-harness-sandbox-template.d.ts
+export declare function createHarnessSandboxTemplate(options: {
+  readonly harnesses: ReadonlyArray<HarnessAgentAdapter>;
+  readonly sandboxConfig?: Omit<HarnessAgentSandboxConfig, 'onSession'>;
 }): Promise<HarnessSandboxTemplate | undefined>;
-
+//#endregion
+//#region src/agent/harness-agent-tool-approval-continuation.d.ts
 /**
  * Extract approval decisions that should continue a suspended harness turn.
  *
@@ -1871,17 +2010,19 @@ declare function createHarnessSandboxTemplate(options: {
  * Responses that already have a tool result are ignored, because those
  * approvals were already consumed by a prior continuation.
  */
-declare function collectHarnessAgentToolApprovalContinuations(input: {
-    messages: readonly ModelMessage[];
+export declare function collectHarnessAgentToolApprovalContinuations(input: {
+  messages: readonly ModelMessage[];
 }): readonly ToolApprovalResponse[];
-
+//#endregion
+//#region src/agent/harness-agent-tool-result-continuation.d.ts
 /**
  * Extract client-provided tool results from the trailing tool message.
  */
-declare function collectHarnessAgentToolResultContinuations(input: {
-    messages: readonly ModelMessage[];
+export declare function collectHarnessAgentToolResultContinuations(input: {
+  messages: readonly ModelMessage[];
 }): readonly ToolResultPart[];
-
+//#endregion
+//#region src/agent/prepare-harness-sandbox-template.d.ts
 type SandboxBootstrapSettings = Omit<HarnessAgentSandboxConfig, 'onSession'>;
 /**
  * Prepare a harness's sandbox template without running an agent. Idempotent: if
@@ -1897,20 +2038,21 @@ type SandboxBootstrapSettings = Omit<HarnessAgentSandboxConfig, 'onSession'>;
  * provider's native storage.
  * @deprecated Use `createHarnessSandboxTemplate` and pass its template to a sandbox session creator instead.
  */
-declare function prepareHarnessSandboxTemplate(options: {
-    readonly harness: HarnessAgentAdapter;
-    readonly sandboxProvider: HarnessV1SandboxProvider;
-    readonly sandboxConfig?: SandboxBootstrapSettings;
-    readonly abortSignal?: AbortSignal;
+export declare function prepareHarnessSandboxTemplate(options: {
+  readonly harness: HarnessAgentAdapter;
+  readonly sandboxProvider: HarnessV1SandboxProvider;
+  readonly sandboxConfig?: SandboxBootstrapSettings;
+  readonly abortSignal?: AbortSignal;
 }): Promise<void>;
 /** @deprecated Use `prepareHarnessSandboxTemplate` instead. */
-declare const prewarmHarness: typeof prepareHarnessSandboxTemplate;
-
+export declare const prewarmHarness: typeof prepareHarnessSandboxTemplate;
+//#endregion
+//#region src/agent/prepare-sandbox-for-harness.d.ts
 /** @deprecated Use `createHarnessSandboxTemplate` and `template.prepare` instead. */
 type PrepareSandboxForHarnessResult = {
-    readonly identity?: string;
-    readonly recipeIdentities: Record<string, string>;
-    readonly skippedHarnessIds: ReadonlyArray<string>;
+  readonly identity?: string;
+  readonly recipeIdentities: Record<string, string>;
+  readonly skippedHarnessIds: ReadonlyArray<string>;
 };
 /**
  * Apply one or more harness bootstrap recipes to an existing sandbox session.
@@ -1933,28 +2075,30 @@ type PrepareSandboxForHarnessResult = {
  * ID, the last adapter in `harnesses` is used.
  * @deprecated Use `createHarnessSandboxTemplate` and `template.prepare` instead.
  */
-declare function prepareSandboxForHarness(options: {
-    readonly session: Experimental_SandboxSession;
-    readonly harnesses: ReadonlyArray<HarnessAgentAdapter>;
-    readonly sandboxConfig?: HarnessAgentSandboxConfig;
-    readonly abortSignal?: AbortSignal;
+export declare function prepareSandboxForHarness(options: {
+  readonly session: Experimental_SandboxSession;
+  readonly harnesses: ReadonlyArray<HarnessAgentAdapter>;
+  readonly sandboxConfig?: HarnessAgentSandboxConfig;
+  readonly abortSignal?: AbortSignal;
 }): Promise<PrepareSandboxForHarnessResult>;
-
+//#endregion
+//#region src/errors/harness-error.d.ts
 declare const symbol$2: unique symbol;
 /**
  * Base error type for failures originating in or signalled by a harness
  * adapter. Specific failure modes (e.g. unsupported capability) extend this
  * class.
  */
-declare class HarnessError extends AISDKError {
-    private readonly [symbol$2];
-    constructor({ message, cause }: {
-        message: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is HarnessError;
+export declare class HarnessError extends AISDKError {
+  private readonly [symbol$2];
+  constructor({ message, cause }: {
+    message: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is HarnessError;
 }
-
+//#endregion
+//#region src/errors/harness-capability-unsupported-error.d.ts
 declare const symbol$1: unique symbol;
 /**
  * Thrown when a caller asks the harness to do something the adapter (or the
@@ -1965,17 +2109,18 @@ declare const symbol$1: unique symbol;
  * The caller supplies the full human-readable message. Optional `harnessId`
  * is recorded as structured context for tooling.
  */
-declare class HarnessCapabilityUnsupportedError extends HarnessError {
-    private readonly [symbol$1];
-    readonly harnessId?: string;
-    constructor({ message, harnessId, cause, }: {
-        message: string;
-        harnessId?: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is HarnessCapabilityUnsupportedError;
+export declare class HarnessCapabilityUnsupportedError extends HarnessError {
+  private readonly [symbol$1];
+  readonly harnessId?: string;
+  constructor({ message, harnessId, cause }: {
+    message: string;
+    harnessId?: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is HarnessCapabilityUnsupportedError;
 }
-
+//#endregion
+//#region src/errors/harness-sandbox-authentication-error.d.ts
 declare const symbol: unique symbol;
 /**
  * Thrown when a sandbox provider cannot authenticate or authorize the
@@ -1983,25 +2128,27 @@ declare const symbol: unique symbol;
  * preserve the underlying SDK failure as `cause` and supply a message that
  * explains how the consumer can configure credentials.
  */
-declare class HarnessSandboxAuthenticationError extends HarnessError {
-    private readonly [symbol];
-    readonly sandboxProviderId: string;
-    constructor({ message, sandboxProviderId, cause, }: {
-        message: string;
-        sandboxProviderId: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is HarnessSandboxAuthenticationError;
+export declare class HarnessSandboxAuthenticationError extends HarnessError {
+  private readonly [symbol];
+  readonly sandboxProviderId: string;
+  constructor({ message, sandboxProviderId, cause }: {
+    message: string;
+    sandboxProviderId: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is HarnessSandboxAuthenticationError;
 }
-
+//#endregion
+//#region src/agent/get-harness-error-message.d.ts
 /**
  * Returns a client-safe message for errors produced by the harness runtime.
  * Messages from explicitly reviewed harness error types are preserved. All
  * other errors are masked so provider, sandbox, and server details are not
  * exposed to clients by default.
  */
-declare function getHarnessErrorMessage(error: unknown): string;
-
+export declare function getHarnessErrorMessage(error: unknown): string;
+//#endregion
+//#region src/agent/observability/file-reporter.d.ts
 /**
  * A harness observability reporter that writes a unified, non-lossy
  * `events.jsonl` containing **both** the telemetry span lifecycle (turn / step
@@ -2014,20 +2161,21 @@ declare function getHarnessErrorMessage(error: unknown): string;
  * replacement for the original SDK's host-side artifact files.
  */
 interface FileReporterOptions {
-    /** Directory for `events.jsonl` (created if absent). */
-    dir: string;
-    /**
-     * Buffer a turn's records in memory and write them only if the turn produced
-     * an error (an `error`-level diagnostic, a failed tool, or an error finish).
-     * Default false (write everything).
-     */
-    failOnly?: boolean;
-    /** File name within `dir`. Default `events.jsonl`. */
-    fileName?: string;
+  /** Directory for `events.jsonl` (created if absent). */
+  dir: string;
+  /**
+   * Buffer a turn's records in memory and write them only if the turn produced
+   * an error (an `error`-level diagnostic, a failed tool, or an error finish).
+   * Default false (write everything).
+   */
+  failOnly?: boolean;
+  /** File name within `dir`. Default `events.jsonl`. */
+  fileName?: string;
 }
 type FileReporter = Telemetry & HarnessDiagnosticConsumer;
-declare function createFileReporter(options: FileReporterOptions): FileReporter;
-
+export declare function createFileReporter(options: FileReporterOptions): FileReporter;
+//#endregion
+//#region src/agent/observability/trace-tree-reporter.d.ts
 /**
  * A harness observability reporter that renders an ASCII trace tree of a
  * turn's span lifecycle (turn → steps → tools) to a stream at turn end. It is a
@@ -2036,9 +2184,10 @@ declare function createFileReporter(options: FileReporterOptions): FileReporter;
  * backend (via `@ai-sdk/otel`) is a strict superset.
  */
 interface TraceTreeReporterOptions {
-    /** Where to write the rendered tree. Default `process.stderr.write`. */
-    write?: (chunk: string) => void;
+  /** Where to write the rendered tree. Default `process.stderr.write`. */
+  write?: (chunk: string) => void;
 }
-declare function createTraceTreeReporter(options?: TraceTreeReporterOptions): Telemetry;
-
-export { type FileReporter, type FileReporterOptions, HarnessAgent, type HarnessAgentAdapter, type HarnessAgentAdapterSession, type HarnessAgentBuiltinTool, type HarnessAgentBuiltinToolName, type HarnessAgentBuiltinToolUseKind, type HarnessAgentBuiltinTools, type HarnessAgentContinueTurnOptions, type HarnessAgentContinueTurnState, type HarnessAgentLifecycleState, type HarnessAgentPendingToolApproval, type HarnessAgentPendingToolResult, type HarnessAgentPermissionMode, type HarnessAgentPrompt, type HarnessAgentPromptControl, type HarnessAgentPromptTurnOptions, type HarnessAgentResumeSessionState, type HarnessAgentSandboxConfig, HarnessAgentSession, type HarnessAgentSettings, type HarnessAgentSkill, type HarnessAgentStartOptions, type HarnessAgentStreamPart, type HarnessAgentToolApprovalConfiguration, type HarnessAgentToolSpec, type HarnessAllTools, HarnessCapabilityUnsupportedError, type HarnessDebugConfig, type HarnessDebugLevel, type HarnessDiagnostic, type HarnessDiagnosticConsumer, HarnessError, HarnessSandboxAuthenticationError, type HarnessSandboxTemplate, type PrepareSandboxForHarnessResult, type TraceTreeReporterOptions, collectHarnessAgentToolApprovalContinuations, collectHarnessAgentToolResultContinuations, createFileReporter, createHarnessSandboxTemplate, createTraceTreeReporter, getHarnessErrorMessage, prepareHarnessSandboxTemplate, prepareSandboxForHarness, prewarmHarness };
+export declare function createTraceTreeReporter(options?: TraceTreeReporterOptions): Telemetry;
+//#endregion
+export type { FileReporter, FileReporterOptions, HarnessAgentAdapter, HarnessAgentAdapterSession, HarnessAgentBuiltinTool, HarnessAgentBuiltinToolName, HarnessAgentBuiltinToolUseKind, HarnessAgentBuiltinTools, HarnessAgentContinueTurnOptions, HarnessAgentContinueTurnState, HarnessAgentLifecycleState, HarnessAgentPendingToolApproval, HarnessAgentPendingToolResult, HarnessAgentPermissionMode, HarnessAgentPrompt, HarnessAgentPromptControl, HarnessAgentPromptTurnOptions, HarnessAgentResumeSessionState, HarnessAgentSandboxConfig, HarnessAgentSettings, HarnessAgentSkill, HarnessAgentStartOptions, HarnessAgentStreamPart, HarnessAgentToolApprovalConfiguration, HarnessAgentToolSpec, HarnessAllTools, HarnessDebugConfig, HarnessDebugLevel, HarnessDiagnostic, HarnessDiagnosticConsumer, HarnessSandboxTemplate, PrepareSandboxForHarnessResult, TraceTreeReporterOptions };
+//# sourceMappingURL=index.d.ts.map