@ai-sdk/harness 1.0.133 → 1.0.134

package/dist/index.d.ts

@@ -1,9 +1,7 @@
-import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Experimental_SandboxSession, UserModelMessage, ToolResultPart, ProviderOptions, ToolSet, FlexibleSchema, Tool, FunctionTool } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-import * as _ai_sdk_provider from '@ai-sdk/provider';
-import { JSONSchema7, JSONValue, LanguageModelV4StreamPart, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, SharedV4ProviderMetadata, LanguageModelV4TextPart, LanguageModelV4FilePart, LanguageModelV4CustomPart, LanguageModelV4ReasoningPart, LanguageModelV4ReasoningFilePart, LanguageModelV4ToolCallPart, LanguageModelV4ToolResultPart, LanguageModelV4ToolResultOutput, LanguageModelV4ToolApprovalResponsePart, AISDKError } from '@ai-sdk/provider';
-
+import { Experimental_SandboxSession, FlexibleSchema, FunctionTool, ProviderOptions, Tool, ToolResultPart, ToolSet, UserModelMessage } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { AISDKError, JSONSchema7, JSONValue, LanguageModelV4CustomPart, LanguageModelV4FilePart, LanguageModelV4FinishReason, LanguageModelV4ReasoningFilePart, LanguageModelV4ReasoningPart, LanguageModelV4StreamPart, LanguageModelV4TextPart, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolApprovalResponsePart, LanguageModelV4ToolCall, LanguageModelV4ToolCallPart, LanguageModelV4ToolResult, LanguageModelV4ToolResultOutput, LanguageModelV4ToolResultPart, LanguageModelV4Usage, SharedV4ProviderMetadata } from "@ai-sdk/provider";
+//#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
@@ -11,8 +9,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.
@@ -20,7 +18,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
@@ -29,32 +27,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>>;
 };
 /**
  * Fixed, non-configurable path for harness-generated state (bootstrap files,
@@ -65,8 +64,8 @@ type HarnessV1PortEndpoint = {
  * framework also calls this with a symbolic `$HOME` when hashing bootstrap
  * recipes, so changes to the state path invalidate existing templates.
  */
-declare function harnessStateDirectoryPath({ sandboxHomeDir, }: {
-    sandboxHomeDir: string;
+export declare function harnessStateDirectoryPath({ sandboxHomeDir }: {
+  sandboxHomeDir: string;
 }): string;
 /**
  * Network sandbox session returned by sandbox adapter creation and resume
@@ -80,94 +79,94 @@ declare function harnessStateDirectoryPath({ sandboxHomeDir, }: {
  * 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.
@@ -185,37 +184,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
@@ -229,30 +228,31 @@ 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>>;
+  };
 };
 type HarnessV1RequestTransformationSources<AuthenticationMode> = {
-    env: Record<string, string>;
-    sandboxEnv: Record<string, string>;
-    auth: AuthenticationMode;
+  env: Record<string, string>;
+  sandboxEnv: Record<string, string>;
+  auth: AuthenticationMode;
 };
-
+//#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";
+export declare const harnessV1DebugLevelSchema: z.ZodEnum<{
+  error: "error";
+  warn: "warn";
+  info: "info";
+  debug: "debug";
+  trace: "trace";
 }>;
 type HarnessV1DebugLevel = z.infer<typeof harnessV1DebugLevelSchema>;
 /**
@@ -261,16 +261,16 @@ type HarnessV1DebugLevel = z.infer<typeof harnessV1DebugLevelSchema>;
  * captures and emits nothing. `subsystems` filters structured events by dotted
  * 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>>;
+export 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>>;
 }, z.core.$strip>;
 type HarnessV1DebugConfig = z.infer<typeof harnessV1DebugConfigSchema>;
 /**
@@ -279,32 +279,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
@@ -314,12 +315,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.
  *
@@ -328,7 +330,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`.
  *
@@ -338,7 +341,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`.
  *
@@ -349,41 +353,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;
 /**
@@ -395,46 +399,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.
@@ -446,43 +452,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
@@ -490,47 +497,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
@@ -538,12 +545,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
@@ -551,27 +558,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.
  *
@@ -580,18 +588,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.
  *
@@ -603,7 +612,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.
  *
@@ -619,176 +629,176 @@ 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;
 };
-declare const harnessV1StreamStartPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"stream-start">;
-    warnings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<HarnessV1CallWarning, unknown, z.core.$ZodTypeInternals<HarnessV1CallWarning, unknown>>>>>;
-    modelId: z.ZodOptional<z.ZodString>;
+export declare const harnessV1StreamStartPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"stream-start">;
+  warnings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<HarnessV1CallWarning, unknown, z.core.$ZodTypeInternals<HarnessV1CallWarning, unknown>>>>>;
+  modelId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const harnessV1TextStartPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"text-start">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1TextStartPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text-start">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1TextDeltaPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"text-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1TextDeltaPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1TextEndPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"text-end">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1TextEndPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text-end">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1ReasoningStartPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-start">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1ReasoningStartPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"reasoning-start">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1ReasoningDeltaPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1ReasoningDeltaPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"reasoning-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1ReasoningEndPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-end">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1ReasoningEndPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"reasoning-end">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1ToolCallPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool-call">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    input: z.ZodString;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
-    nativeName: z.ZodOptional<z.ZodString>;
-    stepToolCallCount: z.ZodOptional<z.ZodNumber>;
+export declare const harnessV1ToolCallPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"tool-call">;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  input: z.ZodString;
+  providerExecuted: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  nativeName: z.ZodOptional<z.ZodString>;
+  stepToolCallCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-declare const harnessV1ToolApprovalRequestPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool-approval-request">;
-    approvalId: z.ZodString;
-    toolCallId: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+export declare const harnessV1ToolApprovalRequestPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"tool-approval-request">;
+  approvalId: z.ZodString;
+  toolCallId: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1ToolResultPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool-result">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    result: z.ZodType<NonNullable<JSONValue>, unknown, z.core.$ZodTypeInternals<NonNullable<JSONValue>, unknown>>;
-    isError: z.ZodOptional<z.ZodBoolean>;
-    preliminary: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+export declare const harnessV1ToolResultPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"tool-result">;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  result: z.ZodType<NonNullable<JSONValue>, unknown, z.core.$ZodTypeInternals<NonNullable<JSONValue>, unknown>>;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  preliminary: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1FinishStepPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"finish-step">;
-    finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
-    usage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1FinishStepPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"finish-step">;
+  finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
+  usage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1FinishPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"finish">;
-    finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
-    totalUsage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1FinishPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"finish">;
+  finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
+  totalUsage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1FileChangePartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"file-change">;
-    event: z.ZodEnum<{
-        create: "create";
-        modify: "modify";
-        delete: "delete";
-    }>;
-    path: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+export declare const harnessV1FileChangePartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"file-change">;
+  event: z.ZodEnum<{
+    create: "create";
+    modify: "modify";
+    delete: "delete";
+  }>;
+  path: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>;
-declare const harnessV1ErrorPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    error: z.ZodUnknown;
+export declare const harnessV1ErrorPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"error">;
+  error: z.ZodUnknown;
 }, z.core.$strip>;
-declare const harnessV1RawPartSchema: z.ZodObject<{
-    type: z.ZodLiteral<"raw">;
-    rawValue: z.ZodUnknown;
+export declare const harnessV1RawPartSchema: z.ZodObject<{
+  type: z.ZodLiteral<"raw">;
+  rawValue: z.ZodUnknown;
 }, z.core.$strip>;
 /**
  * Assembled discriminated union over every `HarnessV1StreamPart` variant. Left
@@ -796,116 +806,117 @@ declare const harnessV1RawPartSchema: z.ZodObject<{
  * composes the individual member schemas, and the type test asserts the
  * inferred union equals `HarnessV1StreamPart`.
  */
-declare const harnessV1StreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"stream-start">;
-    warnings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<HarnessV1CallWarning, unknown, z.core.$ZodTypeInternals<HarnessV1CallWarning, unknown>>>>>;
-    modelId: z.ZodOptional<z.ZodString>;
+export declare const harnessV1StreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"stream-start">;
+  warnings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<HarnessV1CallWarning, unknown, z.core.$ZodTypeInternals<HarnessV1CallWarning, unknown>>>>>;
+  modelId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-start">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"text-start">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"text-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-end">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"text-end">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-start">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"reasoning-start">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"reasoning-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-end">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"reasoning-end">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-input-start">;
-    id: z.ZodString;
-    toolName: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    title: z.ZodOptional<z.ZodString>;
+  type: z.ZodLiteral<"tool-input-start">;
+  id: z.ZodString;
+  toolName: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  providerExecuted: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  title: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-input-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-input-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-input-end">;
-    id: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-input-end">;
+  id: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-call">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    input: z.ZodString;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
-    nativeName: z.ZodOptional<z.ZodString>;
-    stepToolCallCount: z.ZodOptional<z.ZodNumber>;
+  type: z.ZodLiteral<"tool-call">;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  input: z.ZodString;
+  providerExecuted: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  nativeName: z.ZodOptional<z.ZodString>;
+  stepToolCallCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-approval-request">;
-    approvalId: z.ZodString;
-    toolCallId: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-approval-request">;
+  approvalId: z.ZodString;
+  toolCallId: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-result">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    result: z.ZodType<NonNullable<JSONValue>, unknown, z.core.$ZodTypeInternals<NonNullable<JSONValue>, unknown>>;
-    isError: z.ZodOptional<z.ZodBoolean>;
-    preliminary: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-result">;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  result: z.ZodType<NonNullable<JSONValue>, unknown, z.core.$ZodTypeInternals<NonNullable<JSONValue>, unknown>>;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  preliminary: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  providerMetadata: z.ZodOptional<z.ZodType<SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"finish-step">;
-    finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
-    usage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"finish-step">;
+  finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
+  usage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"finish">;
-    finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
-    totalUsage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"finish">;
+  finishReason: z.ZodType<LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<LanguageModelV4FinishReason, unknown>>;
+  totalUsage: z.ZodType<LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<LanguageModelV4Usage, unknown>>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"file-change">;
-    event: z.ZodEnum<{
-        create: "create";
-        modify: "modify";
-        delete: "delete";
-    }>;
-    path: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"file-change">;
+  event: z.ZodEnum<{
+    create: "create";
+    modify: "modify";
+    delete: "delete";
+  }>;
+  path: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"compaction">;
-    trigger: z.ZodEnum<{
-        manual: "manual";
-        auto: "auto";
-    }>;
-    summary: z.ZodString;
-    tokensBefore: z.ZodOptional<z.ZodNumber>;
-    tokensAfter: z.ZodOptional<z.ZodNumber>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"compaction">;
+  trigger: z.ZodEnum<{
+    manual: "manual";
+    auto: "auto";
+  }>;
+  summary: z.ZodString;
+  tokensBefore: z.ZodOptional<z.ZodNumber>;
+  tokensAfter: z.ZodOptional<z.ZodNumber>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    error: z.ZodUnknown;
+  type: z.ZodLiteral<"error">;
+  error: z.ZodUnknown;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"raw">;
-    rawValue: z.ZodUnknown;
+  type: z.ZodLiteral<"raw">;
+  rawValue: z.ZodUnknown;
 }, z.core.$strip>]>;
