@ai-sdk/harness 1.0.92 → 1.0.94

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @ai-sdk/harness
 
+## 1.0.94
+
+### Patch Changes
+
+- 8961fde: feat(harness): allow changing `model` between turns via call options
+- eb59f2a: fix(harness): ensure harness adapters can stream tool input deltas before the complete tool call arrives
+- Updated dependencies [55a9981]
+- Updated dependencies [dd32de2]
+- Updated dependencies [aa45741]
+- Updated dependencies [cc29073]
+  - ai@7.0.85
+  - @ai-sdk/provider@4.0.9
+  - @ai-sdk/provider-utils@5.0.34
+
+## 1.0.93
+
+### Patch Changes
+
+- cc9f6ce: fix(harness): stop diagnosing caller-initiated aborts as bridge errors, and serialize bridge turns so a start racing an aborted turn's teardown no longer overlaps it (bounded by a teardown grace period, after which the start proceeds as before)
+- 7608210: feat(harness): add `model` parameter to `HarnessAgent` instead of having each harness adapter support it on their own constructor functions
+- 6f8a2d7: fix (harness): ensure the harness bootstrap recipe on resumed sessions too. The marker is keyed by recipe identity, so a resume whose bootstrap is already current costs one file read, while a resume into a sandbox bootstrapped by an older adapter build — a snapshot that outlived the harness version that made it — is re-bootstrapped instead of running a stale bridge against a newer host.
+- 14d4fc0: feat(harness): allow changing harness settings between turns via `prepareCall()` support on `HarnessAgent`
+- Updated dependencies [6669d69]
+- Updated dependencies [a6463ca]
+- Updated dependencies [e604532]
+- Updated dependencies [90192f1]
+  - ai@7.0.84
+  - @ai-sdk/provider-utils@5.0.33
+
 ## 1.0.92
 
 ### Patch Changes

package/README.md

