@ai-sdk/harness 1.0.92 → 1.0.94

package/dist/agent/index.js

@@ -42,7 +42,8 @@ var HarnessCapabilityUnsupportedError = class extends (_b2 = HarnessError, _a2 =
 import {
   asArray as asArray2,
   asSchema,
-  generateId as generateId5
+  generateId as generateId5,
+  validateTypes
 } from "@ai-sdk/provider-utils";
 
 // src/agent/internal/lifecycle-state-validation.ts
@@ -107,7 +108,8 @@ async function validateLifecycleStateData(input) {
     specificationVersion: state.specificationVersion,
     data,
     ...state.pendingToolApprovals !== void 0 ? { pendingToolApprovals: state.pendingToolApprovals } : {},
-    ...state.pendingToolResults !== void 0 ? { pendingToolResults: state.pendingToolResults } : {}
+    ...state.pendingToolResults !== void 0 ? { pendingToolResults: state.pendingToolResults } : {},
+    ...state.turnSettings !== void 0 ? { turnSettings: state.turnSettings } : {}
   };
 }
 
@@ -887,6 +889,10 @@ function translateStreamPart(event, options = {}) {
           providerMetadata: event.harnessMetadata
         }
       ];
+    case "tool-input-start":
+    case "tool-input-delta":
+    case "tool-input-end":
+      return [event];
     case "tool-call":
       return [];
     case "tool-approval-request":
@@ -986,9 +992,45 @@ function translateStreamPart(event, options = {}) {
 }
 
 // src/agent/internal/strip-work-dir.ts
