@ai-sdk/harness 1.0.74 → 1.0.76

package/dist/index.d.ts

@@ -1263,17 +1263,6 @@ declare function commonTool<TName extends HarnessV1BuiltinToolName, TInput>(comm
 interface HarnessV1SandboxProvider {
     readonly specificationVersion: 'harness-sandbox-v1';
     readonly providerId: string;
-    /**
-     * Pool of ports the consumer reserved on a caller-provided sandbox for
-     * concurrent harness sessions. The session manager leases one port per
-     * session and releases on stop or destroy.
-     *
-     * Only meaningful when the provider wraps a caller-provided sandbox
-     * (the caller pre-declared the ports). In create-new modes the provider
-     * mints a fresh sandbox per session, so no leasing is needed; providers
-     * leave this undefined.
-     */
-    readonly bridgePorts?: ReadonlyArray<number>;
     /**
      * Providers should throw `HarnessSandboxAuthenticationError` when sandbox
      * acquisition fails because credentials are missing, invalid, or not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -46,7 +46,7 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.7",
     "@ai-sdk/provider-utils": "5.0.27",
-    "ai": "7.0.67"
+    "ai": "7.0.69"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -65,7 +65,7 @@
     "typescript": "5.8.3",
     "ws": "^8.21.0",
     "zod": "3.25.76",
-    "@ai-sdk/otel": "1.0.67",
+    "@ai-sdk/otel": "1.0.69",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "engines": {

package/src/agent/harness-agent-session.ts

@@ -10,7 +10,6 @@ import type {
   HarnessV1BuiltinToolFiltering,
   HarnessV1NetworkSandboxSession,
   HarnessV1ResponseFormat,
-  HarnessV1SandboxProvider,
 } from '../v1';
 import type {
   HarnessAgentAdapter,
@@ -24,7 +23,6 @@ import type {
 } from './harness-agent-types';
 import type { HarnessAgentToolApprovalContinuation } from './harness-agent-tool-approval-continuation';
 import type { HarnessAgentToolResultContinuation } from './harness-agent-tool-result-continuation';
-import { releaseBridgePort } from './internal/bridge-port-registry';
 import { validateLifecycleStateData } from './internal/lifecycle-state-validation';
 import { runPrompt } from './internal/run-prompt';
 
@@ -50,9 +48,7 @@ type HarnessAgentTurnState =
  * Live harness session held by the caller.
  *
  * Created by {@link import('./harness-agent').HarnessAgent.createSession}.
- * Owns the underlying adapter session, the network sandbox session, and the
- * bridge-port lease (when the provider wraps a caller-provided sandbox with a
- * port pool).
+ * Owns the underlying adapter session and the network sandbox session.
  *
  * Pass the instance back to `agent.generate` / `agent.stream` on every
  * call; end the local handle with `detach()`, `stop()`, or `destroy()`.
@@ -69,11 +65,10 @@ export class HarnessAgentSession {
   readonly sessionId: string;
 
   private readonly harness: HarnessAgentAdapter;
-  private readonly sandboxProvider: HarnessV1SandboxProvider;
   private readonly sessionWorkDir: string;
+  private readonly ownsSandboxLifecycle: boolean;
   private underlyingSession: HarnessAgentAdapterSession | undefined;
   private sandboxSession: HarnessV1NetworkSandboxSession | undefined;
-  private leasedBridgePort: number | undefined;
   private readonly toolApproval:
     | HarnessAgentToolApprovalConfiguration
     | undefined;
@@ -104,8 +99,7 @@ export class HarnessAgentSession {
     harness: HarnessAgentAdapter;
     underlyingSession: HarnessAgentAdapterSession;
     sandboxSession: HarnessV1NetworkSandboxSession;
-    sandboxProvider: HarnessV1SandboxProvider;
-    leasedBridgePort?: number;
+    ownsSandboxLifecycle?: boolean;
     sessionWorkDir: string;
     toolApproval: HarnessAgentToolApprovalConfiguration | undefined;
     pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
@@ -116,8 +110,7 @@ export class HarnessAgentSession {
     this.harness = options.harness;
     this.underlyingSession = options.underlyingSession;
     this.sandboxSession = options.sandboxSession;
-    this.sandboxProvider = options.sandboxProvider;
-    this.leasedBridgePort = options.leasedBridgePort;
+    this.ownsSandboxLifecycle = options.ownsSandboxLifecycle ?? true;
     this.sessionWorkDir = options.sessionWorkDir;
     this.toolApproval = options.toolApproval;
     for (const approval of options.pendingToolApprovals ?? []) {
@@ -362,15 +355,13 @@ export class HarnessAgentSession {
       });
       return validated;
     } finally {
-      this.endLocalHandle({
-        sessionState: 'detached',
-        releasePortLease: false,
-      });
+      this.endLocalHandle({ sessionState: 'detached' });
     }
   }
 
   /**
-   * Persist enough state to resume later, then stop the runtime and sandbox.
+   * Persist enough state to resume later, then stop the runtime and any
+   * harness-owned sandbox.
    * Returns the resume state for a future
    * `agent.createSession({ sessionId, resumeFrom })` call.
    */
@@ -396,26 +387,26 @@ export class HarnessAgentSession {
       });
       return validated;
     } finally {
-      this.endLocalHandle({
-        sessionState: 'stopped',
-        releasePortLease: true,
-      });
-      await Promise.resolve(sandboxSession.stop()).catch(() => {});
+      this.endLocalHandle({ sessionState: 'stopped' });
+      if (this.ownsSandboxLifecycle) {
+        await Promise.resolve(sandboxSession.stop()).catch(() => {});
+      }
     }
   }
 
   /**
-   * Stop the runtime and discard resumability. The sandbox is destroyed when
-   * the provider supports destruction; otherwise it is stopped.
+   * Stop the runtime and discard resumability. A harness-owned sandbox is
+   * destroyed when supported; otherwise it is stopped.
    */
   async destroy(): Promise<void> {
     if (this.sessionState !== 'active') return;
     const session = this.underlyingSession;
     const sandboxSession = this.getSandboxSession();
-    this.endLocalHandle({ sessionState: 'destroyed', releasePortLease: true });
+    this.endLocalHandle({ sessionState: 'destroyed' });
     if (session != null) {
       await Promise.resolve(session.doDestroy()).catch(() => {});
     }
+    if (!this.ownsSandboxLifecycle) return;
     await Promise.resolve(
       sandboxSession.destroy?.() ?? sandboxSession.stop(),
     ).catch(() => {});
@@ -430,9 +421,8 @@ export class HarnessAgentSession {
    *
    * After this call the session is detached. This in-process handle no
    * longer drives turns; a future slice creates a fresh session from the
-   * returned state. The sandbox is **not** stopped and no port lease is
-   * released, because bridge-backed adapters may still have a live bridge on
-   * that port.
+   * returned state. The sandbox is **not** stopped because bridge-backed
+   * adapters may still have a live bridge.
    */
   async suspendTurn(): Promise<HarnessAgentContinueTurnState> {
     if (this.sessionState !== 'active' || this.underlyingSession == null) {
@@ -449,10 +439,7 @@ export class HarnessAgentSession {
     try {
       return await this.suspendCurrentTurn({ session });
     } finally {
-      this.endLocalHandle({
-        sessionState: 'detached',
-        releasePortLease: false,
-      });
+      this.endLocalHandle({ sessionState: 'detached' });
     }
   }
 
@@ -588,23 +575,10 @@ export class HarnessAgentSession {
 
   private endLocalHandle(options: {
     sessionState: Exclude<HarnessAgentSessionState, 'active'>;
-    releasePortLease: boolean;
   }): void {
     this.sessionState = options.sessionState;
     this.underlyingSession = undefined;
     this.sandboxSession = undefined;
-    if (options.releasePortLease) {
-      this.releasePortLease();
-    }
-  }
-
-  private releasePortLease(): void {
-    if (this.leasedBridgePort == null) return;
-    releaseBridgePort({
-      poolKey: this.sandboxProvider,
-      sessionId: this.sessionId,
-    });
-    this.leasedBridgePort = undefined;
   }
 
   private requireReusableSession(): HarnessAgentAdapterSession {

package/src/agent/harness-agent-settings.ts

@@ -179,12 +179,11 @@ export type HarnessAgentSettings<
   readonly toolApproval?: HarnessAgentToolApprovalConfiguration;
 
   /**
-   * Sandbox provider whose `create()` produces the network sandbox session the
-   * harness runs against. Its `restricted()` view is also propagated to user
-   * tool `execute()` calls (as the `experimental_sandbox` field), typed as
-   * `Experimental_SandboxSession` so tools cannot reach the infra surface.
+   * Optional sandbox provider used to create or resume network sandbox
+   * sessions. When omitted, every `createSession()` call must provide an
+   * existing network sandbox session.
    */
-  readonly sandbox: HarnessV1SandboxProvider;
+  readonly sandbox?: HarnessV1SandboxProvider;
 
   /**
    * Sandbox working-directory and lifecycle hook configuration.

package/src/agent/harness-agent.ts

@@ -5,7 +5,6 @@ import type {
   HarnessV1JSONSchema,
   HarnessV1NetworkSandboxSession,
   HarnessV1ResponseFormat,
-  HarnessV1SandboxProvider,
 } from '../v1';
 import {
   asArray,
@@ -48,17 +47,15 @@ import {
   collectHarnessAgentToolResultContinuations,
   type HarnessAgentToolResultContinuation,
 } from './harness-agent-tool-result-continuation';
-import { applyBootstrapRecipe } from './internal/bootstrap-recipe';
 import {
-  acquireBridgePort,
-  releaseBridgePort,
-} from './internal/bridge-port-registry';
+  applyBootstrapRecipe,
+  hashHarnessBootstrap,
+} from './internal/bootstrap-recipe';
 import {
   createSandboxBootstrapPlan,
   ensureSandboxDirectory,
   resolveSessionWorkDir,
   validateSandboxBootstrapSettings,
-  type SandboxBootstrapPlan,
 } from './internal/sandbox-bootstrap';
 import { buildObservability } from './internal/resolve-observability';
 import { validateLifecycleStateData } from './internal/lifecycle-state-validation';
@@ -110,12 +107,13 @@ export interface HarnessAgentCallExtensions {
  *    the result is fed back to the harness via `submitToolResult`.
  *    Adapter builtin tools (e.g. Claude Code's `Bash`) pass through
  *    untouched.
- *  - **Sandbox propagation.** `settings.sandbox` is a sandbox provider.
- *    On `createSession`, the agent calls `provider.createSession()` (or
- *    `resumeSession()`) and passes the resulting network sandbox session into
- *    `doStart`. Its `restricted()` view (a tool-safe
+ *  - **Sandbox propagation.** On `createSession`, the agent uses a
+ *    caller-provided network sandbox session when present; otherwise it calls
+ *    the configured provider's `createSession()` (or `resumeSession()`). It
+ *    passes the selected session into `doStart`. Its `restricted()` view (a tool-safe
  *    `Experimental_SandboxSession`) is handed to user-tool `execute()` calls
- *    via `experimental_sandbox`.
+ *    via `experimental_sandbox`. Caller-provided sandboxes remain owned by the
+ *    caller and are not stopped or destroyed by the harness layer.
  */
 export class HarnessAgent<
   THarness extends HarnessAgentAdapter<any> = HarnessAgentAdapter,
@@ -235,14 +233,21 @@ export class HarnessAgent<
      * handing it to the adapter.
      */
     continueFrom?: HarnessAgentContinueTurnState;
+    /**
+     * Existing network sandbox session to run the harness in. When provided,
+     * the caller retains ownership of the sandbox lifecycle.
+     */
+    sandboxSession?: HarnessV1NetworkSandboxSession;
     abortSignal?: AbortSignal;
   }): Promise<HarnessAgentSession> {
     const sessionId = options?.sessionId ?? generateId();
     const resumeFrom = options?.resumeFrom;
     const continueFrom = options?.continueFrom;
+    const providedSandboxSession = options?.sandboxSession;
     const abortSignal = options?.abortSignal;
     const harness = this.settings.harness;
     const sandboxProvider = this.settings.sandbox;
+    const ownsSandboxLifecycle = providedSandboxSession == null;
 
     if (resumeFrom != null && continueFrom != null) {
       throw new Error(
@@ -273,61 +278,121 @@ export class HarnessAgent<
     const isResumedSession =
       validatedResumeFrom != null || effectiveContinueFrom != null;
 
-    let recipe: HarnessV1Bootstrap | undefined;
-    if (harness.getBootstrap != null) {
-      recipe = await harness.getBootstrap({ abortSignal });
-    }
-
-    // Defines the hashes based on both harness bootstrap recipe and
-    // consumer-defined onBootstrap callback.
-    const sandboxBootstrapPlan = await createSandboxBootstrapPlan({
-      recipe,
-      settings: this.sandboxConfig,
-    });
-
     // Acquires the concrete sandbox session, either by starting fresh and then
     // creating a post-bootstrap snapshot, or by reusing a previously created
     // snapshot based on the bootstrap-based hashes.
-    const acquiredSandboxSession = await this._acquireSandbox({
-      sandboxProvider,
-      sessionId,
-      isResume: isResumedSession,
-      bootstrapPlan: sandboxBootstrapPlan,
-      abortSignal,
-    });
+    let sandboxSession: HarnessV1NetworkSandboxSession;
+    let sessionWorkDir: string;
+    if (providedSandboxSession != null) {
+      sandboxSession = providedSandboxSession;
+      sessionWorkDir = resolveSessionWorkDir({
+        defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+        harnessId: harness.harnessId,
+        sessionId,
+        workDir: this.sandboxConfig.workDir,
+      });
 
-    const leased = applyPortLease({
-      provider: sandboxProvider,
-      sandboxSession: acquiredSandboxSession,
-      sessionId,
-    });
-    const sandboxSession = leased.sandboxSession;
-    const leasedBridgePort = leased.port;
-    const sessionWorkDir = resolveSessionWorkDir({
-      defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
-      harnessId: harness.harnessId,
-      sessionId,
-      workDir: sandboxBootstrapPlan.workDir,
-    });
+      const recipe = await harness.getBootstrap?.({ abortSignal });
+      if (recipe != null) {
+        const recipeIdentity = await hashHarnessBootstrap(recipe);
+        try {
+          await applyBootstrapRecipe({
+            session: sandboxSession.restricted(),
+            recipe,
+            identity: recipeIdentity,
+            defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+            abortSignal,
+          });
+        } catch (err) {
+          await cleanupAfterStartFailure({
+            sandboxSession,
+            ownsSandboxLifecycle,
+          });
+          throw err;
+        }
+      }
+    } else {
+      if (sandboxProvider == null) {
+        throw new Error(
+          'HarnessAgent.createSession: configure `sandbox` on HarnessAgent or pass `sandboxSession` to createSession().',
+        );
+      }
 
-    try {
-      // In case the sandbox session was created with a custom sandbox, or in
-      // case the sandbox provider doesn't respect `onFirstCreate`, we still
-      // have to ensure the harness bootstrap recipe has run. In the common
-      // scenario, this will be a cheap no-op based on just a marker check.
-      if (
-        !isResumedSession &&
-        sandboxBootstrapPlan.recipe != null &&
-        sandboxBootstrapPlan.recipeIdentity != null
-      ) {
-        await applyBootstrapRecipe({
-          session: sandboxSession.restricted(),
-          recipe: sandboxBootstrapPlan.recipe,
-          identity: sandboxBootstrapPlan.recipeIdentity,
+      if (isResumedSession) {
+        if (sandboxProvider.resumeSession == null) {
+          throw new HarnessCapabilityUnsupportedError({
+            message: `Sandbox provider '${sandboxProvider.providerId}' does not support resume.`,
+            harnessId: harness.harnessId,
+          });
+        }
+        sandboxSession = await sandboxProvider.resumeSession({
+          sessionId,
+          abortSignal,
+        });
+        sessionWorkDir = resolveSessionWorkDir({
           defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+          harnessId: harness.harnessId,
+          sessionId,
+          workDir: this.sandboxConfig.workDir,
+        });
+      } else {
+        // The logic in this clause applies the bootstrap plan, including both the harness
+        // bootstrap recipe and agent specific sandbox configuration.
+        // The logic matches largely what `prepareHarnessSandboxTemplate()` and
+        // `prepareSandboxForHarness()` do, so they will have to remain aligned.
+        let recipe: HarnessV1Bootstrap | undefined;
+        if (harness.getBootstrap != null) {
+          recipe = await harness.getBootstrap({ abortSignal });
+        }
+
+        // Defines the hashes based on both harness bootstrap recipe and
+        // consumer-defined onBootstrap callback.
+        const sandboxBootstrapPlan = await createSandboxBootstrapPlan({
+          recipe,
+          settings: this.sandboxConfig,
+        });
+
+        sandboxSession = await sandboxProvider.createSession({
+          sessionId,
           abortSignal,
+          identity: sandboxBootstrapPlan.identity,
+          onFirstCreate: sandboxBootstrapPlan.onFirstCreate,
         });
+        sessionWorkDir = resolveSessionWorkDir({
+          defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+          harnessId: harness.harnessId,
+          sessionId,
+          workDir: sandboxBootstrapPlan.workDir,
+        });
+
+        // In case the sandbox session was created with a custom sandbox, or in
+        // case the sandbox provider doesn't respect `onFirstCreate`, we still
+        // have to ensure the harness bootstrap recipe has run. In the common
+        // scenario, this will be a cheap no-op based on just a marker check.
+        if (
+          sandboxBootstrapPlan.recipe != null &&
+          sandboxBootstrapPlan.recipeIdentity != null
+        ) {
+          try {
+            await applyBootstrapRecipe({
+              session: sandboxSession.restricted(),
+              recipe: sandboxBootstrapPlan.recipe,
+              identity: sandboxBootstrapPlan.recipeIdentity,
+              defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+              abortSignal,
+            });
+          } catch (err) {
+            await cleanupAfterStartFailure({
+              sandboxSession,
+              ownsSandboxLifecycle,
+            });
+            throw err;
+          }
+        }
       }
+    }
+
+    try {
       await ensureSandboxDirectory({
         session: sandboxSession,
         workDir: sessionWorkDir,
@@ -342,10 +407,8 @@ export class HarnessAgent<
       }
     } catch (err) {
       await cleanupAfterStartFailure({
-        sandboxProvider,
         sandboxSession,
-        sessionId,
-        leasedBridgePort,
+        ownsSandboxLifecycle,
       });
       throw err;
     }
@@ -371,8 +434,7 @@ export class HarnessAgent<
         harness,
         underlyingSession,
         sandboxSession,
-        sandboxProvider,
-        leasedBridgePort,
+        ownsSandboxLifecycle,
         sessionWorkDir,
         toolApproval: this.settings.toolApproval,
         pendingToolApprovals: effectiveContinueFrom?.pendingToolApprovals,
@@ -390,10 +452,8 @@ export class HarnessAgent<
       });
     } catch (error) {
       await cleanupAfterStartFailure({
-        sandboxProvider,
         sandboxSession,
-        sessionId,
-        leasedBridgePort,
+        ownsSandboxLifecycle,
       });
       throw error;
     }
@@ -590,34 +650,6 @@ export class HarnessAgent<
     });
   }
 
-  private async _acquireSandbox(input: {
-    sandboxProvider: HarnessV1SandboxProvider;
-    sessionId: string;
-    isResume: boolean;
-    bootstrapPlan: SandboxBootstrapPlan;
-    abortSignal: AbortSignal | undefined;
-  }): Promise<HarnessV1NetworkSandboxSession> {
-    const { sandboxProvider } = input;
-    if (input.isResume) {
-      if (sandboxProvider.resumeSession == null) {
-        throw new HarnessCapabilityUnsupportedError({
-          message: `Sandbox provider '${sandboxProvider.providerId}' does not support resume.`,
-          harnessId: this.settings.harness.harnessId,
-        });
-      }
-      return sandboxProvider.resumeSession({
-        sessionId: input.sessionId,
-        abortSignal: input.abortSignal,
-      });
-    }
-    return sandboxProvider.createSession({
-      sessionId: input.sessionId,
-      abortSignal: input.abortSignal,
-      identity: input.bootstrapPlan.identity,
-      onFirstCreate: input.bootstrapPlan.onFirstCreate,
-    });
-  }
-
   /*
    * Reduce AI SDK input to the single user message the harness should run
    * for this turn. The harness session owns prior-turn state (system
@@ -890,64 +922,10 @@ function resolveSandboxConfig(
   };
 }
 
-/*
- * Bridge-port leasing helper. Returns the port-narrowed network sandbox session
- * plus the leased port (or `undefined` when the provider has no port pool). Kept here
- * rather than on the session so the lease is established as part of session
- * start — the session only needs to release it on close/detach.
- */
-function applyPortLease(input: {
-  provider: HarnessV1SandboxProvider;
-  sandboxSession: HarnessV1NetworkSandboxSession;
-  sessionId: string;
-}): {
-  sandboxSession: HarnessV1NetworkSandboxSession;
-  port: number | undefined;
-} {
-  const pool = input.provider.bridgePorts;
-  if (pool == null || pool.length === 0) {
-    return { sandboxSession: input.sandboxSession, port: undefined };
-  }
-  const port = acquireBridgePort({
-    poolKey: input.provider,
-    pool,
-    sessionId: input.sessionId,
-  });
-  return {
-    sandboxSession: narrowNetworkSessionPorts(input.sandboxSession, port),
-    port,
-  };
-}
-
-/*
- * Derive a view of the network sandbox session that reports only the leased
- * port. Implemented as a prototype-delegating overlay so every other member
- * (file I/O, exec, spawn, lifecycle, `restricted`) forwards to the same live
- * instance — only `ports` is shadowed.
- */
-function narrowNetworkSessionPorts(
-  sandboxSession: HarnessV1NetworkSandboxSession,
-  leasedPort: number,
-): HarnessV1NetworkSandboxSession {
-  return Object.create(sandboxSession, {
-    ports: {
-      value: [leasedPort] as ReadonlyArray<number>,
-      enumerable: true,
-    },
-  }) as HarnessV1NetworkSandboxSession;
-}
-
 async function cleanupAfterStartFailure(input: {
-  sandboxProvider: HarnessV1SandboxProvider;
   sandboxSession: HarnessV1NetworkSandboxSession;
-  sessionId: string;
-  leasedBridgePort: number | undefined;
+  ownsSandboxLifecycle: boolean;
 }): Promise<void> {
+  if (!input.ownsSandboxLifecycle) return;
   await Promise.resolve(input.sandboxSession.stop()).catch(() => {});
-  if (input.leasedBridgePort != null) {
-    releaseBridgePort({
-      poolKey: input.sandboxProvider,
-      sessionId: input.sessionId,
-    });
-  }
 }

package/src/agent/internal/harness-stream-text-result.ts

@@ -824,21 +824,10 @@ export class HarnessStreamTextResult<
         return;
       }
       case 'tool-call':
-        this.currentStepContent.push({
-          ...(part as object),
-        } as ContentPart<TOOLS>);
-        return;
       case 'tool-approval-request':
-        this.currentStepContent.push({
-          ...(part as object),
-        } as ContentPart<TOOLS>);
-        return;
       case 'tool-approval-response':
-        this.currentStepContent.push({
-          ...(part as object),
-        } as ContentPart<TOOLS>);
-        return;
       case 'tool-result':
+      case 'tool-error':
         this.currentStepContent.push({
           ...(part as object),
         } as ContentPart<TOOLS>);

package/src/agent/internal/run-prompt.ts

@@ -219,6 +219,19 @@ export function runPrompt<
       string,
       Extract<HarnessV1StreamPart, { type: 'tool-call' }>
     >();
+    /*
+     * Host results are echoed back as `tool-result` events too, so the event
+     * alone cannot say who ran the tool — classify by the originating
+     * `tool-call`. Only an explicit `true` counts: `LanguageModelV4ToolCall`
+     * defines an omitted flag as client-executed. A call missing from the map
+     * arrived in an earlier slice, where nothing here can classify it.
+     */
+    const translateOptions = {
+      isProviderExecuted: (toolCallId: string): boolean => {
+        const rawToolCall = rawToolCallsByToolCallId.get(toolCallId);
+        return rawToolCall == null || rawToolCall.providerExecuted === true;
+      },
+    };
     const pendingApprovalsByApprovalId = new Map(
       pendingToolApprovals.map(approval => [approval.approvalId, approval]),
     );
@@ -709,7 +722,10 @@ export function runPrompt<
         }
 
         // Forward to consumer as soon as possible.
-        for (const part of translateStreamPart<TOOLS>(displayValue)) {
+        for (const part of translateStreamPart<TOOLS>(
+          displayValue,
+          translateOptions,
+        )) {
           result.enqueue(part);
         }