@@ -22,6 +22,7 @@ import { z } from 'zod/v4';
 const agent = new HarnessAgent({
   harness: claudeCode,
   id: 'auth-agent',
+  model: 'claude-sonnet-4-5',
   instructions:
     'You are a careful refactoring assistant. Prefer minimal diffs.',
   sandbox: createVercelSandbox({
@@ -100,6 +101,9 @@ const agent = new HarnessAgent({
 
 Use `session.detach()` to park a bridge-backed session for later attach, `session.stop()` to save state and stop the sandbox, or `session.destroy()` to clean up without keeping resume state. Bridge-backed adapters such as Claude Code, Codex, OpenCode, and DeepAgents require a network sandbox session that exposes ports — `@ai-sdk/sandbox-vercel` is the supported choice today. `@ai-sdk/sandbox-just-bash` is suitable only for host-runtime or otherwise non-bridge flows, such as Pi.
 
+Set `model` on `HarnessAgent` to select the model used when the harness session
+starts. Model identifiers are harness-specific, so `model` accepts any string.
+
 `sandbox` is an optional `HarnessV1SandboxProvider`. When omitted, pass a `HarnessV1NetworkSandboxSession` to every `agent.createSession({ sandboxSession })` call. Use `sandboxConfig` for agent specific sandbox configuration that works independently from the sandbox provider that is used:
 
 - Use `sandboxConfig.onSession` to prepare the acquired sandbox before the harness adapter starts. The hook runs for fresh and resumed sessions, so keep it idempotent.
@@ -126,7 +130,7 @@ See the [harness adapters documentation](https://ai-sdk.dev/v7/docs/ai-sdk-harne
 
 ## Implementing a harness
 
-Implement the `HarnessV1` factory and a `HarnessV1Session` whose `doPromptTurn` emits events; the agent surface, streaming, tool execution, and multi-turn state are handled for you. Read `startOpts.sandboxSession` for the selected network sandbox session. The harness layer stops or destroys sessions it acquires from the provider, while a session passed to `agent.createSession({ sandboxSession })` remains caller-owned. Call `sandboxSession.restricted()` for the tool-safe file-IO/exec/spawn surface.
+Implement the `HarnessV1` factory and a `HarnessV1Session` whose `doPromptTurn` emits events; the agent surface, streaming, tool execution, and multi-turn state are handled for you. Read `startOpts.model` for the consumer-selected model and `startOpts.sandboxSession` for the selected network sandbox session. The harness layer stops or destroys sessions it acquires from the provider, while a session passed to `agent.createSession({ sandboxSession })` remains caller-owned. Call `sandboxSession.restricted()` for the tool-safe file-IO/exec/spawn surface.
 
 Each prompt and continuation receives an optional `responseFormat`. JSON
 formats carry a caller-provided JSON Schema plus optional name and description;

package/dist/agent/index.d.ts

@@ -1,8 +1,8 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Experimental_SandboxSession, UserModelMessage, ToolSet, FlexibleSchema, Tool, Context, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
-import { OutputInterface, StopCondition, ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, AgentCallParameters, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
+import { Experimental_SandboxSession, UserModelMessage, ToolSet, FlexibleSchema, Tool, Context, MaybePromiseLike, Arrayable, ToolApprovalResponse, ModelMessage } from '@ai-sdk/provider-utils';
+import { OutputInterface, AgentCallParameters, Prompt, StopCondition, ToolApprovalStatus, TelemetryOptions, ActiveTools, StreamTextResult, Agent, GenerateTextResult, AgentStreamParameters, Telemetry } from 'ai';
 import { z } from 'zod/v4';
-import { JSONValue, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, JSONSchema7, AISDKError } from '@ai-sdk/provider';
+import { JSONSchema7, JSONValue, LanguageModelV4StreamPart, LanguageModelV4ToolCall, LanguageModelV4ToolApprovalRequest, LanguageModelV4ToolResult, LanguageModelV4FinishReason, LanguageModelV4Usage, AISDKError } from '@ai-sdk/provider';
 
 /**
  * One file to write into the sandbox as part of an adapter's bootstrap recipe.
@@ -392,6 +392,66 @@ type HarnessV1ResponseFormat = {
     readonly description?: string;
 };
 
+/**
+ * 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>;
+};
+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;
+};
+
+/**
+ * Description of a host-defined tool that the harness should make available
+ * to the underlying agent runtime.
+ *
+ * Adapters translate this into whatever shape their runtime expects (e.g.
+ * Claude Code's tool definitions, Codex CLI's tool config, an MCP server
+ * exposed to the runtime, …). The adapter does not execute the tool; when
+ * the runtime calls it, the adapter emits a `tool-call` event and waits for
+ * `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;
+};
+
 type HarnessV1PendingToolApproval = {
     readonly approvalId: string;
     readonly toolCallId: string;
@@ -406,6 +466,38 @@ type HarnessV1PendingToolResult = {
     readonly toolName: string;
     readonly input: string;
 };
+/**
+ * Framework-owned settings captured when a turn begins. The same settings are
+ * passed to fresh and continued turns and persisted with unfinished-turn state
+ * 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>;
+};
 type HarnessV1LifecycleStateBase = {
     /**
      * Identifier of the harness that produced this state. Used by adapters to
@@ -453,40 +545,14 @@ type HarnessV1ContinueTurnState = HarnessV1LifecycleStateBase & {
      * result before the underlying turn can continue.
      */
     readonly pendingToolResults?: readonly HarnessV1PendingToolResult[];
-};
-type HarnessV1LifecycleState = HarnessV1ResumeSessionState | HarnessV1ContinueTurnState;
-
-/**
- * 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.
+     * 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 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;
+    readonly turnSettings?: HarnessV1TurnSettings;
 };
+type HarnessV1LifecycleState = HarnessV1ResumeSessionState | HarnessV1ContinueTurnState;
 
 /**
  * Warning emitted by a harness adapter during a call.
@@ -570,7 +636,13 @@ type HarnessV1StreamPart = {
     type: 'reasoning-end';
     id: string;
     harnessMetadata?: HarnessV1Metadata;
-} | (LanguageModelV4ToolCall & {
+} | Extract<LanguageModelV4StreamPart, {
+    type: 'tool-input-start';
+}> | Extract<LanguageModelV4StreamPart, {
+    type: 'tool-input-delta';
+}> | Extract<LanguageModelV4StreamPart, {
+    type: 'tool-input-end';
+}> | (LanguageModelV4ToolCall & {
     nativeName?: string;
     /**
      * Total tool calls in the current model step, when known before tool
@@ -607,34 +679,6 @@ type HarnessV1StreamPart = {
     rawValue: unknown;
 };
 
-/**
- * Description of a host-defined tool that the harness should make available
- * to the underlying agent runtime.
- *
- * Adapters translate this into whatever shape their runtime expects (e.g.
- * Claude Code's tool definitions, Codex CLI's tool config, an MCP server
- * exposed to the runtime, …). The adapter does not execute the tool; when
- * the runtime calls it, the adapter emits a `tool-call` event and waits for
- * `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;
-};
-
 type HarnessV1BuiltinToolFiltering = {
     mode: 'allow';
     toolNames: string[];
@@ -657,11 +701,6 @@ type HarnessV1StartOptions = {
      * (sandbox name, native session id, …).
      */
     readonly sessionId: string;
-    /**
-     * Skills made available to the underlying runtime for the lifetime of
-     * the session. Adapters decide how to surface them.
-     */
-    readonly skills?: ReadonlyArray<HarnessV1Skill>;
     /**
      * Optional resume payload returned by a prior session lifecycle method. When
      * provided, the adapter should resume the existing session before accepting a
@@ -715,7 +754,7 @@ type HarnessV1StartOptions = {
 /**
  * Options passed to `HarnessV1Session.doPromptTurn`.
  */
-type HarnessV1PromptTurnOptions = {
+type HarnessV1PromptTurnOptions = HarnessV1TurnSettings & {
     /**
      * Fresh input for this turn — either a plain string or a single
      * `ModelMessage`. The harness session owns its own conversation history,
@@ -727,20 +766,6 @@ type HarnessV1PromptTurnOptions = {
      * JSON response format must throw `HarnessCapabilityUnsupportedError`.
      */
     readonly responseFormat?: HarnessV1ResponseFormat;
-    /**
-     * Host-defined tools to make available to the underlying runtime for this
-     * turn. The harness emits `tool-call` events when the runtime calls one
-     * and waits for `submitToolResult`.
-     */
-    readonly tools?: ReadonlyArray<HarnessV1ToolSpec>;
-    /**
-     * Free-form instructions for the session. The framework supplies the same
-     * value on every turn. Adapters should append it to the runtime's native
-     * system or developer prompt when supported. Otherwise, they should prepend
-     * it to the first user message of a fresh session and rely on the runtime's
-     * persisted history when resuming.
-     */
-    readonly instructions?: string;
     /**
      * Signal that aborts the in-flight turn. The adapter must cancel any
      * underlying work and resolve `done` (with an error if appropriate).
@@ -761,24 +786,12 @@ type HarnessV1PromptTurnOptions = {
  * in-flight turn rather than starting a new one. It is used to continue a turn
  * that was previously suspended temporarily, e.g. by the workflow slice loop.
  */
-type HarnessV1ContinueTurnOptions = {
+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;
-    /**
-     * Host-defined tools to make available for the continued turn. Same shape
-     * as `doPromptTurn`'s `tools`. An adapter that purely attaches to a live turn
-     * may ignore them; an adapter that re-drives the turn (rerun) needs them.
-     */
-    readonly tools?: ReadonlyArray<HarnessV1ToolSpec>;
-    /**
-     * Free-form session instructions. An adapter that re-drives the runtime may
-     * need these to reconstruct its native system or developer prompt. An
-     * adapter that attaches to a live turn may ignore them.
-     */
-    readonly instructions?: string;
     /**
      * Signal that aborts the continued turn. The adapter must cancel any
      * underlying work and resolve `done` (with an error if appropriate).
@@ -809,13 +822,6 @@ type HarnessV1Session = {
      * sessions report `false`; resumed sessions report `true`.
      */
     readonly isResume: boolean;
-    /**
-     * The model id the underlying runtime is configured to use, if the adapter
-     * knows it (e.g. from its settings). Surfaced into telemetry as
-     * `gen_ai.request.model` and the trace span labels. Omitted when the adapter
-     * defers to the runtime's own default and has no concrete id.
-     */
-    readonly modelId?: string;
     /**
      * 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
@@ -1242,9 +1248,10 @@ type HarnessTools<TOOLS extends ToolSet> = ActiveTools<NoInfer<TOOLS>>;
 /**
  * Construction-time settings for a `HarnessAgent`.
  *
- * Per-call settings (prompt, abortSignal, callbacks) belong on the
+ * Prompt, abortSignal, callbacks, and custom call options belong on the
  * `AgentCallParameters` / `AgentStreamParameters` passed to `generate` /
- * `stream` and are not duplicated here.
+ * `stream`. `prepareCall` can derive turn-scoped model, skills, instructions,
+ * and tools from those custom call options.
  */
 type HarnessAgentToolFilteringSettings<TOOLS extends ToolSet> = {
     /**
@@ -1261,7 +1268,7 @@ type HarnessAgentToolFilteringSettings<TOOLS extends ToolSet> = {
      */
     readonly inactiveTools?: HarnessTools<TOOLS>;
 };
-type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never> = {
+type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never, CALL_OPTIONS = never> = {
     /**
      * The harness adapter driving the underlying agent runtime. Its
      * `builtinTools` are merged with the user-defined `tools` and exposed to
@@ -1273,6 +1280,12 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
      * If omitted, `agent.id` is `undefined`.
      */
     readonly id?: string;
+    /**
+     * Model identifier used by the harness adapter. Supported values are
+     * defined by the selected harness. `prepareCall` can replace it between
+     * completed turns.
+     */
+    readonly model?: string;
     /**
      * Tools available to the underlying runtime in addition to the harness's
      * own builtins. The agent forwards each tool to the harness as a
@@ -1284,17 +1297,37 @@ type HarnessAgentSettings<THarness extends HarnessAgentAdapter<any> = HarnessAge
      */
     readonly tools?: TUserTools;
     /**
-     * Skills made available to the underlying runtime for the lifetime of
-     * the session. Each adapter decides how to surface skills (file in the
-     * working tree, prompt prefix, …).
+     * Skills made available to the underlying runtime. Each adapter decides how
+     * to surface skills. `prepareCall` can replace them between completed turns.
      */
     readonly skills?: ReadonlyArray<HarnessAgentSkill>;
     /**
-     * Instructions for the underlying agent runtime. Adapters append this to a
+     * Instructions for the underlying agent runtime. Adapters append these to a
      * native system or developer prompt when supported. Otherwise, they prepend
-     * it to the first user message of a fresh session.
+     * them to the user message. `prepareCall` can replace them between completed
+     * turns.
      */
     readonly instructions?: string;
+    /**
+     * Schema for validating the custom options passed to each agent call.
+     */
+    readonly callOptionsSchema?: FlexibleSchema<CALL_OPTIONS>;
+    /**
+     * Prepares the prompt and the settings that may vary between completed
+     * turns. The prepared values are frozen for the lifetime of the turn,
+     * including any suspended-turn continuations.
+     *
+     * Preserve the remaining arguments with the rest-spread pattern when a
+     * field should be removable by returning `undefined`:
+     *
+     * ```ts
+     * prepareCall: ({ options, ...rest }) => ({
+     *   ...rest,
+     *   instructions: options.instructions,
+     * })
+     * ```
+     */
+    readonly prepareCall?: (options: Omit<AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT>, 'abortSignal' | 'timeout' | 'onStart' | 'experimental_onStart' | 'onStepStart' | 'experimental_onStepStart' | 'onToolExecutionStart' | 'experimental_onToolCallStart' | 'onToolExecutionEnd' | 'experimental_onToolCallFinish' | 'onStepEnd' | 'onStepFinish' | 'onEnd' | 'onFinish' | 'experimental_sandbox'> & Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools'>) => MaybePromiseLike<Pick<HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, NoInfer<OUTPUT>, CALL_OPTIONS>, 'model' | 'skills' | 'instructions' | 'tools'> & Omit<Prompt, 'system' | 'instructions' | 'allowSystemInMessages'>>;
     /**
      * Optional specification for generating typed output. The same output
      * requirement is active for every turn run by this agent.
@@ -1399,6 +1432,7 @@ declare function collectHarnessAgentToolResultContinuations(input: {
 type HarnessAgentTurnResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface> = {
     result: StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
     done: Promise<void>;
+    ready: Promise<void>;
 };
 type HarnessAgentTurnState = 'idle' | 'running' | 'awaiting-approval' | 'awaiting-tool-result' | 'suspended';
 /**
@@ -1434,6 +1468,8 @@ declare class HarnessAgentSession {
     private activeTurnSequence;
     private activePromptControl;
     private suspendedTurnState;
+    private activeTurnSettings;
+    private persistedTurnSettings;
     /**
      * Whether this session was created from `resumeFrom` or `continueFrom`.
      * Captured at construction so it survives lifecycle cleanup.
@@ -1449,11 +1485,14 @@ declare class HarnessAgentSession {
         toolApproval: HarnessAgentToolApprovalConfiguration | undefined;
         pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
         pendingToolResults?: readonly HarnessAgentPendingToolResult[];
+        turnSettings?: HarnessV1TurnSettings;
         turnState?: HarnessAgentTurnState;
     });
     hasUnfinishedTurn(): boolean;
     promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
         prompt: HarnessAgentPrompt;
+        model: string | undefined;
+        skills: ReadonlyArray<HarnessV1Skill>;
         instructions: string | undefined;
         tools: TOOLS;
         activeTools: ToolSet;
@@ -1467,6 +1506,8 @@ declare class HarnessAgentSession {
         stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
     }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
     continueTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends OutputInterface>(options: {
+        model: string | undefined;
+        skills: ReadonlyArray<HarnessV1Skill>;
         instructions: string | undefined;
         tools: TOOLS;
         activeTools: ToolSet;
@@ -1543,9 +1584,11 @@ declare class HarnessAgentSession {
     private markAwaitingToolResultIfActive;
     private startTrackedTurn;
     private setPromptControl;
+    private waitForPromptControl;
     private settleActivePromptControl;
     private clearActivePromptControl;
     private finishTrackedTurn;
+    private resolveActiveTurnSettings;
     private endLocalHandle;
     private requireReusableSession;
 }
@@ -1598,7 +1641,7 @@ interface HarnessAgentCallExtensions {
  *    remain owned by the caller and are not stopped or destroyed by the
  *    harness layer.
  */
-declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never> implements Agent<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT> {
+declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter, TUserTools extends ToolSet = {}, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends OutputInterface = never, CALL_OPTIONS = never> implements Agent<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT> {
     readonly version: "agent-v1";
     readonly id: string | undefined;
     /**
@@ -1611,10 +1654,9 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
     private readonly settings;
     private readonly stopConditions;
     private readonly sandboxConfig;
-    private readonly activeUserTools;
     private readonly builtinToolFiltering;
     private readonly permissionMode;
-    constructor(settings: HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, OUTPUT>);
+    constructor(settings: HarnessAgentSettings<THarness, TUserTools, RUNTIME_CONTEXT, OUTPUT, CALL_OPTIONS>);
     /** Identifier of the harness backing this agent. */
     get harnessId(): string;
     /**
@@ -1652,8 +1694,8 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
         sandboxSession?: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
         abortSignal?: AbortSignal;
     }): Promise<HarnessAgentSession>;
-    generate(options: AgentCallParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
-    stream(options: AgentStreamParameters<never, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+    generate(options: AgentCallParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<GenerateTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
+    stream(options: AgentStreamParameters<CALL_OPTIONS, HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT> & HarnessAgentCallExtensions): Promise<StreamTextResult<HarnessAllTools<THarness, TUserTools>, RUNTIME_CONTEXT, OUTPUT>>;
     /**
      * Continue the in-flight turn **without a new prompt**, draining it like
      * {@link generate}. Used after `createSession({ continueFrom })` to finish
@@ -1690,8 +1732,14 @@ declare class HarnessAgent<THarness extends HarnessAgentAdapter<any> = HarnessAg
         session: HarnessAgentSession;
         text: string;
     }): Promise<void>;
-    private _startTurn;
-    private _resolveTurnInput;
+    private _startPromptTurn;
+    private _startContinueTurn;
+    private _buildTurnOptions;
+    private _resolveContinueTurnInput;
+    private _resolvePromptTurnInput;
+    private _preparePromptTurnInput;
+    private _prepareContinueTurnInput;
+    private _prepareTurnSettings;
     private _toToolSpecs;
     private _toGenerateResult;
     private _resolveResponseFormat;