-
+//#endregion
+//#region src/v1/harness-v1-message.d.ts
 type LanguageModelV4ToolResultContentPart = Extract<LanguageModelV4ToolResultOutput, {
-    type: 'content';
+  type: 'content';
 }>['value'][number];
 type HarnessV1TextPart = Omit<LanguageModelV4TextPart, 'providerOptions'>;
 type HarnessV1FilePart = Omit<LanguageModelV4FilePart, 'providerOptions'>;
@@ -913,72 +924,74 @@ type HarnessV1CustomPart = Omit<LanguageModelV4CustomPart, 'providerOptions'>;
 type HarnessV1ReasoningPart = Omit<LanguageModelV4ReasoningPart, 'providerOptions'>;
 type HarnessV1ReasoningFilePart = Omit<LanguageModelV4ReasoningFilePart, 'providerOptions'>;
 type HarnessV1ToolCallPart = Omit<LanguageModelV4ToolCallPart, 'providerOptions'> & {
-    nativeName?: string;
+  nativeName?: string;
 };
 type HarnessV1ToolResultOutput = Omit<Extract<LanguageModelV4ToolResultOutput, {
-    type: 'text';
+  type: 'text';
 }>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
-    type: 'json';
+  type: 'json';
 }>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
-    type: 'execution-denied';
+  type: 'execution-denied';
 }>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
-    type: 'error-text';
+  type: 'error-text';
 }>, 'providerOptions'> | Omit<Extract<LanguageModelV4ToolResultOutput, {
-    type: 'error-json';
+  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: '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;
+  output: HarnessV1ToolResultOutput;
 };
 type HarnessV1ToolApprovalResponsePart = Omit<LanguageModelV4ToolApprovalResponsePart, 'providerOptions'>;
 type HarnessV1MessagePart = HarnessV1TextPart | HarnessV1FilePart | HarnessV1CustomPart | HarnessV1ReasoningPart | HarnessV1ReasoningFilePart | HarnessV1ToolCallPart | HarnessV1ToolResultPart | HarnessV1ToolApprovalResponsePart;
 type HarnessV1UserMessage = {
-    readonly role: 'user';
-    readonly content: Array<HarnessV1TextPart | HarnessV1FilePart>;
-    readonly at?: string;
-    readonly harnessMetadata?: HarnessV1Metadata;
+  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;
+  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;
+  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[];
 };