+function createToolInputWorkDirStripper({
+  sessionWorkDir
+}) {
+  const pendingByToolCallId = /* @__PURE__ */ new Map();
+  return (part) => {
+    var _a4;
+    if (sessionWorkDir.length === 0) return [part];
+    if (part.type === "tool-input-start") {
+      pendingByToolCallId.set(part.id, "");
+      return [part];
+    }
+    if (part.type === "tool-input-delta") {
+      const stripped2 = stripStreamingString({
+        value: ((_a4 = pendingByToolCallId.get(part.id)) != null ? _a4 : "") + part.delta,
+        workDir: sessionWorkDir,
+        final: false
+      });
+      pendingByToolCallId.set(part.id, stripped2.pending);
+      return stripped2.output.length === 0 ? [] : [{ ...part, delta: stripped2.output }];
+    }
+    const pending = pendingByToolCallId.get(part.id);
+    pendingByToolCallId.delete(part.id);
+    if (pending == null || pending.length === 0) return [part];
+    const stripped = stripStreamingString({
+      value: pending,
+      workDir: sessionWorkDir,
+      final: true
+    });
+    return stripped.output.length === 0 ? [part] : [
+      { type: "tool-input-delta", id: part.id, delta: stripped.output },
+      part
+    ];
+  };
+}
 function stripWorkDir(part, sessionWorkDir) {
   if (sessionWorkDir.length === 0) return part;
   switch (part.type) {
+    case "tool-input-delta":
+      return { ...part, delta: stripString(part.delta, sessionWorkDir) };
     case "tool-call":
       return { ...part, input: stripString(part.input, sessionWorkDir) };
     case "tool-result":
@@ -1005,6 +1047,42 @@ function stripWorkDir(part, sessionWorkDir) {
 function stripString(value, workDir) {
   return value.split(`${workDir}/`).join("").split(workDir).join(".");
 }
+function stripStreamingString({
+  value,
+  workDir,
+  final
+}) {
+  let remaining = value;
+  let output = "";
+  while (remaining.length > 0) {
+    const matchIndex = remaining.indexOf(workDir);
+    if (matchIndex >= 0) {
+      output += remaining.slice(0, matchIndex);
+      const followingIndex = matchIndex + workDir.length;
+      if (followingIndex === remaining.length && !final) {
+        return { output, pending: remaining.slice(matchIndex) };
+      }
+      if (remaining[followingIndex] === "/") {
+        remaining = remaining.slice(followingIndex + 1);
+      } else {
+        output += ".";
+        remaining = remaining.slice(followingIndex);
+      }
+      continue;
+    }
+    if (final) return { output: output + remaining, pending: "" };
+    let pendingLength = Math.min(remaining.length, workDir.length - 1);
+    while (pendingLength > 0 && !workDir.startsWith(remaining.slice(-pendingLength))) {
+      pendingLength -= 1;
+    }
+    const outputLength = remaining.length - pendingLength;
+    return {
+      output: output + remaining.slice(0, outputLength),
+      pending: remaining.slice(outputLength)
+    };
+  }
+  return { output, pending: "" };
+}
 function stripDeep(value, workDir) {
   if (typeof value === "string") return stripString(value, workDir);
   if (Array.isArray(value)) return value.map((item) => stripDeep(item, workDir));
@@ -1491,7 +1569,7 @@ function runPrompt(input) {
   const telemetry = createTurnTelemetry({
     telemetry: input.telemetry,
     harnessId: input.harness.harnessId,
-    modelId: input.session.modelId,
+    modelId: input.model,
     instructions: input.instructions,
     promptText: input.prompt != null ? promptToText(input.prompt) : "",
     runtimeContext: input.runtimeContext
@@ -1511,17 +1589,23 @@ function runPrompt(input) {
     result.fail(err);
   };
   const done = (async () => {
-    var _a5, _b5, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k, _l, _m;
+    var _a5, _b5, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k, _l, _m, _n;
     let bridge;
     try {
       bridge = await toHarnessStream({
-        invoke: input.mode === "continue" ? (emit) => input.session.doContinueTurn({
-          responseFormat: input.responseFormat,
-          tools: input.toolSpecs,
-          instructions: input.instructions,
-          abortSignal: input.abortSignal,
-          emit
-        }) : (emit) => {
+        invoke: input.mode === "continue" ? (emit) => {
+          var _a6;
+          return input.session.doContinueTurn({
+            model: input.model,
+            skills: (_a6 = input.skills) != null ? _a6 : [],
+            responseFormat: input.responseFormat,
+            tools: input.toolSpecs,
+            instructions: input.instructions,
+            abortSignal: input.abortSignal,
+            emit
+          });
+        } : (emit) => {
+          var _a6;
           if (input.prompt == null) {
             throw new Error(
               'runPrompt: `prompt` is required for mode "prompt".'
@@ -1529,6 +1613,8 @@ function runPrompt(input) {
           }
           return input.session.doPromptTurn({
             prompt: input.prompt,
+            model: input.model,
+            skills: (_a6 = input.skills) != null ? _a6 : [],
             responseFormat: input.responseFormat,
             tools: input.toolSpecs,
             instructions: input.instructions,
@@ -1551,6 +1637,9 @@ function runPrompt(input) {
     const { stream, control } = bridge;
     (_a5 = input.onPromptControlAvailable) == null ? void 0 : _a5.call(input, control);
     const reader = stream.getReader();
+    const stripToolInputWorkDir = createToolInputWorkDirStripper({
+      sessionWorkDir: input.sessionWorkDir
+    });
     const toolCallsByToolCallId = /* @__PURE__ */ new Map();
     const rawToolCallsByToolCallId = /* @__PURE__ */ new Map();
     const translateOptions = {
@@ -1795,7 +1884,7 @@ function runPrompt(input) {
         toolName: approval.toolName,
         input: approval.input
       };
-      await telemetry.start(input.session.modelId);
+      await telemetry.start(input.model);
       await telemetry.toolStart({
         toolCallId: rawToolCall.toolCallId,
         toolName: rawToolCall.toolName,
@@ -1894,11 +1983,25 @@ function runPrompt(input) {
           }
         }
         if (value.type === "stream-start") {
-          await telemetry.start((_e2 = value.modelId) != null ? _e2 : input.session.modelId);
+          await telemetry.start((_e2 = value.modelId) != null ? _e2 : input.model);
         }
         if (value.type !== "stream-start" && value.type !== "finish-step" && value.type !== "finish" && value.type !== "error") {
           await telemetry.ensureStepOpen();
         }
+        if (value.type === "tool-input-start" || value.type === "tool-input-delta" || value.type === "tool-input-end") {
+          if (settledHostToolCallIds.has(value.id) || settledBuiltinApprovalToolCallIds.has(value.id)) {
+            continue;
+          }
+          for (const displayValue2 of stripToolInputWorkDir(value)) {
+            for (const part of translateStreamPart(
+              displayValue2,
+              translateOptions
+            )) {
+              result.enqueue(part);
+            }
+          }
+          continue;
+        }
         const displayValue = stripWorkDir(value, input.sessionWorkDir);
         const settledHostInputReplay = (displayValue.type === "tool-call" || displayValue.type === "tool-result" || displayValue.type === "tool-approval-request") && settledHostToolCallIds.has(displayValue.toolCallId);
         const settledBuiltinApprovalReplay = (displayValue.type === "tool-call" || displayValue.type === "tool-approval-request") && settledBuiltinApprovalToolCallIds.has(displayValue.toolCallId);
@@ -1944,12 +2047,14 @@ function runPrompt(input) {
         if (value.type === "error" && displayValue.type === "error") {
           await waitForOutstandingHostToolExecutions();
           await telemetry.error(value.error);
-          logBridgeError({
-            harnessId: input.harness.harnessId,
-            sessionId: input.session.sessionId,
-            context: "harness stream error",
-            error: value.error
-          });
+          if (!((_g2 = input.abortSignal) == null ? void 0 : _g2.aborted)) {
+            logBridgeError({
+              harnessId: input.harness.harnessId,
+              sessionId: input.session.sessionId,
+              context: "harness stream error",
+              error: value.error
+            });
+          }
           settleFailure(displayValue.error);
           return;
         }
@@ -2003,13 +2108,13 @@ function runPrompt(input) {
             );
           }
           const rawToolCall = rawToolCallsByToolCallId.get(value.toolCallId);
-          const pendingApproval = (_i = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _i : {
+          const pendingApproval = (_j = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _j : {
             approvalId: value.approvalId,
             toolCallId: value.toolCallId,
             toolName: toolCall.toolName,
-            input: (_g2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _g2 : JSON.stringify(toolCall.input),
+            input: (_h = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _h : JSON.stringify(toolCall.input),
             kind: "builtin",
-            providerExecuted: (_h = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _h : true,
+            providerExecuted: (_i = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _i : true,
             ...(rawToolCall == null ? void 0 : rawToolCall.nativeName) !== void 0 ? { nativeName: rawToolCall.nativeName } : {}
           };
           pendingApprovalsByApprovalId.set(
@@ -2114,7 +2219,7 @@ function runPrompt(input) {
             await telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
             continue;
           }
-          const pendingApproval = (_j = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _j : customToolApprovalDecision.type === "request" ? {
+          const pendingApproval = (_k = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _k : customToolApprovalDecision.type === "request" ? {
             approvalId: generateId4(),
             toolCallId: toolCall.toolCallId,
             toolName: toolCall.toolName,
@@ -2213,15 +2318,15 @@ function runPrompt(input) {
         }
       }
       await waitForOutstandingHostToolExecutions();
-      const isTurnSuspending = ((_k = input.isTurnSuspending) == null ? void 0 : _k.call(input)) === true;
+      const isTurnSuspending = ((_l = input.isTurnSuspending) == null ? void 0 : _l.call(input)) === true;
       if (isTurnSuspending) {
         if (finalFinish == null) {
           result.discardCurrentStepContent();
         }
       } else if (finalFinish != null) {
-        (_l = input.onTurnFinished) == null ? void 0 : _l.call(input);
+        (_m = input.onTurnFinished) == null ? void 0 : _m.call(input);
       } else {
-        (_m = input.onTurnFailed) == null ? void 0 : _m.call(input);
+        (_n = input.onTurnFailed) == null ? void 0 : _n.call(input);
       }
       await result.finish(
         finalFinish ? {
@@ -2368,6 +2473,7 @@ var HarnessAgentSession = class {
     for (const pendingResult of (_c = options.pendingToolResults) != null ? _c : []) {
       this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
     }
+    this.persistedTurnSettings = options.turnSettings;
     this.turnState = (_d = options.turnState) != null ? _d : this.pendingToolApprovals.size > 0 ? "awaiting-approval" : this.pendingToolResults.size > 0 ? "awaiting-tool-result" : "idle";
     this.isResume = options.underlyingSession.isResume;
   }
@@ -2399,6 +2505,18 @@ var HarnessAgentSession = class {
   promptTurn(options) {
     const session = this.requireReusableSession();
     this.requirePromptableTurn();
+    this.persistedTurnSettings = {
+      ...options.model == null ? {} : { model: options.model },
+      skills: options.skills,
+      ...options.instructions == null ? {} : { instructions: options.instructions },
+      tools: options.toolSpecs
+    };
+    this.activeTurnSettings = {
+      persisted: this.persistedTurnSettings,
+      tools: options.tools,
+      activeTools: options.activeTools,
+      builtinToolFiltering: options.builtinToolFiltering
+    };
     const sandboxSession = this.getSandboxSession();
     const turnId = this.startTrackedTurn();
     try {
@@ -2406,6 +2524,8 @@ var HarnessAgentSession = class {
         harness: this.harness,
         session,
         prompt: options.prompt,
+        model: options.model,
+        skills: options.skills,
         instructions: options.instructions,
         tools: options.tools,
         activeTools: options.activeTools,
@@ -2448,7 +2568,10 @@ var HarnessAgentSession = class {
         isTurnSuspending: () => this.activeTurnSequence === turnId && this.suspendedTurnState != null,
         onStopConditionMet: () => this.captureStopConditionBoundary({ session, turnId })
       });
-      return turn;
+      return {
+        ...turn,
+        ready: this.waitForPromptControl({ turnId })
+      };
     } catch (error) {
       this.finishTrackedTurn({ turnId });
       throw error;
@@ -2457,6 +2580,15 @@ var HarnessAgentSession = class {
   continueTurn(options) {
     const session = this.requireReusableSession();
     this.requireContinuableTurn();
+    const turnSettings = this.resolveActiveTurnSettings({
+      model: options.model,
+      skills: options.skills,
+      instructions: options.instructions,
+      tools: options.tools,
+      activeTools: options.activeTools,
+      toolSpecs: options.toolSpecs,
+      builtinToolFiltering: options.builtinToolFiltering
+    });
     const sandboxSession = this.getSandboxSession();
     const turnId = this.startTrackedTurn();
     try {
@@ -2464,11 +2596,13 @@ var HarnessAgentSession = class {
         harness: this.harness,
         session,
         mode: "continue",
-        instructions: options.instructions,
-        tools: options.tools,
-        activeTools: options.activeTools,
-        toolSpecs: options.toolSpecs,
-        builtinToolFiltering: options.builtinToolFiltering,
+        model: turnSettings.persisted.model,
+        skills: turnSettings.persisted.skills,
+        instructions: turnSettings.persisted.instructions,
+        tools: turnSettings.tools,
+        activeTools: turnSettings.activeTools,
+        toolSpecs: [...turnSettings.persisted.tools],
+        builtinToolFiltering: turnSettings.builtinToolFiltering,
         sandboxSession: getRestrictedSandboxSession(sandboxSession),
         sessionWorkDir: this.sessionWorkDir,
         runtimeContext: options.runtimeContext,
@@ -2508,7 +2642,10 @@ var HarnessAgentSession = class {
         isTurnSuspending: () => this.activeTurnSequence === turnId && this.suspendedTurnState != null,
         onStopConditionMet: () => this.captureStopConditionBoundary({ session, turnId })
       });
-      return turn;
+      return {
+        ...turn,
+        ready: this.waitForPromptControl({ turnId })
+      };
     } catch (error) {
       this.finishTrackedTurn({ turnId });
       throw error;
@@ -2676,6 +2813,7 @@ var HarnessAgentSession = class {
     return Array.from(this.pendingToolResults.values());
   }
   addPendingToolState(state) {
+    const turnSettings = this.persistedTurnSettings;
     const pendingToolApprovals = this.getPendingToolApprovals();
     const pendingToolResults = this.getPendingToolResults();
     if (pendingToolApprovals.length === 0 && pendingToolResults.length === 0) {
@@ -2683,11 +2821,13 @@ var HarnessAgentSession = class {
         type: state.type,
         harnessId: state.harnessId,
         specificationVersion: state.specificationVersion,
-        data: state.data
+        data: state.data,
+        ...turnSettings == null ? {} : { turnSettings }
       };
     }
     return {
       ...state,
+      ...turnSettings == null ? {} : { turnSettings },
       ...pendingToolApprovals.length > 0 ? { pendingToolApprovals } : {},
       ...pendingToolResults.length > 0 ? { pendingToolResults } : {}
     };
@@ -2787,6 +2927,11 @@ var HarnessAgentSession = class {
     }
     this.settleActivePromptControl(options.control);
   }
+  async waitForPromptControl(options) {
+    const activePromptControl = this.activePromptControl;
+    if ((activePromptControl == null ? void 0 : activePromptControl.turnId) !== options.turnId) return;
+    await activePromptControl.promise;
+  }
   settleActivePromptControl(control) {
     const activePromptControl = this.activePromptControl;
     if (activePromptControl == null || activePromptControl.settled) return;
@@ -2807,8 +2952,40 @@ var HarnessAgentSession = class {
     this.pendingToolApprovals.clear();
     this.pendingToolResults.clear();
     this.suspendedTurnState = void 0;
+    this.activeTurnSettings = void 0;
+    this.persistedTurnSettings = void 0;
     this.turnState = "idle";
   }
+  resolveActiveTurnSettings(options) {
+    var _a4;
+    if (this.activeTurnSettings != null) {
+      return this.activeTurnSettings;
+    }
+    const persisted = (_a4 = this.persistedTurnSettings) != null ? _a4 : {
+      ...options.model == null ? {} : { model: options.model },
+      skills: options.skills,
+      ...options.instructions == null ? {} : { instructions: options.instructions },
+      tools: options.toolSpecs
+    };
+    this.persistedTurnSettings = persisted;
+    const activeTools = {};
+    for (const toolSpec of persisted.tools) {
+      const tool = options.activeTools[toolSpec.name];
+      if (tool == null) {
+        throw new Error(
+          `HarnessAgent cannot continue turn because tool '${toolSpec.name}' is no longer available.`
+        );
+      }
+      activeTools[toolSpec.name] = tool;
+    }
+    this.activeTurnSettings = {
+      persisted,
+      tools: options.tools,
+      activeTools,
+      builtinToolFiltering: options.builtinToolFiltering
+    };
+    return this.activeTurnSettings;
+  }
   endLocalHandle(options) {
     this.clearActivePromptControl();
     this.sessionState = options.sessionState;
@@ -3395,7 +3572,6 @@ var HarnessAgent = class {
       activeTools: settings.activeTools,
       inactiveTools: settings.inactiveTools
     });
-    this.activeUserTools = toolFiltering.activeUserTools;
     this.builtinToolFiltering = toolFiltering.builtinToolFiltering;
     if (Object.keys(settings.harness.builtinTools).length > 0 && permissionModeNeedsBuiltinSupport({
       permissionMode: this.permissionMode
@@ -3419,7 +3595,7 @@ var HarnessAgent = class {
    * `session.destroy()`.
    */
   async createSession(options) {
-    var _a4, _b4;
+    var _a4, _b4, _c;
     const sessionId = (_a4 = options == null ? void 0 : options.sessionId) != null ? _a4 : generateId5();
     const resumeFrom = options == null ? void 0 : options.resumeFrom;
     const continueFrom = options == null ? void 0 : options.continueFrom;
@@ -3491,6 +3667,7 @@ var HarnessAgent = class {
           "HarnessAgent.createSession: configure `sandbox` on HarnessAgent or pass `sandboxSession` to createSession()."
         );
       }
+      const recipe = await ((_c = harness.getBootstrap) == null ? void 0 : _c.call(harness, { abortSignal }));
       if (isResumedSession) {
         if (sandboxProvider.resumeSession == null) {
           throw new HarnessCapabilityUnsupportedError({
@@ -3509,11 +3686,25 @@ var HarnessAgent = class {
           sessionId,
           workDir: this.sandboxConfig.workDir
         });
-      } else {
-        let recipe;
-        if (harness.getBootstrap != null) {
-          recipe = await harness.getBootstrap({ abortSignal });
+        if (recipe != null) {
+          const recipeIdentity = await hashHarnessBootstrap(recipe);
+          try {
+            await applyBootstrapRecipe({
+              session: resumedSandboxSession.restricted(),
+              recipe,
+              identity: recipeIdentity,
+              defaultWorkingDirectory: resumedSandboxSession.defaultWorkingDirectory,
+              abortSignal
+            });
+          } catch (err) {
+            await cleanupAfterStartFailure({
+              sandboxSession,
+              ownsSandboxLifecycle
+            });
+            throw err;
+          }
         }
+      } else {
         const sandboxBootstrapPlan = await createSandboxBootstrapPlan({
           recipe,
           settings: this.sandboxConfig
@@ -3573,7 +3764,6 @@ var HarnessAgent = class {
     try {
       const baseStartOptions = {
         sessionId,
-        skills: this.settings.skills,
         resumeFrom: validatedResumeFrom,
         continueFrom: effectiveContinueFrom,
         permissionMode: this.permissionMode,
@@ -3596,6 +3786,7 @@ var HarnessAgent = class {
         toolApproval: this.settings.toolApproval,
         pendingToolApprovals: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.pendingToolApprovals,
         pendingToolResults: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.pendingToolResults,
+        turnSettings: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.turnSettings,
         turnState: effectiveContinueFrom == null ? "idle" : effectiveContinueFrom.pendingToolApprovals != null && effectiveContinueFrom.pendingToolApprovals.length > 0 ? "awaiting-approval" : effectiveContinueFrom.pendingToolResults != null && effectiveContinueFrom.pendingToolResults.length > 0 ? "awaiting-tool-result" : "suspended"
       });
     } catch (error) {
@@ -3607,30 +3798,27 @@ var HarnessAgent = class {
     }
   }
   async generate(options) {
-    const turnInput = this._resolveTurnInput(options);
+    const continueTurnInput = this._resolveContinueTurnInput(options);
     const runtimeContext = {};
-    const responseFormat = await this._resolveResponseFormat();
-    const { result, done } = this._startTurn({
+    const { result, done } = continueTurnInput == null ? await this._startPromptTurn({ options, runtimeContext }) : await this._startContinueTurn({
       session: options.session,
-      turnInput,
+      turnInput: continueTurnInput,
       runtimeContext,
-      abortSignal: options.abortSignal,
-      responseFormat
+      abortSignal: options.abortSignal
     });
     await done;
     return this._toGenerateResult(result);
   }
   async stream(options) {
-    const turnInput = this._resolveTurnInput(options);
+    const continueTurnInput = this._resolveContinueTurnInput(options);
     const runtimeContext = {};
-    const responseFormat = await this._resolveResponseFormat();
-    const { result } = this._startTurn({
+    const { result, ready } = continueTurnInput == null ? await this._startPromptTurn({ options, runtimeContext }) : await this._startContinueTurn({
       session: options.session,
-      turnInput,
+      turnInput: continueTurnInput,
       runtimeContext,
-      abortSignal: options.abortSignal,
-      responseFormat
+      abortSignal: options.abortSignal
     });
+    await ready;
     return result;
   }
   /**
@@ -3641,17 +3829,14 @@ var HarnessAgent = class {
   async continueGenerate(options) {
     var _a4, _b4;
     const runtimeContext = {};
-    const responseFormat = await this._resolveResponseFormat();
-    const { result, done } = this._startTurn({
+    const { result, done } = await this._startContinueTurn({
       session: options.session,
       turnInput: {
-        mode: "continue",
         toolApprovalContinuations: (_a4 = options.toolApprovalContinuations) != null ? _a4 : [],
         toolResultContinuations: (_b4 = options.toolResultContinuations) != null ? _b4 : []
       },
       runtimeContext,
-      abortSignal: options.abortSignal,
-      responseFormat
+      abortSignal: options.abortSignal
     });
     await done;
     return this._toGenerateResult(result);
@@ -3667,18 +3852,16 @@ var HarnessAgent = class {
   async continueStream(options) {
     var _a4, _b4;
     const runtimeContext = {};
-    const responseFormat = await this._resolveResponseFormat();
-    const { result } = this._startTurn({
+    const { result, ready } = await this._startContinueTurn({
       session: options.session,
       turnInput: {
-        mode: "continue",
         toolApprovalContinuations: (_a4 = options.toolApprovalContinuations) != null ? _a4 : [],
         toolResultContinuations: (_b4 = options.toolResultContinuations) != null ? _b4 : []
       },
       runtimeContext,
-      abortSignal: options.abortSignal,
-      responseFormat
+      abortSignal: options.abortSignal
     });
+    await ready;
     return result;
   }
   /**
@@ -3692,50 +3875,53 @@ var HarnessAgent = class {
     await options.session.experimental_steerTurn(options.text);
   }
   // ─── Internals ──────────────────────────────────────────────────────
-  _startTurn(input) {
-    if (input.turnInput.mode === "continue") {
-      return input.session.continueTurn({
-        instructions: this.settings.instructions,
-        tools: this.tools,
-        activeTools: this.activeUserTools,
-        toolSpecs: this._toToolSpecs(),
-        builtinToolFiltering: this.builtinToolFiltering,
+  async _startPromptTurn(input) {
+    const turnInput = await this._preparePromptTurnInput(input.options);
+    const responseFormat = await this._resolveResponseFormat();
+    return input.options.session.promptTurn({
+      ...this._buildTurnOptions({
+        turnSettings: turnInput,
+        runtimeContext: input.runtimeContext,
+        abortSignal: input.options.abortSignal,
+        responseFormat
+      }),
+      prompt: turnInput.prompt
+    });
+  }
+  async _startContinueTurn(input) {
+    const turnInput = this._prepareContinueTurnInput(input.turnInput);
+    const responseFormat = await this._resolveResponseFormat();
+    return input.session.continueTurn({
+      ...this._buildTurnOptions({
+        turnSettings: turnInput,
         runtimeContext: input.runtimeContext,
         abortSignal: input.abortSignal,
-        responseFormat: input.responseFormat,
-        output: this.settings.output,
-        telemetry: this.settings.telemetry,
-        stopConditions: this.stopConditions,
-        toolApprovalContinuations: input.turnInput.toolApprovalContinuations,
-        toolResultContinuations: input.turnInput.toolResultContinuations
-      });
-    }
-    return input.session.promptTurn({
-      prompt: input.turnInput.prompt,
-      instructions: this.settings.instructions,
-      tools: this.tools,
-      activeTools: this.activeUserTools,
-      toolSpecs: this._toToolSpecs(),
-      builtinToolFiltering: this.builtinToolFiltering,
+        responseFormat
+      }),
+      toolApprovalContinuations: turnInput.toolApprovalContinuations,
+      toolResultContinuations: turnInput.toolResultContinuations
+    });
+  }
+  _buildTurnOptions(input) {
+    return {
+      model: input.turnSettings.model,
+      skills: input.turnSettings.skills,
+      instructions: input.turnSettings.instructions,
+      tools: input.turnSettings.tools,
+      activeTools: input.turnSettings.activeTools,
+      toolSpecs: input.turnSettings.toolSpecs,
+      builtinToolFiltering: input.turnSettings.builtinToolFiltering,
       runtimeContext: input.runtimeContext,
       abortSignal: input.abortSignal,
       responseFormat: input.responseFormat,
       output: this.settings.output,
       telemetry: this.settings.telemetry,
       stopConditions: this.stopConditions
-    });
+    };
   }
-  /*
-   * Reduce AI SDK input to the single user message the harness should run
-   * for this turn. The harness session owns prior-turn state (system
-   * prompt, assistant turns, tool results) — we never replay it. A bare
-   * string is forwarded as-is; a message array is collapsed to its last
-   * `role: 'user'` entry. Inputs whose only messages are non-user (system,
-   * assistant, tool) have no fresh user input and are rejected.
-   */
-  _resolveTurnInput(options) {
+  _resolveContinueTurnInput(options) {
     if (typeof options.prompt === "string") {
-      return { mode: "prompt", prompt: options.prompt };
+      return void 0;
     }
     const messages = Array.isArray(options.prompt) ? options.prompt : options.messages;
     if (Array.isArray(messages)) {
@@ -3743,15 +3929,30 @@ var HarnessAgent = class {
       const toolResultContinuations = collectHarnessAgentToolResultContinuations({ messages });
       if (toolApprovalContinuations.length > 0 || toolResultContinuations.length > 0) {
         return {
-          mode: "continue",
           toolApprovalContinuations,
           toolResultContinuations
         };
       }
+    }
+    return void 0;
+  }
+  /*
+   * Reduce AI SDK input to the single user message the harness should run
+   * for this turn. The harness session owns prior-turn state (system
+   * prompt, assistant turns, tool results) — we never replay it. A bare
+   * string is forwarded as-is; a message array is collapsed to its last
+   * `role: 'user'` entry. Inputs whose only messages are non-user (system,
+   * assistant, tool) have no fresh user input and are rejected.
+   */
+  _resolvePromptTurnInput(options) {
+    if (typeof options.prompt === "string") {
+      return options.prompt;
+    }
+    const messages = Array.isArray(options.prompt) ? options.prompt : options.messages;
+    if (Array.isArray(messages)) {
       for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
-        if ((message == null ? void 0 : message.role) === "user")
-          return { mode: "prompt", prompt: message };
+        if ((message == null ? void 0 : message.role) === "user") return message;
       }
       throw new Error(
         'HarnessAgent: messages must contain at least one `role: "user"` entry.'
@@ -3759,15 +3960,111 @@ var HarnessAgent = class {
     }
     throw new Error("HarnessAgent: either `prompt` or `messages` is required.");
   }
+  async _preparePromptTurnInput(options) {
+    var _a4, _b4, _c;
+    let callOptions = options;
+    if (this.settings.callOptionsSchema != null && options.options !== void 0) {
+      const validatedOptions = await validateTypes({
+        value: options.options,
+        schema: this.settings.callOptionsSchema,
+        context: { field: "options" }
+      });
+      callOptions = {
+        ...options,
+        options: validatedOptions
+      };
+    }
+    const {
+      session: _session,
+      abortSignal: _abortSignal,
+      timeout: _timeout,
+      onStart: _onStart,
+      experimental_onStart: _experimentalOnStart,
+      onStepStart: _onStepStart,
+      experimental_onStepStart: _experimentalOnStepStart,
+      onToolExecutionStart: _onToolExecutionStart,
+      experimental_onToolCallStart: _experimentalOnToolCallStart,
+      onToolExecutionEnd: _onToolExecutionEnd,
+      experimental_onToolCallFinish: _experimentalOnToolCallFinish,
+      onStepEnd: _onStepEnd,
+      onStepFinish: _onStepFinish,
+      onEnd: _onEnd,
+      onFinish: _onFinish,
+      experimental_sandbox: _experimentalSandbox,
+      ...promptOptions
+    } = callOptions;
+    const baseCallArgs = {
+      model: this.settings.model,
+      skills: this.settings.skills,
+      instructions: this.settings.instructions,
+      tools: this.settings.tools,
+      ...promptOptions
+    };
+    const preparedCallArgs = (_c = await ((_b4 = (_a4 = this.settings).prepareCall) == null ? void 0 : _b4.call(
+      _a4,
+      baseCallArgs
+    ))) != null ? _c : baseCallArgs;
+    if (this._resolveContinueTurnInput(preparedCallArgs) != null) {
+      throw new Error(
+        "HarnessAgent.prepareCall must return a fresh user prompt, not a tool continuation."
+      );
+    }
+    return {
+      prompt: this._resolvePromptTurnInput(preparedCallArgs),
+      ...this._prepareTurnSettings({
+        model: preparedCallArgs.model,
+        skills: preparedCallArgs.skills,
+        instructions: preparedCallArgs.instructions,
+        tools: preparedCallArgs.tools
+      })
+    };
+  }
+  _prepareContinueTurnInput(options) {
+    var _a4, _b4;
+    return {
+      ...this._prepareTurnSettings({
+        model: this.settings.model,
+        skills: this.settings.skills,
+        instructions: this.settings.instructions,
+        tools: this.settings.tools
+      }),
+      toolApprovalContinuations: (_a4 = options.toolApprovalContinuations) != null ? _a4 : [],
+      toolResultContinuations: (_b4 = options.toolResultContinuations) != null ? _b4 : []
+    };
+  }
+  _prepareTurnSettings(options) {
+    var _a4, _b4;
+    const userTools = (_a4 = options.tools) != null ? _a4 : {};
+    const tools = {
+      ...this.settings.harness.builtinTools,
+      ...userTools
+    };
+    const toolFiltering = resolveHarnessAgentToolFiltering({
+      harness: this.settings.harness,
+      userTools,
+      allTools: tools,
+      activeTools: this.settings.activeTools,
+      inactiveTools: this.settings.inactiveTools
+    });
+    return {
+      model: options.model,
+      skills: (_b4 = options.skills) != null ? _b4 : [],
+      instructions: options.instructions,
+      tools,
+      activeTools: toolFiltering.activeUserTools,
+      toolSpecs: this._toToolSpecs(toolFiltering.activeUserTools),
+      builtinToolFiltering: toolFiltering.builtinToolFiltering
+    };
+  }
   /*
    * Wire-format projection of user-defined tools only. Harness builtins are
    * executed by the runtime and the bridge already knows about them — we
    * never re-declare them over the wire.
    */
-  _toToolSpecs() {
+  _toToolSpecs(activeUserTools) {
     const specs = [];
     for (const [name4, tool] of Object.entries(
-      this.activeUserTools
+      activeUserTools
     )) {
       const t = tool;
       let inputSchema;