@ai-sdk/sandbox-vercel 1.0.124 → 1.0.126

package/dist/index.js

@@ -1,17 +1,5 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-// src/vercel-sandbox.ts
-import {
-  HarnessSandboxAuthenticationError
-} from "@ai-sdk/harness";
-import { Sandbox } from "@vercel/sandbox";
+// src/vercel-legacy-sandbox-provider.ts
+import { Sandbox as Sandbox2 } from "@vercel/sandbox";
 
 // src/vercel-network-sandbox-session.ts
 import {
@@ -23,36 +11,33 @@ import {
   HarnessCapabilityUnsupportedError
 } from "@ai-sdk/harness";
 var VERCEL_PROVIDER_ID = "vercel-sandbox";
-var _sandbox, _state, _mutationQueue, _VercelNetworkPolicyManager_instances, enqueueMutation_fn, inspectPolicy_fn, applyState_fn;
 var VercelNetworkPolicyManager = class {
+  #sandbox;
+  #state;
+  #mutationQueue = Promise.resolve();
   constructor({ sandbox }) {
-    __privateAdd(this, _VercelNetworkPolicyManager_instances);
-    __privateAdd(this, _sandbox);
-    __privateAdd(this, _state);
-    __privateAdd(this, _mutationQueue, Promise.resolve());
-    __privateSet(this, _sandbox, sandbox);
+    this.#sandbox = sandbox;
   }
   setNetworkPolicy(policy) {
-    return __privateMethod(this, _VercelNetworkPolicyManager_instances, enqueueMutation_fn).call(this, async () => {
-      var _a, _b;
-      const inspection = __privateMethod(this, _VercelNetworkPolicyManager_instances, inspectPolicy_fn).call(this);
-      if (__privateGet(this, _state) == null && inspection.requestTransformationHosts.length > 0) {
+    return this.#enqueueMutation(async () => {
+      const inspection = this.#inspectPolicy();
+      if (this.#state == null && inspection.requestTransformationHosts.length > 0) {
         throw createPolicyConflictError(
           "Cannot set the network policy because the current Vercel Sandbox policy contains request transformations whose redacted values cannot be preserved safely. Replace them explicitly with setRequestTransformations() or rehydrate them with addRequestTransformations() first."
         );
       }
-      await __privateMethod(this, _VercelNetworkPolicyManager_instances, applyState_fn).call(this, {
+      await this.#applyState({
         accessPolicy: toNetworkAccessPolicy(policy),
-        requestTransformations: (_b = (_a = __privateGet(this, _state)) == null ? void 0 : _a.requestTransformations.map(cloneRequestTransformation)) != null ? _b : [],
+        requestTransformations: this.#state?.requestTransformations.map(cloneRequestTransformation) ?? [],
         forwardRules: inspection.forwardRules.map(cloneForwardRule),
         currentPolicy: inspection.currentPolicy
       });
     });
   }
   setRequestTransformations(transformations) {
-    return __privateMethod(this, _VercelNetworkPolicyManager_instances, enqueueMutation_fn).call(this, async () => {
-      const inspection = __privateMethod(this, _VercelNetworkPolicyManager_instances, inspectPolicy_fn).call(this);
-      await __privateMethod(this, _VercelNetworkPolicyManager_instances, applyState_fn).call(this, {
+    return this.#enqueueMutation(async () => {
+      const inspection = this.#inspectPolicy();
+      await this.#applyState({
         accessPolicy: inspection.accessPolicy,
         requestTransformations: transformations.map(cloneRequestTransformation),
         forwardRules: inspection.forwardRules.map(cloneForwardRule),
@@ -61,12 +46,12 @@ var VercelNetworkPolicyManager = class {
     });
   }
   addRequestTransformations(transformations) {
-    return __privateMethod(this, _VercelNetworkPolicyManager_instances, enqueueMutation_fn).call(this, async () => {
-      const inspection = __privateMethod(this, _VercelNetworkPolicyManager_instances, inspectPolicy_fn).call(this);
+    return this.#enqueueMutation(async () => {
+      const inspection = this.#inspectPolicy();
       const incomingTransformations = transformations.map(
         cloneRequestTransformation
       );
-      if (__privateGet(this, _state) == null) {
+      if (this.#state == null) {
         const incomingPolicy = composeNetworkPolicy({
           accessPolicy: inspection.accessPolicy,
           requestTransformations: incomingTransformations,
@@ -82,10 +67,10 @@ var VercelNetworkPolicyManager = class {
           );
         }
       }
-      await __privateMethod(this, _VercelNetworkPolicyManager_instances, applyState_fn).call(this, {
+      await this.#applyState({
         accessPolicy: inspection.accessPolicy,
-        requestTransformations: __privateGet(this, _state) == null ? incomingTransformations : mergeRequestTransformations({
-          existing: __privateGet(this, _state).requestTransformations,
+        requestTransformations: this.#state == null ? incomingTransformations : mergeRequestTransformations({
+          existing: this.#state.requestTransformations,
           incoming: incomingTransformations
         }),
         forwardRules: inspection.forwardRules.map(cloneForwardRule),
@@ -93,61 +78,55 @@ var VercelNetworkPolicyManager = class {
       });
     });
   }
-};
-_sandbox = new WeakMap();
-_state = new WeakMap();
-_mutationQueue = new WeakMap();
-_VercelNetworkPolicyManager_instances = new WeakSet();
-enqueueMutation_fn = function(operation) {
-  const result = __privateGet(this, _mutationQueue).then(operation);
-  __privateSet(this, _mutationQueue, result.then(
-    () => void 0,
-    () => void 0
-  ));
-  return result;
-};
-inspectPolicy_fn = function() {
-  var _a;
-  if (__privateGet(this, _state) != null) {
-    return {
-      accessPolicy: __privateGet(this, _state).accessPolicy,
-      forwardRules: __privateGet(this, _state).forwardRules,
-      requestTransformationHosts: [],
-      currentPolicy: __privateGet(this, _state).effectivePolicy
-    };
+  #enqueueMutation(operation) {
+    const result = this.#mutationQueue.then(operation);
+    this.#mutationQueue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
   }
-  return inspectCurrentPolicy(
-    (_a = __privateGet(this, _sandbox).currentSession().networkPolicy) != null ? _a : "allow-all"
-  );
-};
-applyState_fn = async function({
-  accessPolicy,
-  requestTransformations,
-  forwardRules,
-  currentPolicy
-}) {
-  const effectivePolicy = composeNetworkPolicy({
+  #inspectPolicy() {
+    if (this.#state != null) {
+      return {
+        accessPolicy: this.#state.accessPolicy,
+        forwardRules: this.#state.forwardRules,
+        requestTransformationHosts: [],
+        currentPolicy: this.#state.effectivePolicy
+      };
+    }
+    return inspectCurrentPolicy(
+      this.#sandbox.currentSession().networkPolicy ?? "allow-all"
+    );
+  }
+  async #applyState({
     accessPolicy,
     requestTransformations,
-    forwardRules
-  });
-  if (!areNetworkPoliciesEqual({
-    first: currentPolicy,
-    second: effectivePolicy
-  })) {
-    await __privateGet(this, _sandbox).update({ networkPolicy: effectivePolicy });
+    forwardRules,
+    currentPolicy
+  }) {
+    const effectivePolicy = composeNetworkPolicy({
+      accessPolicy,
+      requestTransformations,
+      forwardRules
+    });
+    if (!areNetworkPoliciesEqual({
+      first: currentPolicy,
+      second: effectivePolicy
+    })) {
+      await this.#sandbox.update({ networkPolicy: effectivePolicy });
+    }
+    this.#state = {
+      accessPolicy: cloneNetworkAccessPolicy(accessPolicy),
+      requestTransformations: requestTransformations.map(
+        cloneRequestTransformation
+      ),
+      forwardRules: forwardRules.map(cloneForwardRule),
+      effectivePolicy
+    };
   }
-  __privateSet(this, _state, {
-    accessPolicy: cloneNetworkAccessPolicy(accessPolicy),
-    requestTransformations: requestTransformations.map(
-      cloneRequestTransformation
-    ),
-    forwardRules: forwardRules.map(cloneForwardRule),
-    effectivePolicy
-  });
 };
 function inspectCurrentPolicy(policy) {
-  var _a, _b, _c, _d, _e;
   if (policy === "allow-all" || policy === "deny-all") {
     return {
       accessPolicy: { mode: policy },
@@ -156,7 +135,7 @@ function inspectCurrentPolicy(policy) {
       currentPolicy: policy
     };
   }
-  const allowedHosts = Array.isArray(policy.allow) ? [...policy.allow] : Object.keys((_a = policy.allow) != null ? _a : {});
+  const allowedHosts = Array.isArray(policy.allow) ? [...policy.allow] : Object.keys(policy.allow ?? {});
   const forwardRules = [];
   const requestTransformationHosts = /* @__PURE__ */ new Set();
   if (policy.allow != null && !Array.isArray(policy.allow)) {
@@ -179,8 +158,8 @@ function inspectCurrentPolicy(policy) {
     accessPolicy: {
       mode: "custom",
       allowedHosts: minimizeHostPatterns(allowedHosts),
-      allowedCIDRs: [...(_c = (_b = policy.subnets) == null ? void 0 : _b.allow) != null ? _c : []],
-      deniedCIDRs: [...(_e = (_d = policy.subnets) == null ? void 0 : _d.deny) != null ? _e : []]
+      allowedCIDRs: [...policy.subnets?.allow ?? []],
+      deniedCIDRs: [...policy.subnets?.deny ?? []]
     },
     forwardRules,
     requestTransformationHosts: [...requestTransformationHosts],
@@ -188,16 +167,15 @@ function inspectCurrentPolicy(policy) {
   };
 }
 function toNetworkAccessPolicy(policy) {
-  var _a, _b, _c;
   switch (policy.mode) {
     case "allow-all":
       return { mode: "allow-all" };
     case "deny-all":
       return { mode: "deny-all" };
     case "custom": {
-      const allowedHosts = [...(_a = policy.allowedHosts) != null ? _a : []];
-      const allowedCIDRs = [...(_b = policy.allowedCIDRs) != null ? _b : []];
-      const deniedCIDRs = [...(_c = policy.deniedCIDRs) != null ? _c : []];
+      const allowedHosts = [...policy.allowedHosts ?? []];
+      const allowedCIDRs = [...policy.allowedCIDRs ?? []];
+      const deniedCIDRs = [...policy.deniedCIDRs ?? []];
       if (allowedHosts.length === 0 && allowedCIDRs.length === 0 && deniedCIDRs.length === 0) {
         throw createPolicyConflictError(
           "Custom network policy requires at least one of allowedHosts, allowedCIDRs, or deniedCIDRs to be non-empty."
@@ -336,8 +314,7 @@ function appendRule({
   host,
   rule
 }) {
-  var _a;
-  const rules = (_a = rulesByHost.get(host)) != null ? _a : [];
+  const rules = rulesByHost.get(host) ?? [];
   rules.push(rule);
   rulesByHost.set(host, rules);
 }
@@ -361,10 +338,9 @@ function toVercelRequestTransformationRule(transformation) {
   };
 }
 function hasRequestTransformation(rule) {
-  var _a, _b;
-  return (_b = (_a = rule.transform) == null ? void 0 : _a.some(
+  return rule.transform?.some(
     (transformation) => transformation.headers != null && Object.keys(transformation.headers).length > 0
-  )) != null ? _b : false;
+  ) ?? false;
 }
 function getRequestTransformationHosts(policy) {
   if (policy === "allow-all" || policy === "deny-all" || policy.allow == null || Array.isArray(policy.allow)) {
@@ -535,7 +511,7 @@ var VercelSandboxSession = class {
     env,
     abortSignal
   }) {
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    abortSignal?.throwIfAborted();
     const finished = await this.sandbox.runCommand({
       cmd: "bash",
       args: ["-c", command],
@@ -559,7 +535,7 @@ var VercelSandboxSession = class {
     env,
     abortSignal
   }) {
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    abortSignal?.throwIfAborted();
     const live = await this.sandbox.runCommand({
       cmd: "bash",
       args: ["-c", command],
@@ -582,7 +558,7 @@ var VercelSandboxSession = class {
     path,
     abortSignal
   }) {
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    abortSignal?.throwIfAborted();
     try {
       const buffer = await this.sandbox.readFileToBuffer(
         { path },
@@ -624,7 +600,7 @@ var VercelSandboxSession = class {
     content,
     abortSignal
   }) {
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    abortSignal?.throwIfAborted();
     const parent = posix.dirname(path);
     if (parent && parent !== "." && parent !== "/") {
       await this.sandbox.runCommand({
@@ -670,29 +646,27 @@ function createSandboxProcess(command, abortSignal) {
     }
   });
   const drained = (async () => {
-    var _a, _b, _c, _d;
     try {
       const iterator = abortSignal ? command.logs({ signal: abortSignal }) : command.logs();
       for await (const message of iterator) {
         const target = message.stream === "stdout" ? controllers.stdout : controllers.stderr;
-        target == null ? void 0 : target.enqueue(encoder.encode(message.data));
+        target?.enqueue(encoder.encode(message.data));
       }
-      (_a = controllers.stdout) == null ? void 0 : _a.close();
-      (_b = controllers.stderr) == null ? void 0 : _b.close();
+      controllers.stdout?.close();
+      controllers.stderr?.close();
     } catch (error) {
-      (_c = controllers.stdout) == null ? void 0 : _c.error(error);
-      (_d = controllers.stderr) == null ? void 0 : _d.error(error);
+      controllers.stdout?.error(error);
+      controllers.stderr?.error(error);
     }
   })();
   return {
     stdout,
     stderr,
     async wait() {
-      var _a;
       const finished = await command.wait();
       await drained;
-      if (abortSignal == null ? void 0 : abortSignal.aborted) {
-        throw (_a = abortSignal.reason) != null ? _a : new DOMException("Aborted", "AbortError");
+      if (abortSignal?.aborted) {
+        throw abortSignal.reason ?? new DOMException("Aborted", "AbortError");
       }
       return { exitCode: finished.exitCode };
     },
@@ -739,13 +713,10 @@ function isFileNotFoundError(error) {
 
 // src/vercel-network-sandbox-session.ts
 var VERCEL_PROVIDER_ID2 = "vercel-sandbox";
-var _networkPolicyManager;
 var VercelNetworkSandboxSession = class extends VercelSandboxSession {
   constructor(input) {
     super(input.sandbox);
-    __privateAdd(this, _networkPolicyManager);
     this.getPortEndpoint = async (options) => {
-      var _a;
       const exposedPorts = this.ports;
       if (!exposedPorts.includes(options.port)) {
         throw new HarnessCapabilityUnsupportedError2({
@@ -753,7 +724,7 @@ var VercelNetworkSandboxSession = class extends VercelSandboxSession {
           message: `Port ${options.port} is not exposed on this sandbox. Exposed ports: [${exposedPorts.join(", ")}].`
         });
       }
-      const protocol = (_a = options.protocol) != null ? _a : "https";
+      const protocol = options.protocol ?? "https";
       const url = new URL(this.sandbox.domain(options.port));
       const isSecure = url.protocol === "https:";
       switch (protocol) {
@@ -776,18 +747,18 @@ var VercelNetworkSandboxSession = class extends VercelSandboxSession {
       return (await this.getPortEndpoint(options)).url;
     };
     this.setNetworkPolicy = async (policy) => {
-      await __privateGet(this, _networkPolicyManager).setNetworkPolicy(policy);
+      await this.#networkPolicyManager.setNetworkPolicy(policy);
     };
     this.setRequestTransformations = async (transformations) => {
-      await __privateGet(this, _networkPolicyManager).setRequestTransformations(transformations);
+      await this.#networkPolicyManager.setRequestTransformations(transformations);
     };
     this.addRequestTransformations = async (transformations) => {
-      await __privateGet(this, _networkPolicyManager).addRequestTransformations(transformations);
+      await this.#networkPolicyManager.addRequestTransformations(transformations);
     };
     this.setPorts = async (ports, options) => {
       await this.sandbox.update(
         { ports: [...ports] },
-        (options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : void 0
+        options?.abortSignal ? { signal: options.abortSignal } : void 0
       );
     };
     this.stop = async () => {
@@ -803,10 +774,11 @@ var VercelNetworkSandboxSession = class extends VercelSandboxSession {
     this.ownsLifecycle = input.ownsLifecycle;
     this.id = input.sandbox.name;
     this.defaultWorkingDirectory = input.sandbox.currentSession().cwd;
-    __privateSet(this, _networkPolicyManager, new VercelNetworkPolicyManager({
+    this.#networkPolicyManager = new VercelNetworkPolicyManager({
       sandbox: input.sandbox
-    }));
+    });
   }
+  #networkPolicyManager;
   get ports() {
     return this.sandbox.routes.map((route) => route.port);
   }
@@ -814,154 +786,15 @@ var VercelNetworkSandboxSession = class extends VercelSandboxSession {
     return new VercelSandboxSession(this.sandbox);
   }
 };
-_networkPolicyManager = new WeakMap();
 
-// src/vercel-sandbox.ts
+// src/utils.ts
+import { HarnessSandboxAuthenticationError } from "@ai-sdk/harness";
+import { Sandbox } from "@vercel/sandbox";
+var VERCEL_PROVIDER_ID3 = "vercel-sandbox";
 var DEFAULT_SANDBOX_TIMEOUT_MS = 30 * 60 * 1e3;
 var DEFAULT_SANDBOX_RUNTIME = "node24";
-var VERCEL_PROVIDER_ID3 = "vercel-sandbox";
-var TEMPLATE_NAME_PREFIX = "ai-sdk-harness";
-var SESSION_NAME_PREFIX = "ai-sdk-harness-session";
 var SNAPSHOT_POLL_INTERVAL_MS = 500;
 var SNAPSHOT_POLL_TIMEOUT_MS = 3e4;
-function sessionSandboxName(sessionId) {
-  return `${SESSION_NAME_PREFIX}-${sessionId}`;
-}
-function hasExplicitSandboxEnvironment(params) {
-  return "runtime" in params && params.runtime != null || "image" in params && params.image != null || "source" in params && typeof params.source === "object" && params.source != null && "type" in params.source && params.source.type === "snapshot";
-}
-function createVercelSandbox(settings = {}) {
-  return new VercelSandboxProvider(settings);
-}
-var VercelSandboxProvider = class {
-  constructor(settings) {
-    this.settings = settings;
-    this.specificationVersion = "harness-sandbox-v1";
-    this.providerId = VERCEL_PROVIDER_ID3;
-    this.createSession = async (options) => {
-      var _a, _b, _c;
-      (_a = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a.throwIfAborted();
-      if ("sandbox" in this.settings && this.settings.sandbox != null) {
-        return new VercelNetworkSandboxSession({
-          sandbox: this.settings.sandbox,
-          ownsLifecycle: false
-        });
-      }
-      const settings = this.settings;
-      const {
-        sandbox: _ignoredSandbox,
-        name: explicitName,
-        ...createParams
-      } = settings;
-      const baseParams = {
-        ...hasExplicitSandboxEnvironment(createParams) ? {} : { runtime: DEFAULT_SANDBOX_RUNTIME },
-        ...createParams,
-        timeout: (_b = createParams.timeout) != null ? _b : DEFAULT_SANDBOX_TIMEOUT_MS
-      };
-      const identity = options == null ? void 0 : options.identity;
-      const onFirstCreate = options == null ? void 0 : options.onFirstCreate;
-      const sessionNameOverride = (options == null ? void 0 : options.sessionId) ? { name: sessionSandboxName(options.sessionId) } : {};
-      if (identity == null || onFirstCreate == null) {
-        const sandbox = await withVercelSandboxAuthenticationError({
-          settings: this.settings,
-          operation: () => Sandbox.create({
-            ...baseParams,
-            ...sessionNameOverride,
-            ...(options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : {}
-          })
-        });
-        return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
-      }
-      const templateName = explicitName != null ? explicitName : `${TEMPLATE_NAME_PREFIX}-${identity}`;
-      const cache = getSnapshotCache();
-      let snapshotId = cache.get(templateName);
-      if (snapshotId == null) {
-        const template = await withVercelSandboxAuthenticationError({
-          settings: this.settings,
-          operation: () => {
-            var _a2;
-            return Sandbox.getOrCreate({
-              ...baseParams,
-              name: templateName,
-              persistent: true,
-              snapshotExpiration: (_a2 = baseParams.snapshotExpiration) != null ? _a2 : 0,
-              onCreate: async (sbx) => {
-                await onFirstCreate(new VercelSandboxSession(sbx), {
-                  abortSignal: options == null ? void 0 : options.abortSignal
-                });
-              },
-              ...(options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : {}
-            });
-          }
-        });
-        let resolvedId = template.currentSnapshotId;
-        if (resolvedId == null) {
-          const stopResult = await withVercelSandboxAuthenticationError({
-            settings: this.settings,
-            operation: () => template.stop(
-              (options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : void 0
-            )
-          });
-          resolvedId = (_c = stopResult.snapshot) == null ? void 0 : _c.id;
-          if (resolvedId == null) {
-            resolvedId = await withVercelSandboxAuthenticationError({
-              settings: this.settings,
-              operation: () => pollForTemplateSnapshot({
-                name: templateName,
-                lookupParams: getSandboxLookupParams(baseParams),
-                abortSignal: options == null ? void 0 : options.abortSignal
-              })
-            });
-          }
-        }
-        cache.set(templateName, resolvedId);
-        snapshotId = resolvedId;
-      }
-      const {
-        runtime: _ignoredRuntime,
-        image: _ignoredImage,
-        source: _ignoredSource,
-        persistent: _ignoredPersistent,
-        ...forkParams
-      } = baseParams;
-      const fork = await withVercelSandboxAuthenticationError({
-        settings: this.settings,
-        operation: () => Sandbox.create({
-          ...forkParams,
-          source: { type: "snapshot", snapshotId },
-          ...sessionNameOverride,
-          ...(options == null ? void 0 : options.abortSignal) ? { signal: options.abortSignal } : {}
-        })
-      });
-      return new VercelNetworkSandboxSession({
-        sandbox: fork,
-        ownsLifecycle: true
-      });
-    };
-    this.resumeSession = async (options) => {
-      var _a;
-      (_a = options.abortSignal) == null ? void 0 : _a.throwIfAborted();
-      if ("sandbox" in this.settings && this.settings.sandbox != null) {
-        return new VercelNetworkSandboxSession({
-          sandbox: this.settings.sandbox,
-          ownsLifecycle: false
-        });
-      }
-      const sandbox = await withVercelSandboxAuthenticationError({
-        settings: this.settings,
-        operation: () => Sandbox.get({
-          ...getSandboxLookupParams(this.settings),
-          name: sessionSandboxName(options.sessionId),
-          ...options.abortSignal ? { signal: options.abortSignal } : {}
-        })
-      });
-      return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
-    };
-  }
-};
-var SNAPSHOT_CACHE_KEY = /* @__PURE__ */ Symbol.for(
-  "ai-sdk.harness.vercel-template-snapshots"
-);
 function getSandboxLookupParams(settings) {
   if ("sandbox" in settings && settings.sandbox != null) {
     return {};
@@ -974,15 +807,6 @@ function getSandboxLookupParams(settings) {
     ...token ? { token } : {}
   };
 }
-function getSnapshotCache() {
-  const globals = globalThis;
-  let cache = globals[SNAPSHOT_CACHE_KEY];
-  if (cache == null) {
-    cache = /* @__PURE__ */ new Map();
-    globals[SNAPSHOT_CACHE_KEY] = cache;
-  }
-  return cache;
-}
 var VERCEL_SANDBOX_AUTHENTICATION_MESSAGE = "Vercel Sandbox authentication failed. Set VERCEL_OIDC_TOKEN, or pass token, teamId, and projectId to createVercelSandbox(), then verify that they can access Vercel Sandbox.";
 async function withVercelSandboxAuthenticationError({
   settings,
@@ -1014,14 +838,13 @@ function isVercelSandboxAuthenticationFailure({
   error,
   hasConfiguredCredentials: hasConfiguredCredentials2
 }) {
-  var _a, _b, _c, _d;
   const seen = /* @__PURE__ */ new Set();
   let current = error;
   while (current != null && !seen.has(current)) {
     seen.add(current);
     if (typeof current === "object") {
       const candidate = current;
-      if (((_a = candidate.response) == null ? void 0 : _a.status) === 401 || ((_b = candidate.response) == null ? void 0 : _b.status) === 403 || ((_c = candidate.response) == null ? void 0 : _c.statusCode) === 401 || ((_d = candidate.response) == null ? void 0 : _d.statusCode) === 403) {
+      if (candidate.response?.status === 401 || candidate.response?.status === 403 || candidate.response?.statusCode === 401 || candidate.response?.statusCode === 403) {
         return true;
       }
       if (typeof candidate.name === "string" && VERCEL_AUTHENTICATION_ERROR_NAMES.has(candidate.name)) {
@@ -1049,6 +872,70 @@ var VERCEL_AUTHENTICATION_ERROR_NAMES = /* @__PURE__ */ new Set([
   "VercelOidcTokenError"
 ]);
 var VERCEL_AUTHENTICATION_ERROR_MESSAGE = /Could not get credentials from OIDC context|No authentication found|Failed to (?:retrieve|refresh) authentication token|Missing credentials parameters to access the Vercel API|Authentication failed/i;
+function hasExplicitSandboxEnvironment(params) {
+  return "runtime" in params && params.runtime != null || "image" in params && params.image != null || "source" in params && typeof params.source === "object" && params.source != null && "type" in params.source && params.source.type === "snapshot";
+}
+function withDefaultSandboxSettings(createParams) {
+  return {
+    ...hasExplicitSandboxEnvironment(createParams) ? {} : { runtime: DEFAULT_SANDBOX_RUNTIME },
+    ...createParams,
+    timeout: createParams.timeout ?? DEFAULT_SANDBOX_TIMEOUT_MS
+  };
+}
+async function ensureTemplateSnapshot({
+  baseParams,
+  templateName,
+  onCreate,
+  lookupParams,
+  abortSignal,
+  snapshotCache
+}) {
+  const cachedSnapshotId = snapshotCache?.get(templateName);
+  if (cachedSnapshotId != null) {
+    return cachedSnapshotId;
+  }
+  const prepared = await Sandbox.getOrCreate({
+    ...baseParams,
+    name: templateName,
+    persistent: true,
+    snapshotExpiration: baseParams.snapshotExpiration ?? 0,
+    onCreate,
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  let snapshotId = prepared.currentSnapshotId;
+  if (snapshotId == null) {
+    const stopped = await prepared.stop(
+      abortSignal ? { signal: abortSignal } : void 0
+    );
+    snapshotId = stopped.snapshot?.id ?? await pollForTemplateSnapshot({
+      name: templateName,
+      lookupParams,
+      abortSignal
+    });
+  }
+  snapshotCache?.set(templateName, snapshotId);
+  return snapshotId;
+}
+function createLiveSandboxFromSnapshot({
+  baseParams,
+  snapshotId,
+  liveName,
+  abortSignal
+}) {
+  const {
+    runtime: _runtime,
+    image: _image,
+    source: _source,
+    persistent: _persistent,
+    ...forkParams
+  } = baseParams;
+  return Sandbox.create({
+    ...forkParams,
+    source: { type: "snapshot", snapshotId },
+    ...liveName != null ? { name: liveName } : {},
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+}
 async function pollForTemplateSnapshot({
   name,
   lookupParams,
@@ -1056,7 +943,7 @@ async function pollForTemplateSnapshot({
 }) {
   const deadline = Date.now() + SNAPSHOT_POLL_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+    abortSignal?.throwIfAborted();
     const refreshed = await Sandbox.get({
       ...lookupParams,
       name,
@@ -1074,8 +961,227 @@ async function pollForTemplateSnapshot({
     `Timed out waiting for snapshot of template "${name}" to publish.`
   );
 }
+
+// src/vercel-legacy-sandbox-provider.ts
+var SESSION_NAME_PREFIX = "ai-sdk-harness-session";
+function sessionSandboxName(sessionId) {
+  return `${SESSION_NAME_PREFIX}-${sessionId}`;
+}
+function createVercelSandbox(settings = {}) {
+  console.warn(
+    "createVercelSandbox is deprecated. Use createVercelNetworkSandboxSession and HarnessAgent.createSession({ sandboxSession }) instead."
+  );
+  return new VercelSandboxProvider(settings);
+}
+var VercelSandboxProvider = class {
+  constructor(settings) {
+    this.settings = settings;
+    this.specificationVersion = "harness-sandbox-v1";
+    this.providerId = VERCEL_PROVIDER_ID3;
+    this.createSession = async (options) => {
+      options?.abortSignal?.throwIfAborted();
+      if ("sandbox" in this.settings && this.settings.sandbox != null) {
+        return new VercelNetworkSandboxSession({
+          sandbox: this.settings.sandbox,
+          ownsLifecycle: false
+        });
+      }
+      const settings = this.settings;
+      const {
+        sandbox: _ignoredSandbox,
+        name: explicitName,
+        ...createParams
+      } = settings;
+      const baseParams = withDefaultSandboxSettings(
+        createParams
+      );
+      const identity = options?.identity;
+      const onFirstCreate = options?.onFirstCreate;
+      const sessionNameOverride = options?.sessionId ? { name: sessionSandboxName(options.sessionId) } : {};
+      if (identity == null || onFirstCreate == null) {
+        const sandbox = await withVercelSandboxAuthenticationError({
+          settings: this.settings,
+          operation: () => Sandbox2.create({
+            ...baseParams,
+            ...sessionNameOverride,
+            ...options?.abortSignal ? { signal: options.abortSignal } : {}
+          })
+        });
+        return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
+      }
+      const templateName = explicitName ?? `ai-sdk-harness-${identity}`;
+      const snapshotId = await withVercelSandboxAuthenticationError({
+        settings: this.settings,
+        operation: () => ensureTemplateSnapshot({
+          baseParams,
+          templateName,
+          lookupParams: getSandboxLookupParams(baseParams),
+          abortSignal: options?.abortSignal,
+          snapshotCache: getSnapshotCache(),
+          onCreate: async (sbx) => {
+            await onFirstCreate(new VercelSandboxSession(sbx), {
+              abortSignal: options?.abortSignal
+            });
+          }
+        })
+      });
+      const fork = await withVercelSandboxAuthenticationError({
+        settings: this.settings,
+        operation: () => createLiveSandboxFromSnapshot({
+          baseParams,
+          snapshotId,
+          liveName: sessionNameOverride.name,
+          abortSignal: options?.abortSignal
+        })
+      });
+      return new VercelNetworkSandboxSession({
+        sandbox: fork,
+        ownsLifecycle: true
+      });
+    };
+    this.resumeSession = async (options) => {
+      options.abortSignal?.throwIfAborted();
+      if ("sandbox" in this.settings && this.settings.sandbox != null) {
+        return new VercelNetworkSandboxSession({
+          sandbox: this.settings.sandbox,
+          ownsLifecycle: false
+        });
+      }
+      const sandbox = await withVercelSandboxAuthenticationError({
+        settings: this.settings,
+        operation: () => Sandbox2.get({
+          ...getSandboxLookupParams(this.settings),
+          name: sessionSandboxName(options.sessionId),
+          ...options.abortSignal ? { signal: options.abortSignal } : {}
+        })
+      });
+      return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
+    };
+    console.warn(
+      "VercelSandboxProvider is deprecated. Use createVercelNetworkSandboxSession instead."
+    );
+  }
+};
+var SNAPSHOT_CACHE_KEY = /* @__PURE__ */ Symbol.for(
+  "ai-sdk.harness.vercel-template-snapshots"
+);
+function getSnapshotCache() {
+  const globals = globalThis;
+  let cache = globals[SNAPSHOT_CACHE_KEY];
+  if (cache == null) {
+    cache = /* @__PURE__ */ new Map();
+    globals[SNAPSHOT_CACHE_KEY] = cache;
+  }
+  return cache;
+}
+
+// src/vercel-sandbox.ts
+import { Sandbox as Sandbox3 } from "@vercel/sandbox";
+async function createVercelNetworkSandboxSession(options = {}) {
+  if ("sandbox" in options) {
+    throw new Error(
+      "createVercelNetworkSandboxSession: use createVercelNetworkSandboxSessionFromNativeSandbox for an existing sandbox."
+    );
+  }
+  const {
+    template,
+    abortSignal,
+    sandboxId,
+    sandbox: _sandbox,
+    ...nativeOptions
+  } = options;
+  const effectiveSignal = abortSignal ?? nativeOptions.signal;
+  effectiveSignal?.throwIfAborted();
+  const { name, ...creationOptions } = nativeOptions;
+  if (sandboxId != null && name != null && sandboxId !== name) {
+    throw new Error(
+      "createVercelNetworkSandboxSession: sandboxId and name must match when both are provided."
+    );
+  }
+  const liveName = sandboxId ?? name;
+  const baseParams = withDefaultSandboxSettings({
+    ...creationOptions,
+    ...effectiveSignal ? { signal: effectiveSignal } : {}
+  });
+  const settings = options;
+  if (template == null) {
+    const sandbox = await withVercelSandboxAuthenticationError({
+      settings,
+      operation: () => Sandbox3.create({
+        ...baseParams,
+        ...liveName != null ? { name: liveName } : {}
+      })
+    });
+    return createVercelNetworkSandboxSessionFromNativeSandbox(sandbox);
+  }
+  const selection = "source" in baseParams && baseParams.source != null ? baseParams.source : "image" in baseParams && baseParams.image != null ? { image: baseParams.image } : { runtime: baseParams.runtime };
+  const material = JSON.stringify([2, template.identity, selection]);
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", new TextEncoder().encode(material))
+  );
+  const templateName = `ai-sdk-harness-v2-${Array.from(digest.slice(0, 12), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  const snapshotId = await withVercelSandboxAuthenticationError({
+    settings,
+    operation: () => ensureTemplateSnapshot({
+      baseParams,
+      templateName,
+      lookupParams: getSandboxLookupParams(baseParams),
+      abortSignal: effectiveSignal,
+      onCreate: async (sandbox) => {
+        await template.prepare({
+          session: createVercelSandboxSessionFromNativeSandbox(sandbox),
+          abortSignal: effectiveSignal
+        });
+      }
+    })
+  });
+  const liveSandbox = await withVercelSandboxAuthenticationError({
+    settings,
+    operation: () => createLiveSandboxFromSnapshot({
+      baseParams,
+      snapshotId,
+      liveName
+    })
+  });
+  return createVercelNetworkSandboxSessionFromNativeSandbox(liveSandbox);
+}
+async function resumeVercelNetworkSandboxSession(options) {
+  const {
+    sandboxId,
+    abortSignal,
+    signal,
+    name: _name,
+    resume: _resume,
+    ...lookupOptions
+  } = options;
+  const effectiveSignal = abortSignal ?? signal;
+  effectiveSignal?.throwIfAborted();
+  const sandbox = await withVercelSandboxAuthenticationError({
+    settings: options,
+    operation: () => Sandbox3.get({
+      ...lookupOptions,
+      name: sandboxId,
+      resume: true,
+      ...effectiveSignal ? { signal: effectiveSignal } : {}
+    })
+  });
+  return createVercelNetworkSandboxSessionFromNativeSandbox(sandbox);
+}
+function createVercelSandboxSessionFromNativeSandbox(nativeSandbox) {
+  return new VercelSandboxSession(nativeSandbox);
+}
+function createVercelNetworkSandboxSessionFromNativeSandbox(nativeSandbox) {
+  return new VercelNetworkSandboxSession({
+    sandbox: nativeSandbox,
+    ownsLifecycle: true
+  });
+}
 export {
   VercelSandboxProvider,
-  createVercelSandbox
+  createVercelNetworkSandboxSession,
+  createVercelNetworkSandboxSessionFromNativeSandbox,
+  createVercelSandbox,
+  createVercelSandboxSessionFromNativeSandbox,
+  resumeVercelNetworkSandboxSession
 };
 //# sourceMappingURL=index.js.map