-declare function isHarnessV1BuiltinToolIncluded(input: {
-    toolName: string;
-    toolFiltering: HarnessV1BuiltinToolFiltering | undefined;
+export declare function isHarnessV1BuiltinToolIncluded(input: {
+  toolName: string;
+  toolFiltering: HarnessV1BuiltinToolFiltering | undefined;
 }): boolean;
-declare function getHarnessV1BuiltinToolFilteringDenialReason(input: {
-    toolName: string;
+export declare function getHarnessV1BuiltinToolFilteringDenialReason(input: {
+  toolName: string;
 }): string;
-
+//#endregion
+//#region src/v1/harness-v1-session.d.ts
 /**
  * Options passed to `HarnessV1.doStart`.
  *
@@ -987,101 +1000,101 @@ declare function getHarnessV1BuiltinToolFilteringDenialReason(input: {
  * 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;
+  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`.
@@ -1091,21 +1104,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`.
@@ -1116,121 +1129,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>;
-    /**
-     * 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>;
+  /**
+   * 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, …).
@@ -1245,73 +1259,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-authentication.d.ts
 /**
  * Authentication-related environment variables supplied directly to a harness.
  *
@@ -1323,10 +1338,9 @@ type HarnessV1AuthenticationEnvironment = Readonly<Record<string, string>>;
  * Authentication options shared by harness adapters. Adapter choices must be
  * a non-empty union of concrete string values.
  */
-type HarnessV1Authentication<ADAPTER_CHOICES extends string = 'direct'> = [
-    ADAPTER_CHOICES
-] extends [never] ? never : string extends ADAPTER_CHOICES ? never : 'auto' | 'ai-gateway' | ADAPTER_CHOICES | HarnessV1AuthenticationEnvironment;
-
+type HarnessV1Authentication<ADAPTER_CHOICES extends string = 'direct'> = [ADAPTER_CHOICES] extends [never] ? never : string extends ADAPTER_CHOICES ? never : 'auto' | 'ai-gateway' | ADAPTER_CHOICES | HarnessV1AuthenticationEnvironment;
+//#endregion
+//#region src/v1/harness-v1-credential-forwarding.d.ts
 /**
  * Customizes a credential value immediately before a harness adapter forwards
  * it into a sandbox process.
@@ -1336,24 +1350,26 @@ type HarnessV1Authentication<ADAPTER_CHOICES extends string = 'direct'> = [
  * otherwise access in the host process.
  */
 type HarnessV1CredentialForwarding = (options: {
-    /**
-     * The credential value that the adapter would otherwise forward. This is a
-     * generated sandbox placeholder when credential brokering is available and
-     * the real credential otherwise. Use `isSandboxCredentialPlaceholder` from
-     * `@ai-sdk/harness/utils` to distinguish generated placeholders.
-     */
-    readonly credential: string;
-    /** The environment variable name used to expose the value in the sandbox. */
-    readonly environmentVariableName: string;
+  /**
+   * The credential value that the adapter would otherwise forward. This is a
+   * generated sandbox placeholder when credential brokering is available and
+   * the real credential otherwise. Use `isSandboxCredentialPlaceholder` from
+   * `@ai-sdk/harness/utils` to distinguish generated placeholders.
+   */
+  readonly credential: string;
+  /** The environment variable name used to expose the value in the sandbox. */
+  readonly environmentVariableName: string;
 }) => string | PromiseLike<string>;
-
+//#endregion
+//#region src/v1/harness-v1-mint-bridge-token.d.ts
 /**
  * Creates the authentication token a bridge-backed harness adapter uses to
  * secure its sandbox bridge channel for one session. Defaults to a random
  * 32-byte hexadecimal token when omitted.
  */
 type HarnessV1MintBridgeTokenCallback = (sandboxId: string) => string;
-
+//#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
@@ -1363,68 +1379,68 @@ type HarnessV1MintBridgeTokenCallback = (sandboxId: string) => string;
  * Used both as runtime values (spread into `ToolSet`s for inspection) and as
  * 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";
+export declare const HARNESS_V1_BUILTIN_TOOLS: {
+  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;
-declare const HARNESS_V1_BUILTIN_TOOL_NAMES: ReadonlyArray<HarnessV1BuiltinToolName>;
+export declare const HARNESS_V1_BUILTIN_TOOL_NAMES: ReadonlyArray<HarnessV1BuiltinToolName>;
 type HarnessV1BuiltinToolUseKind = 'readonly' | 'edit' | 'bash';
 /**
  * A tool that the adapter's underlying runtime exposes natively. Extends the
@@ -1445,19 +1461,16 @@ 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;
 };
 type InputOf<T> = T extends Tool<infer I, any, any> ? I : never;
 type StandardInputOf<N extends HarnessV1BuiltinToolName> = InputOf<(typeof HARNESS_V1_BUILTIN_TOOLS)[N]>;
-type SupersetCheck<TStandard, TAdapter, TOk> = TStandard extends TAdapter ? TOk : [
-    'ERROR: adapter input schema must be a superset of the standard schema',
-    {
-        expected: TStandard;
-        got: TAdapter;
-    }
-];
+type SupersetCheck<TStandard, TAdapter, TOk> = TStandard extends TAdapter ? TOk : ['ERROR: adapter input schema must be a superset of the standard schema', {
+  expected: TStandard;
+  got: TAdapter;
+}];
 /**
  * Declare a built-in tool that maps to a cross-harness common name. The
  * adapter's input schema must accept every input the standard schema for
@@ -1468,53 +1481,55 @@ type SupersetCheck<TStandard, TAdapter, TOk> = TStandard extends TAdapter ? TOk
  * which fails the surrounding `as const satisfies ToolSet` assignment and
  * surfaces a readable TypeScript error at the offending entry.
  */
-declare function commonTool<TName extends HarnessV1BuiltinToolName, TInput>(commonName: TName, opts: {
-    readonly nativeName: string;
-    readonly toolUseKind?: HarnessV1BuiltinToolUseKind;
-    readonly description?: string;
-    readonly inputSchema: FlexibleSchema<TInput>;
+export declare function commonTool<TName extends HarnessV1BuiltinToolName, TInput>(commonName: TName, opts: {
+  readonly nativeName: string;
+  readonly toolUseKind?: HarnessV1BuiltinToolUseKind;
+  readonly description?: string;
+  readonly inputSchema: FlexibleSchema<TInput>;
 }): SupersetCheck<StandardInputOf<TName>, TInput, HarnessV1BuiltinTool<TInput>>;
-
-declare const harnessV1QuestionsToolInputSchema: z.ZodObject<{
-    allowPartialAnswers: z.ZodBoolean;
-    questions: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        header: z.ZodOptional<z.ZodString>;
-        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            preview: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        allowMultiple: z.ZodOptional<z.ZodBoolean>;
-        allowFreeForm: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-            secret: z.ZodBoolean;
-        }, z.core.$strip>]>>;
-    }, z.core.$strip>>;
+//#endregion
+//#region src/v1/harness-v1-questions-tool.d.ts
+export declare const harnessV1QuestionsToolInputSchema: z.ZodObject<{
+  allowPartialAnswers: z.ZodBoolean;
+  questions: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    header: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      label: z.ZodString;
+      description: z.ZodOptional<z.ZodString>;
+      preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    allowMultiple: z.ZodOptional<z.ZodBoolean>;
+    allowFreeForm: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+      secret: z.ZodBoolean;
+    }, z.core.$strip>]>>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const harnessV1QuestionsToolOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    action: z.ZodLiteral<"answered">;
-    answers: z.ZodRecord<z.ZodString, z.ZodObject<{
-        optionIds: z.ZodArray<z.ZodString>;
-        freeform: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+export declare const harnessV1QuestionsToolOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  action: z.ZodLiteral<"answered">;
+  answers: z.ZodRecord<z.ZodString, z.ZodObject<{
+    optionIds: z.ZodArray<z.ZodString>;
+    freeform: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
-    action: z.ZodLiteral<"partially-answered">;
-    answers: z.ZodRecord<z.ZodString, z.ZodObject<{
-        optionIds: z.ZodArray<z.ZodString>;
-        freeform: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+  action: z.ZodLiteral<"partially-answered">;
+  answers: z.ZodRecord<z.ZodString, z.ZodObject<{
+    optionIds: z.ZodArray<z.ZodString>;
+    freeform: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
-    action: z.ZodLiteral<"declined">;
+  action: z.ZodLiteral<"declined">;
 }, z.core.$strip>, z.ZodObject<{
-    action: z.ZodLiteral<"cancelled">;
+  action: z.ZodLiteral<"cancelled">;
 }, z.core.$strip>]>;
 type HarnessV1QuestionsToolInput = z.infer<typeof harnessV1QuestionsToolInputSchema>;
 type HarnessV1QuestionsToolOutput = z.infer<typeof harnessV1QuestionsToolOutputSchema>;
 declare const harnessV1QuestionsTool: FunctionTool<HarnessV1QuestionsToolInput, HarnessV1QuestionsToolOutput>;
 type HarnessV1QuestionsTool = typeof harnessV1QuestionsTool;
-
+//#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
@@ -1523,126 +1538,131 @@ type HarnessV1QuestionsTool = typeof harnessV1QuestionsTool;
  */
 /** @deprecated Supply a sandbox session to `HarnessAgent.createSession()` instead. */
 interface HarnessV1SandboxProvider {
-    readonly specificationVersion: 'harness-sandbox-v1';
-    readonly providerId: string;
+  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;
     /**
-     * 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.
+     * 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/v1/harness-v1-sandbox-session-create-options.d.ts
 type HarnessV1SandboxSessionCreateOptions<TProviderOptions extends object> = TProviderOptions & {
-    /**
-     * Manually assign the ID of a newly created sandbox session. Creation never
-     * looks up or resumes an existing session. An existing sandbox resource with
-     * the same ID is a creation conflict.
-     */
-    readonly sandboxId?: string;
-    readonly template?: HarnessV1SandboxTemplate;
-    readonly abortSignal?: AbortSignal;
+  /**
+   * Manually assign the ID of a newly created sandbox session. Creation never
+   * looks up or resumes an existing session. An existing sandbox resource with
+   * the same ID is a creation conflict.
+   */
+  readonly sandboxId?: string;
+  readonly template?: HarnessV1SandboxTemplate;
+  readonly abortSignal?: AbortSignal;
 };
-
+//#endregion
+//#region src/v1/harness-v1-sandbox-session-resume-options.d.ts
 type HarnessV1SandboxSessionResumeOptions<TProviderOptions extends object> = TProviderOptions & {
-    /**
-     * ID of the existing sandbox session to reattach. Resume never creates a
-     * sandbox when the ID cannot be found.
-     */
-    readonly sandboxId: string;
-    readonly abortSignal?: AbortSignal;
+  /**
+   * ID of the existing sandbox session to reattach. Resume never creates a
+   * sandbox when the ID cannot be found.
+   */
+  readonly sandboxId: string;
+  readonly abortSignal?: AbortSignal;
 };
-
+//#endregion
+//#region src/v1/harness-session-data-directory-path.d.ts
 /**
  * Return the per-session harness state path under `.agent-runs`. Session IDs
  * occupy one encoded path segment, so path separators and parent-directory
  * references cannot move session data outside the harness state directory.
  */
-declare function harnessSessionDataDirectoryPath({ stateDirectory, sessionId, }: {
-    stateDirectory: string;
-    sessionId: string;
+export declare function harnessSessionDataDirectoryPath({ stateDirectory, sessionId }: {
+  stateDirectory: string;
+  sessionId: string;
 }): string;
-
+//#endregion
+//#region src/v1/harness-v1-bridge-protocol.d.ts
 /**
  * The subset of a host-defined tool that travels on the `start` message. The
  * runtime only needs the name, description, and JSON-Schema input to surface
  * the tool; `execute` stays on the host.
  */
-declare const harnessV1BridgeToolWireSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    inputSchema: z.ZodOptional<z.ZodUnknown>;
+export declare const harnessV1BridgeToolWireSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  inputSchema: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 type HarnessV1BridgeToolWire = z.infer<typeof harnessV1BridgeToolWireSchema>;
-declare const harnessV1BridgePermissionModeSchema: z.ZodEnum<{
-    "allow-all": "allow-all";
-    "allow-reads": "allow-reads";
-    "allow-edits": "allow-edits";
+export declare const harnessV1BridgePermissionModeSchema: z.ZodEnum<{
+  "allow-reads": "allow-reads";
+  "allow-edits": "allow-edits";
+  "allow-all": "allow-all";
 }>;
-declare const harnessV1BridgeBuiltinToolFilteringSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    mode: z.ZodLiteral<"allow">;
-    toolNames: z.ZodArray<z.ZodString>;
+export declare const harnessV1BridgeBuiltinToolFilteringSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  mode: z.ZodLiteral<"allow">;
+  toolNames: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    mode: z.ZodLiteral<"deny">;
-    toolNames: z.ZodArray<z.ZodString>;
+  mode: z.ZodLiteral<"deny">;
+  toolNames: z.ZodArray<z.ZodString>;
 }, z.core.$strip>]>;
-declare const harnessV1BridgeResponseFormatSchema: z.ZodType<HarnessV1ResponseFormat>;
+export declare const harnessV1BridgeResponseFormatSchema: z.ZodType<HarnessV1ResponseFormat>;
 /**
  * Common fields of the inbound `start` message. Each adapter extends this with
  * its runtime-specific configuration (e.g. `thinking`/`continue` for Claude
@@ -1653,39 +1673,39 @@ declare const harnessV1BridgeResponseFormatSchema: z.ZodType<HarnessV1ResponseFo
  * a bridge concept, it just happens to ride the `start` frame for bridge-backed
  * adapters.
  */
-declare const harnessV1BridgeStartBaseSchema: z.ZodObject<{
-    type: z.ZodLiteral<"start">;
-    prompt: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        inputSchema: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>>>;
-    model: z.ZodOptional<z.ZodString>;
-    debug: z.ZodOptional<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>>;
-    }, z.core.$strip>>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
-        "allow-all": "allow-all";
-        "allow-reads": "allow-reads";
-        "allow-edits": "allow-edits";
+export declare const harnessV1BridgeStartBaseSchema: z.ZodObject<{
+  type: z.ZodLiteral<"start">;
+  prompt: z.ZodString;
+  tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodUnknown>;
+  }, z.core.$strip>>>;
+  model: z.ZodOptional<z.ZodString>;
+  debug: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    level: z.ZodOptional<z.ZodEnum<{
+      error: "error";
+      warn: "warn";
+      info: "info";
+      debug: "debug";
+      trace: "trace";
     }>>;
-    builtinToolFiltering: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        mode: z.ZodLiteral<"allow">;
-        toolNames: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        mode: z.ZodLiteral<"deny">;
-        toolNames: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>]>>;
-    responseFormat: z.ZodOptional<z.ZodType<HarnessV1ResponseFormat, unknown, z.core.$ZodTypeInternals<HarnessV1ResponseFormat, unknown>>>;
+    subsystems: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  permissionMode: z.ZodOptional<z.ZodEnum<{
+    "allow-reads": "allow-reads";
+    "allow-edits": "allow-edits";
+    "allow-all": "allow-all";
+  }>>;
+  builtinToolFiltering: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"allow">;
+    toolNames: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"deny">;
+    toolNames: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>]>>;
+  responseFormat: z.ZodOptional<z.ZodType<HarnessV1ResponseFormat, unknown, z.core.$ZodTypeInternals<HarnessV1ResponseFormat, unknown>>>;
 }, z.core.$strip>;
 /**
  * Sent the instant the bridge accepts an authenticated WS connection. The host
@@ -1694,230 +1714,230 @@ declare const harnessV1BridgeStartBaseSchema: z.ZodObject<{
  * the bridge process — anything sent in that gap is dropped. Carries the
  * bridge's lifecycle `state` and highest emitted `seq` for reconnect.
  */
-declare const harnessV1BridgeHelloSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bridge-hello">;
-    state: z.ZodOptional<z.ZodString>;
-    lastSeq: z.ZodOptional<z.ZodNumber>;
-    capabilities: z.ZodOptional<z.ZodObject<{
-        experimental_userMessageResponses: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
+export declare const harnessV1BridgeHelloSchema: z.ZodObject<{
+  type: z.ZodLiteral<"bridge-hello">;
+  state: z.ZodOptional<z.ZodString>;
+  lastSeq: z.ZodOptional<z.ZodNumber>;
+  capabilities: z.ZodOptional<z.ZodObject<{
+    experimental_userMessageResponses: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const experimental_harnessV1BridgeUserMessageResponseSchema: z.ZodObject<{
-    type: z.ZodLiteral<"user-message-response">;
-    messageId: z.ZodString;
-    accepted: z.ZodBoolean;
-    error: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
-    }, z.core.$strip>>;
+export declare const experimental_harnessV1BridgeUserMessageResponseSchema: z.ZodObject<{
+  type: z.ZodLiteral<"user-message-response">;
+  messageId: z.ZodString;
+  accepted: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodObject<{
+    message: z.ZodString;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * The bridge's reply to an inbound `stop`. Carries the adapter-specific
  * payload the host serializes into lifecycle state `data`.
  */
-declare const harnessV1BridgeStopSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bridge-stop">;
-    data: z.ZodUnknown;
+export declare const harnessV1BridgeStopSchema: z.ZodObject<{
+  type: z.ZodLiteral<"bridge-stop">;
+  data: z.ZodUnknown;
 }, z.core.$strip>;
 /**
  * A resume coordinate the bridge proactively announces (e.g. Codex's thread id)
  * so the host can cache it for a later resume without waiting for `stop`.
  */
-declare const harnessV1BridgeThreadSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bridge-thread">;
-    threadId: z.ZodString;
+export declare const harnessV1BridgeThreadSchema: z.ZodObject<{
+  type: z.ZodLiteral<"bridge-thread">;
+  threadId: z.ZodString;
 }, z.core.$strip>;
 /**
  * One captured console line from inside the sandbox. The bridge line-buffers
  * `process.stdout`/`process.stderr` and emits one of these per complete line.
  * Routed host-side to the diagnostics sink, never to the consumer stream.
  */
-declare const harnessV1BridgeSandboxLogSchema: z.ZodObject<{
-    type: z.ZodLiteral<"sandbox-log">;
-    source: z.ZodString;
-    stream: z.ZodEnum<{
-        stdout: "stdout";
-        stderr: "stderr";
-    }>;
-    line: z.ZodString;
+export declare const harnessV1BridgeSandboxLogSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sandbox-log">;
+  source: z.ZodString;
+  stream: z.ZodEnum<{
+    stdout: "stdout";
+    stderr: "stderr";
+  }>;
+  line: z.ZodString;
 }, z.core.$strip>;
 /**
  * A structured diagnostic an adapter emits from inside the bridge via
  * `turn.bridgeLog(...)`. Gated by the session's debug level + subsystem filter.
  */
-declare const harnessV1BridgeDebugEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"debug-event">;
-    level: z.ZodEnum<{
-        error: "error";
-        warn: "warn";
-        info: "info";
-        debug: "debug";
-        trace: "trace";
-    }>;
-    subsystem: z.ZodString;
+export declare const harnessV1BridgeDebugEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"debug-event">;
+  level: z.ZodEnum<{
+    error: "error";
+    warn: "warn";
+    info: "info";
+    debug: "debug";
+    trace: "trace";
+  }>;
+  subsystem: z.ZodString;
+  message: z.ZodString;
+  attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  error: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
     message: z.ZodString;
-    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    error: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        message: z.ZodString;
-        stack: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    stack: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Every frame a bridge can send to the host: the stream-part events plus the
  * transport/control frames. This is the schema the host `SandboxChannel`
  * validates inbound frames against.
  */
-declare const harnessV1BridgeOutboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"stream-start">;
-    warnings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<HarnessV1CallWarning, unknown, z.core.$ZodTypeInternals<HarnessV1CallWarning, unknown>>>>>;
-    modelId: z.ZodOptional<z.ZodString>;
+export declare const harnessV1BridgeOutboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"stream-start">;
+  warnings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<HarnessV1CallWarning, unknown, z.core.$ZodTypeInternals<HarnessV1CallWarning, unknown>>>>>;
+  modelId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-start">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"text-start">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"text-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"text-end">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"text-end">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-start">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"reasoning-start">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"reasoning-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-end">;
-    id: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"reasoning-end">;
+  id: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-input-start">;
-    id: z.ZodString;
-    toolName: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<_ai_sdk_provider.SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.SharedV4ProviderMetadata, unknown>>>;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    title: z.ZodOptional<z.ZodString>;
+  type: z.ZodLiteral<"tool-input-start">;
+  id: z.ZodString;
+  toolName: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown>>>;
+  providerExecuted: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  title: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-input-delta">;
-    id: z.ZodString;
-    delta: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<_ai_sdk_provider.SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-input-delta">;
+  id: z.ZodString;
+  delta: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-input-end">;
-    id: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<_ai_sdk_provider.SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-input-end">;
+  id: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-call">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    input: z.ZodString;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    providerMetadata: z.ZodOptional<z.ZodType<_ai_sdk_provider.SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.SharedV4ProviderMetadata, unknown>>>;
-    nativeName: z.ZodOptional<z.ZodString>;
-    stepToolCallCount: z.ZodOptional<z.ZodNumber>;
+  type: z.ZodLiteral<"tool-call">;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  input: z.ZodString;
+  providerExecuted: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  providerMetadata: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown>>>;
+  nativeName: z.ZodOptional<z.ZodString>;
+  stepToolCallCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-approval-request">;
-    approvalId: z.ZodString;
-    toolCallId: z.ZodString;
-    providerMetadata: z.ZodOptional<z.ZodType<_ai_sdk_provider.SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-approval-request">;
+  approvalId: z.ZodString;
+  toolCallId: z.ZodString;
+  providerMetadata: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-result">;
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    result: z.ZodType<NonNullable<_ai_sdk_provider.JSONValue>, unknown, z.core.$ZodTypeInternals<NonNullable<_ai_sdk_provider.JSONValue>, unknown>>;
-    isError: z.ZodOptional<z.ZodBoolean>;
-    preliminary: z.ZodOptional<z.ZodBoolean>;
-    dynamic: z.ZodOptional<z.ZodBoolean>;
-    providerMetadata: z.ZodOptional<z.ZodType<_ai_sdk_provider.SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.SharedV4ProviderMetadata, unknown>>>;
+  type: z.ZodLiteral<"tool-result">;
+  toolCallId: z.ZodString;
+  toolName: z.ZodString;
+  result: z.ZodType<NonNullable<import("@ai-sdk/provider").JSONValue>, unknown, z.core.$ZodTypeInternals<NonNullable<import("@ai-sdk/provider").JSONValue>, unknown>>;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  preliminary: z.ZodOptional<z.ZodBoolean>;
+  dynamic: z.ZodOptional<z.ZodBoolean>;
+  providerMetadata: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV4ProviderMetadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"finish-step">;
-    finishReason: z.ZodType<_ai_sdk_provider.LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.LanguageModelV4FinishReason, unknown>>;
-    usage: z.ZodType<_ai_sdk_provider.LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.LanguageModelV4Usage, unknown>>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"finish-step">;
+  finishReason: z.ZodType<import("@ai-sdk/provider").LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").LanguageModelV4FinishReason, unknown>>;
+  usage: z.ZodType<import("@ai-sdk/provider").LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").LanguageModelV4Usage, unknown>>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"finish">;
-    finishReason: z.ZodType<_ai_sdk_provider.LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.LanguageModelV4FinishReason, unknown>>;
-    totalUsage: z.ZodType<_ai_sdk_provider.LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<_ai_sdk_provider.LanguageModelV4Usage, unknown>>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"finish">;
+  finishReason: z.ZodType<import("@ai-sdk/provider").LanguageModelV4FinishReason, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").LanguageModelV4FinishReason, unknown>>;
+  totalUsage: z.ZodType<import("@ai-sdk/provider").LanguageModelV4Usage, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").LanguageModelV4Usage, unknown>>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"file-change">;
-    event: z.ZodEnum<{
-        create: "create";
-        modify: "modify";
-        delete: "delete";
-    }>;
-    path: z.ZodString;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"file-change">;
+  event: z.ZodEnum<{
+    create: "create";
+    modify: "modify";
+    delete: "delete";
+  }>;
+  path: z.ZodString;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"compaction">;
-    trigger: z.ZodEnum<{
-        manual: "manual";
-        auto: "auto";
-    }>;
-    summary: z.ZodString;
-    tokensBefore: z.ZodOptional<z.ZodNumber>;
-    tokensAfter: z.ZodOptional<z.ZodNumber>;
-    harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
+  type: z.ZodLiteral<"compaction">;
+  trigger: z.ZodEnum<{
+    manual: "manual";
+    auto: "auto";
+  }>;
+  summary: z.ZodString;
+  tokensBefore: z.ZodOptional<z.ZodNumber>;
+  tokensAfter: z.ZodOptional<z.ZodNumber>;
+  harnessMetadata: z.ZodOptional<z.ZodType<HarnessV1Metadata, unknown, z.core.$ZodTypeInternals<HarnessV1Metadata, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    error: z.ZodUnknown;
+  type: z.ZodLiteral<"error">;
+  error: z.ZodUnknown;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"raw">;
-    rawValue: z.ZodUnknown;
+  type: z.ZodLiteral<"raw">;
+  rawValue: z.ZodUnknown;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"bridge-hello">;
-    state: z.ZodOptional<z.ZodString>;
-    lastSeq: z.ZodOptional<z.ZodNumber>;
-    capabilities: z.ZodOptional<z.ZodObject<{
-        experimental_userMessageResponses: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
+  type: z.ZodLiteral<"bridge-hello">;
+  state: z.ZodOptional<z.ZodString>;
+  lastSeq: z.ZodOptional<z.ZodNumber>;
+  capabilities: z.ZodOptional<z.ZodObject<{
+    experimental_userMessageResponses: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"user-message-response">;
-    messageId: z.ZodString;
-    accepted: z.ZodBoolean;
-    error: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
-    }, z.core.$strip>>;
+  type: z.ZodLiteral<"user-message-response">;
+  messageId: z.ZodString;
+  accepted: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodObject<{
+    message: z.ZodString;
+  }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"bridge-stop">;
-    data: z.ZodUnknown;
+  type: z.ZodLiteral<"bridge-stop">;
+  data: z.ZodUnknown;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"bridge-thread">;
-    threadId: z.ZodString;
+  type: z.ZodLiteral<"bridge-thread">;
+  threadId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"sandbox-log">;
-    source: z.ZodString;
-    stream: z.ZodEnum<{
-        stdout: "stdout";
-        stderr: "stderr";
-    }>;
-    line: z.ZodString;
+  type: z.ZodLiteral<"sandbox-log">;
+  source: z.ZodString;
+  stream: z.ZodEnum<{
+    stdout: "stdout";
+    stderr: "stderr";
+  }>;
+  line: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"debug-event">;
-    level: z.ZodEnum<{
-        error: "error";
-        warn: "warn";
-        info: "info";
-        debug: "debug";
-        trace: "trace";
-    }>;
-    subsystem: z.ZodString;
+  type: z.ZodLiteral<"debug-event">;
+  level: z.ZodEnum<{
+    error: "error";
+    warn: "warn";
+    info: "info";
+    debug: "debug";
+    trace: "trace";
+  }>;
+  subsystem: z.ZodString;
+  message: z.ZodString;
+  attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  error: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
     message: z.ZodString;
-    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    error: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        message: z.ZodString;
-        stack: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    stack: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
 }, z.core.$strip>]>;
 type HarnessV1BridgeOutboundMessage = z.infer<typeof harnessV1BridgeOutboundMessageSchema>;
 type Experimental_HarnessV1BridgeUserMessageResponse = z.infer<typeof experimental_harnessV1BridgeUserMessageResponseSchema>;
@@ -1930,109 +1950,111 @@ type HarnessV1BridgeDebugEvent = z.infer<typeof harnessV1BridgeDebugEventSchema>
  * its fields through. This is the seam where the bridge's serialization is
  * lifted into the general emission shape every harness shares.
  */
-declare function harnessV1DiagnosticFromBridgeFrame(frame: HarnessV1BridgeSandboxLog | HarnessV1BridgeDebugEvent, context: {
-    sessionId?: string;
-    timestamp: number;
+export declare function harnessV1DiagnosticFromBridgeFrame(frame: HarnessV1BridgeSandboxLog | HarnessV1BridgeDebugEvent, context: {
+  sessionId?: string;
+  timestamp: number;
 }): HarnessV1Diagnostic;
-declare const harnessV1BridgeToolResultInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool-result">;
-    toolCallId: z.ZodString;
-    output: z.ZodUnknown;
-    isError: z.ZodOptional<z.ZodBoolean>;
-    toolResult: z.ZodOptional<z.ZodUnknown>;
+export declare const harnessV1BridgeToolResultInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"tool-result">;
+  toolCallId: z.ZodString;
+  output: z.ZodUnknown;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  toolResult: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
-declare const harnessV1BridgeToolApprovalResponseInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool-approval-response">;
-    approvalId: z.ZodString;
-    approved: z.ZodBoolean;
-    reason: z.ZodOptional<z.ZodString>;
+export declare const harnessV1BridgeToolApprovalResponseInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"tool-approval-response">;
+  approvalId: z.ZodString;
+  approved: z.ZodBoolean;
+  reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const harnessV1BridgeUserMessageInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"user-message">;
-    messageId: z.ZodOptional<z.ZodString>;
-    text: z.ZodString;
+export declare const harnessV1BridgeUserMessageInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"user-message">;
+  messageId: z.ZodOptional<z.ZodString>;
+  text: z.ZodString;
 }, z.core.$strip>;
-declare const experimental_harnessV1BridgeUserMessageInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"user-message">;
-    text: z.ZodString;
-    messageId: z.ZodString;
+export declare const experimental_harnessV1BridgeUserMessageInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"user-message">;
+  text: z.ZodString;
+  messageId: z.ZodString;
 }, z.core.$strip>;
-declare const harnessV1BridgeAbortInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"abort">;
+export declare const harnessV1BridgeAbortInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"abort">;
 }, z.core.$strip>;
-declare const harnessV1BridgeDestroyInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"destroy">;
+export declare const harnessV1BridgeDestroyInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"destroy">;
 }, z.core.$strip>;
 /**
  * Reconnect: after re-establishing the socket the host asks the bridge to
  * replay every buffered event with `seq > lastSeenEventId`.
  */
-declare const harnessV1BridgeResumeInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"resume">;
-    lastSeenEventId: z.ZodNumber;
+export declare const harnessV1BridgeResumeInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"resume">;
+  lastSeenEventId: z.ZodNumber;
 }, z.core.$strip>;
 /**
  * The bridge replies with `bridge-stop` carrying any runtime resume data,
  * then exits.
  */
-declare const harnessV1BridgeStopInboundSchema: z.ZodObject<{
-    type: z.ZodLiteral<"stop">;
+export declare const harnessV1BridgeStopInboundSchema: z.ZodObject<{
+  type: z.ZodLiteral<"stop">;
 }, z.core.$strip>;
 /**
  * The inbound command members shared by every bridge adapter. Spread these
  * alongside the adapter's own `start` schema to build the final inbound union:
  * `z.discriminatedUnion('type', [adapterStartSchema, ...harnessV1BridgeInboundCommandSchemas])`.
  */
-declare const harnessV1BridgeInboundCommandSchemas: readonly [z.ZodObject<{
-    type: z.ZodLiteral<"tool-result">;
-    toolCallId: z.ZodString;
-    output: z.ZodUnknown;
-    isError: z.ZodOptional<z.ZodBoolean>;
-    toolResult: z.ZodOptional<z.ZodUnknown>;
+export declare const harnessV1BridgeInboundCommandSchemas: readonly [z.ZodObject<{
+  type: z.ZodLiteral<"tool-result">;
+  toolCallId: z.ZodString;
+  output: z.ZodUnknown;
+  isError: z.ZodOptional<z.ZodBoolean>;
+  toolResult: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool-approval-response">;
-    approvalId: z.ZodString;
-    approved: z.ZodBoolean;
-    reason: z.ZodOptional<z.ZodString>;
+  type: z.ZodLiteral<"tool-approval-response">;
+  approvalId: z.ZodString;
+  approved: z.ZodBoolean;
+  reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"user-message">;
-    messageId: z.ZodOptional<z.ZodString>;
-    text: z.ZodString;
+  type: z.ZodLiteral<"user-message">;
+  messageId: z.ZodOptional<z.ZodString>;
+  text: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"abort">;
+  type: z.ZodLiteral<"abort">;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"destroy">;
+  type: z.ZodLiteral<"destroy">;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"resume">;
-    lastSeenEventId: z.ZodNumber;
+  type: z.ZodLiteral<"resume">;
+  lastSeenEventId: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"stop">;
+  type: z.ZodLiteral<"stop">;
 }, z.core.$strip>];
 /**
  * The JSON line the bridge writes to stdout once its WebSocket server is bound,
  * announcing the port the host should connect to.
  */
-declare const harnessV1BridgeReadySchema: z.ZodObject<{
-    type: z.ZodLiteral<"bridge-ready">;
-    port: z.ZodNumber;
+export declare const harnessV1BridgeReadySchema: z.ZodObject<{
+  type: z.ZodLiteral<"bridge-ready">;
+  port: z.ZodNumber;
 }, z.core.$strip>;
 type HarnessV1BridgeReady = z.infer<typeof harnessV1BridgeReadySchema>;
-
+//#endregion
+//#region src/errors/harness-error.d.ts
 declare const symbol$3: 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$3];
-    constructor({ message, cause }: {
-        message: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is HarnessError;
+export declare class HarnessError extends AISDKError {
+  private readonly [symbol$3];
+  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$2: unique symbol;
 /**
  * Thrown when a caller asks the harness to do something the adapter (or the
@@ -2043,17 +2065,18 @@ declare const symbol$2: 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$2];
-    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$2];
+  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-history-unavailable-error.d.ts
 declare const symbol$1: unique symbol;
 /**
  * Thrown by `readHistory` when the adapter supports history reads but cannot
@@ -2066,17 +2089,18 @@ declare const symbol$1: unique symbol;
  * A conversation with no recorded messages yet is not an error; it resolves
  * to an empty result instead.
  */
-declare class HarnessHistoryUnavailableError 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 HarnessHistoryUnavailableError;
+export declare class HarnessHistoryUnavailableError 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 HarnessHistoryUnavailableError;
 }
-
+//#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
@@ -2084,15 +2108,16 @@ 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;
 }
-
-export { type Experimental_HarnessV1BridgeUserMessageResponse, HARNESS_V1_BUILTIN_TOOLS, HARNESS_V1_BUILTIN_TOOL_NAMES, HarnessCapabilityUnsupportedError, HarnessError, HarnessHistoryUnavailableError, HarnessSandboxAuthenticationError, type HarnessV1, type HarnessV1AssistantMessage, type HarnessV1Authentication, type HarnessV1AuthenticationEnvironment, type HarnessV1Bootstrap, type HarnessV1BootstrapCommand, type HarnessV1BootstrapFile, type HarnessV1BridgeDebugEvent, type HarnessV1BridgeOutboundMessage, type HarnessV1BridgeReady, type HarnessV1BridgeSandboxLog, type HarnessV1BridgeToolWire, type HarnessV1BuiltinTool, type HarnessV1BuiltinToolFiltering, type HarnessV1BuiltinToolName, type HarnessV1BuiltinToolUseKind, type HarnessV1CallWarning, type HarnessV1ContinueTurnOptions, type HarnessV1ContinueTurnState, type HarnessV1CredentialForwarding, type HarnessV1CustomPart, type HarnessV1DebugConfig, type HarnessV1DebugLevel, type HarnessV1Diagnostic, type HarnessV1FilePart, type HarnessV1JSONArray, type HarnessV1JSONObject, type HarnessV1JSONSchema, type HarnessV1JSONValue, type HarnessV1LifecycleState, type HarnessV1Message, type HarnessV1MessagePart, type HarnessV1Metadata, type HarnessV1MintBridgeTokenCallback, type HarnessV1NetworkPolicy, type HarnessV1NetworkSandboxSession, type HarnessV1Observability, type HarnessV1PendingToolApproval, type HarnessV1PendingToolResult, type HarnessV1PermissionMode, type HarnessV1PortEndpoint, type HarnessV1Prompt, type HarnessV1PromptControl, type HarnessV1PromptTurnOptions, type HarnessV1QuestionsTool, type HarnessV1QuestionsToolInput, type HarnessV1QuestionsToolOutput, type HarnessV1ReadHistoryResult, type HarnessV1ReasoningFilePart, type HarnessV1ReasoningPart, type HarnessV1RequestTransformation, type HarnessV1RequestTransformationSources, type HarnessV1ResponseFormat, type HarnessV1ResumeSessionState, type HarnessV1SandboxProvider, type HarnessV1SandboxSessionCreateOptions, type HarnessV1SandboxSessionResumeOptions, type HarnessV1SandboxTemplate, type HarnessV1Session, type HarnessV1Skill, type HarnessV1StartOptions, type HarnessV1StreamPart, type HarnessV1TextPart, type HarnessV1ToolApprovalResponsePart, type HarnessV1ToolCallPart, type HarnessV1ToolMessage, type HarnessV1ToolResultOutput, type HarnessV1ToolResultPart, type HarnessV1ToolSpec, type HarnessV1TurnSettings, type HarnessV1UserMessage, commonTool, experimental_harnessV1BridgeUserMessageInboundSchema, experimental_harnessV1BridgeUserMessageResponseSchema, getHarnessV1BuiltinToolFilteringDenialReason, harnessSessionDataDirectoryPath, harnessStateDirectoryPath, harnessV1BridgeAbortInboundSchema, harnessV1BridgeBuiltinToolFilteringSchema, harnessV1BridgeDebugEventSchema, harnessV1BridgeDestroyInboundSchema, harnessV1BridgeHelloSchema, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgePermissionModeSchema, harnessV1BridgeReadySchema, harnessV1BridgeResponseFormatSchema, harnessV1BridgeResumeInboundSchema, harnessV1BridgeSandboxLogSchema, harnessV1BridgeStartBaseSchema, harnessV1BridgeStopInboundSchema, harnessV1BridgeStopSchema, harnessV1BridgeThreadSchema, harnessV1BridgeToolApprovalResponseInboundSchema, harnessV1BridgeToolResultInboundSchema, harnessV1BridgeToolWireSchema, harnessV1BridgeUserMessageInboundSchema, harnessV1DebugConfigSchema, harnessV1DebugLevelSchema, harnessV1DiagnosticFromBridgeFrame, harnessV1ErrorPartSchema, harnessV1FileChangePartSchema, harnessV1FinishPartSchema, harnessV1FinishStepPartSchema, harnessV1QuestionsToolInputSchema, harnessV1QuestionsToolOutputSchema, harnessV1RawPartSchema, harnessV1ReasoningDeltaPartSchema, harnessV1ReasoningEndPartSchema, harnessV1ReasoningStartPartSchema, harnessV1StreamPartSchema, harnessV1StreamStartPartSchema, harnessV1TextDeltaPartSchema, harnessV1TextEndPartSchema, harnessV1TextStartPartSchema, harnessV1ToolApprovalRequestPartSchema, harnessV1ToolCallPartSchema, harnessV1ToolResultPartSchema, isHarnessV1BuiltinToolIncluded };
+//#endregion
+export type { Experimental_HarnessV1BridgeUserMessageResponse, HarnessV1, HarnessV1AssistantMessage, HarnessV1Authentication, HarnessV1AuthenticationEnvironment, HarnessV1Bootstrap, HarnessV1BootstrapCommand, HarnessV1BootstrapFile, HarnessV1BridgeDebugEvent, HarnessV1BridgeOutboundMessage, HarnessV1BridgeReady, HarnessV1BridgeSandboxLog, HarnessV1BridgeToolWire, HarnessV1BuiltinTool, HarnessV1BuiltinToolFiltering, HarnessV1BuiltinToolName, HarnessV1BuiltinToolUseKind, HarnessV1CallWarning, HarnessV1ContinueTurnOptions, HarnessV1ContinueTurnState, HarnessV1CredentialForwarding, HarnessV1CustomPart, HarnessV1DebugConfig, HarnessV1DebugLevel, HarnessV1Diagnostic, HarnessV1FilePart, HarnessV1JSONArray, HarnessV1JSONObject, HarnessV1JSONSchema, HarnessV1JSONValue, HarnessV1LifecycleState, HarnessV1Message, HarnessV1MessagePart, HarnessV1Metadata, HarnessV1MintBridgeTokenCallback, HarnessV1NetworkPolicy, HarnessV1NetworkSandboxSession, HarnessV1Observability, HarnessV1PendingToolApproval, HarnessV1PendingToolResult, HarnessV1PermissionMode, HarnessV1PortEndpoint, HarnessV1Prompt, HarnessV1PromptControl, HarnessV1PromptTurnOptions, HarnessV1QuestionsTool, HarnessV1QuestionsToolInput, HarnessV1QuestionsToolOutput, HarnessV1ReadHistoryResult, HarnessV1ReasoningFilePart, HarnessV1ReasoningPart, HarnessV1RequestTransformation, HarnessV1RequestTransformationSources, HarnessV1ResponseFormat, HarnessV1ResumeSessionState, HarnessV1SandboxProvider, HarnessV1SandboxSessionCreateOptions, HarnessV1SandboxSessionResumeOptions, HarnessV1SandboxTemplate, HarnessV1Session, HarnessV1Skill, HarnessV1StartOptions, HarnessV1StreamPart, HarnessV1TextPart, HarnessV1ToolApprovalResponsePart, HarnessV1ToolCallPart, HarnessV1ToolMessage, HarnessV1ToolResultOutput, HarnessV1ToolResultPart, HarnessV1ToolSpec, HarnessV1TurnSettings, HarnessV1UserMessage };
+//# sourceMappingURL=index.d.ts.map