@ai-sdk/harness 1.0.75 → 1.0.76

package/dist/agent/index.js

@@ -45,33 +45,6 @@ import {
   generateId as generateId5
 } from "@ai-sdk/provider-utils";
 
-// src/agent/internal/bridge-port-registry.ts
-var registries = /* @__PURE__ */ new WeakMap();
-function acquireBridgePort(options) {
-  let entry = registries.get(options.poolKey);
-  if (entry == null) {
-    entry = { pool: options.pool, leases: /* @__PURE__ */ new Map() };
-    registries.set(options.poolKey, entry);
-  }
-  const existing = entry.leases.get(options.sessionId);
-  if (existing != null) return existing;
-  const leased = new Set(entry.leases.values());
-  for (const port of entry.pool) {
-    if (!leased.has(port)) {
-      entry.leases.set(options.sessionId, port);
-      return port;
-    }
-  }
-  throw new Error(
-    `No available bridge port \u2014 pool of ${entry.pool.length} ports is fully leased.`
-  );
-}
-function releaseBridgePort(options) {
-  const entry = registries.get(options.poolKey);
-  if (entry == null) return;
-  entry.leases.delete(options.sessionId);
-}
-
 // src/agent/internal/lifecycle-state-validation.ts
 import { safeValidateTypes } from "@ai-sdk/provider-utils";
 async function validateLifecycleStateData(input) {
@@ -2352,22 +2325,21 @@ var HarnessAgentSession = class {
     this.sessionState = "active";
     this.turnSequence = 0;
     this.activeTurnSequence = 0;
-    var _a4, _b4, _c;
+    var _a4, _b4, _c, _d;
     this.sessionId = options.sessionId;
     this.harness = options.harness;
     this.underlyingSession = options.underlyingSession;
     this.sandboxSession = options.sandboxSession;
-    this.sandboxProvider = options.sandboxProvider;
-    this.leasedBridgePort = options.leasedBridgePort;
+    this.ownsSandboxLifecycle = (_a4 = options.ownsSandboxLifecycle) != null ? _a4 : true;
     this.sessionWorkDir = options.sessionWorkDir;
     this.toolApproval = options.toolApproval;
-    for (const approval of (_a4 = options.pendingToolApprovals) != null ? _a4 : []) {
+    for (const approval of (_b4 = options.pendingToolApprovals) != null ? _b4 : []) {
       this.pendingToolApprovals.set(approval.approvalId, approval);
     }
-    for (const pendingResult of (_b4 = options.pendingToolResults) != null ? _b4 : []) {
+    for (const pendingResult of (_c = options.pendingToolResults) != null ? _c : []) {
       this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
     }
-    this.turnState = (_c = options.turnState) != null ? _c : this.pendingToolApprovals.size > 0 ? "awaiting-approval" : this.pendingToolResults.size > 0 ? "awaiting-tool-result" : "idle";
+    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;
   }
   /**
@@ -2547,14 +2519,12 @@ var HarnessAgentSession = class {
       });
       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.
    */
@@ -2580,28 +2550,28 @@ var HarnessAgentSession = class {
       });
       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() {
     var _a4, _b4;
     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(
       (_b4 = (_a4 = sandboxSession.destroy) == null ? void 0 : _a4.call(sandboxSession)) != null ? _b4 : sandboxSession.stop()
     ).catch(() => {
@@ -2616,9 +2586,8 @@ var HarnessAgentSession = class {
    *
    * 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() {
     if (this.sessionState !== "active" || this.underlyingSession == null) {
@@ -2635,10 +2604,7 @@ var HarnessAgentSession = class {
     try {
       return await this.suspendCurrentTurn({ session });
     } finally {
-      this.endLocalHandle({
-        sessionState: "detached",
-        releasePortLease: false
-      });
+      this.endLocalHandle({ sessionState: "detached" });
     }
   }
   getPendingToolApprovals() {
@@ -2748,17 +2714,6 @@ var HarnessAgentSession = class {
     this.sessionState = options.sessionState;
     this.underlyingSession = void 0;
     this.sandboxSession = void 0;
-    if (options.releasePortLease) {
-      this.releasePortLease();
-    }
-  }
-  releasePortLease() {
-    if (this.leasedBridgePort == null) return;
-    releaseBridgePort({
-      poolKey: this.sandboxProvider,
-      sessionId: this.sessionId
-    });
-    this.leasedBridgePort = void 0;
   }
   requireReusableSession() {
     if (this.sessionState !== "active" || this.underlyingSession == null) {
@@ -3356,13 +3311,15 @@ var HarnessAgent = class {
    * `session.destroy()`.
    */
   async createSession(options) {
-    var _a4;
+    var _a4, _b4;
     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;
+    const providedSandboxSession = options == null ? void 0 : options.sandboxSession;
     const abortSignal = options == null ? void 0 : options.abortSignal;
     const harness = this.settings.harness;
     const sandboxProvider = this.settings.sandbox;
+    const ownsSandboxLifecycle = providedSandboxSession == null;
     if (resumeFrom != null && continueFrom != null) {
       throw new Error(
         "HarnessAgent.createSession: pass either `resumeFrom` or `continueFrom`, not both."
@@ -3386,44 +3343,99 @@ var HarnessAgent = class {
     }
     const effectiveContinueFrom = validatedContinueFrom != null ? validatedContinueFrom : validatedResumeFrom == null ? void 0 : validatedResumeFrom.continueFrom;
     const isResumedSession = validatedResumeFrom != null || effectiveContinueFrom != null;
-    let recipe;
-    if (harness.getBootstrap != null) {
-      recipe = await harness.getBootstrap({ abortSignal });
-    }
-    const sandboxBootstrapPlan = await createSandboxBootstrapPlan({
-      recipe,
-      settings: this.sandboxConfig
-    });
-    const acquiredSandboxSession = await this._acquireSandbox({
-      sandboxProvider,
-      sessionId,
-      isResume: isResumedSession,
-      bootstrapPlan: sandboxBootstrapPlan,
-      abortSignal
-    });
-    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
-    });
-    try {
-      if (!isResumedSession && sandboxBootstrapPlan.recipe != null && sandboxBootstrapPlan.recipeIdentity != null) {
-        await applyBootstrapRecipe({
-          session: sandboxSession.restricted(),
-          recipe: sandboxBootstrapPlan.recipe,
-          identity: sandboxBootstrapPlan.recipeIdentity,
-          defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+    let sandboxSession;
+    let sessionWorkDir;
+    if (providedSandboxSession != null) {
+      sandboxSession = providedSandboxSession;
+      sessionWorkDir = resolveSessionWorkDir({
+        defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+        harnessId: harness.harnessId,
+        sessionId,
+        workDir: this.sandboxConfig.workDir
+      });
+      const recipe = await ((_b4 = harness.getBootstrap) == null ? void 0 : _b4.call(harness, { 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()."
+        );
+      }
+      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 {
+        let recipe;
+        if (harness.getBootstrap != null) {
+          recipe = await harness.getBootstrap({ abortSignal });
+        }
+        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
+        });
+        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,
@@ -3438,10 +3450,8 @@ var HarnessAgent = class {
       }
     } catch (err) {
       await cleanupAfterStartFailure({
-        sandboxProvider,
         sandboxSession,
-        sessionId,
-        leasedBridgePort
+        ownsSandboxLifecycle
       });
       throw err;
     }
@@ -3466,8 +3476,7 @@ var HarnessAgent = class {
         harness,
         underlyingSession,
         sandboxSession,
-        sandboxProvider,
-        leasedBridgePort,
+        ownsSandboxLifecycle,
         sessionWorkDir,
         toolApproval: this.settings.toolApproval,
         pendingToolApprovals: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.pendingToolApprovals,
@@ -3476,10 +3485,8 @@ var HarnessAgent = class {
       });
     } catch (error) {
       await cleanupAfterStartFailure({
-        sandboxProvider,
         sandboxSession,
-        sessionId,
-        leasedBridgePort
+        ownsSandboxLifecycle
       });
       throw error;
     }
@@ -3593,27 +3600,6 @@ var HarnessAgent = class {
       stopConditions: this.stopConditions
     });
   }
-  async _acquireSandbox(input) {
-    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
@@ -3780,48 +3766,22 @@ function resolveSandboxConfig(settings) {
     ...((_a4 = settings.sandboxConfig) == null ? void 0 : _a4.onSession) == null && settings.onSandboxSession != null ? { onSession: settings.onSandboxSession } : {}
   };
 }
-function applyPortLease(input) {
-  const pool = input.provider.bridgePorts;
-  if (pool == null || pool.length === 0) {
-    return { sandboxSession: input.sandboxSession, port: void 0 };
-  }
-  const port = acquireBridgePort({
-    poolKey: input.provider,
-    pool,
-    sessionId: input.sessionId
-  });
-  return {
-    sandboxSession: narrowNetworkSessionPorts(input.sandboxSession, port),
-    port
-  };
-}
-function narrowNetworkSessionPorts(sandboxSession, leasedPort) {
-  return Object.create(sandboxSession, {
-    ports: {
-      value: [leasedPort],
-      enumerable: true
-    }
-  });
-}
 async function cleanupAfterStartFailure(input) {
+  if (!input.ownsSandboxLifecycle) return;
   await Promise.resolve(input.sandboxSession.stop()).catch(() => {
   });
-  if (input.leasedBridgePort != null) {
-    releaseBridgePort({
-      poolKey: input.sandboxProvider,
-      sessionId: input.sessionId
-    });
-  }
 }
 
 // src/agent/prepare-harness-sandbox-template.ts
 async function prepareHarnessSandboxTemplate(options) {
-  var _a4, _b4, _c;
+  var _a4;
   const sandboxConfig = (_a4 = options.sandboxConfig) != null ? _a4 : {};
   validateSandboxBootstrapSettings(sandboxConfig);
-  const recipe = await ((_c = (_b4 = options.harness).getBootstrap) == null ? void 0 : _c.call(_b4, {
-    abortSignal: options.abortSignal
-  }));
+  const { harness, sandboxProvider, abortSignal } = options;
+  let recipe;
+  if (harness.getBootstrap != null) {
+    recipe = await harness.getBootstrap({ abortSignal });
+  }
   const bootstrapPlan = await createSandboxBootstrapPlan({
     recipe,
     settings: sandboxConfig
@@ -3829,8 +3789,8 @@ async function prepareHarnessSandboxTemplate(options) {
   if (bootstrapPlan.identity == null || bootstrapPlan.onFirstCreate == null) {
     return;
   }
-  const sandboxSession = await options.sandboxProvider.createSession({
-    abortSignal: options.abortSignal,
+  const sandboxSession = await sandboxProvider.createSession({
+    abortSignal,
     identity: bootstrapPlan.identity,
     onFirstCreate: bootstrapPlan.onFirstCreate
   });
@@ -3841,7 +3801,7 @@ async function prepareHarnessSandboxTemplate(options) {
         recipe: bootstrapPlan.recipe,
         identity: bootstrapPlan.recipeIdentity,
         defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
-        abortSignal: options.abortSignal
+        abortSignal
       });
     }
   } finally {