@finalai/final-agent-provider 0.12.0 → 0.14.0

package/dist/modules/sandboxes/computer.mjs

@@ -2,20 +2,17 @@ import { Capability, FilesAccess, ScreenAccess, ShellAccess } from "@finalai/age
 import { NetworkPolicy } from "@finalai/agent-provider";
 import {
   defineSandboxProvider,
-  FULL_SANDBOX_GRANT,
   materializeSandboxSeeds,
   platformProcessEnvironment,
   PortProtocol,
   reportPlatformNetworkPolicy,
   SandboxCapability,
-  SandboxExecutionOperation,
   sandboxSeedArtifact,
   sandboxSeedArtifactSchema,
   sandboxSeedFiles,
   sandboxSeedFilesForAttach,
   sandboxSeedIdentity,
   withPlatformEgressHosts,
-  withSandboxNetworking,
   writePlatformFiles
 } from "@finalai/agent-provider/sandbox";
 import {
@@ -79,9 +76,7 @@ const computerStateSchema = z.object({
   // The sandbox setup's network policy, enforced from the computer's first boot.
   network: networkPolicySchema,
   // Ports the setup's services listen on.
-  ports: z.array(z.number().int()).default([]),
-  // Workspace Device egress manages this computer's network.
-  networkPolicySaved: z.boolean().default(false)
+  ports: z.array(z.number().int()).default([])
 });
 const computerSandboxError = (code, message) => Object.assign(new Error(message), { name: "ComputerSandboxError", code });
 const HTTP_TOKEN_LIFETIME_MS = 60 * 6e4;
@@ -107,10 +102,6 @@ const CAPTURE_SCRUBBED_PATHS = [
 const BUILDER_IDLE_TIMEOUT_SECONDS = 2 * 60 * 60;
 const ARTIFACT_KEY_VERSION = 1;
 const PROJECT_ARTIFACT_CAPTURE_PROTOCOL_VERSION = 2;
-const networkPolicyFor = (network) => ({
-  mode: network?.egress === ComputerEgressPolicy.Internet ? NetworkPolicy.AllowAll : network?.egress === ComputerEgressPolicy.Allowlist ? NetworkPolicy.Allowlist : NetworkPolicy.DenyAll,
-  allow: network?.allow ?? []
-});
 const computerEgressOf = (policy) => {
   if (policy.mode === NetworkPolicy.AllowAll) return { egress: ComputerEgressPolicy.Internet };
   if (policy.mode === NetworkPolicy.DenyAll) return { egress: ComputerEgressPolicy.None };
@@ -151,16 +142,6 @@ const computeComputerArtifactKey = async (inputs) => {
   );
   return `pa-g${hex.slice(0, 16)}-c${PROJECT_ARTIFACT_CAPTURE_PROTOCOL_VERSION}`;
 };
-const offerContextOf = (ctx) => ({
-  organizationId: ctx.organizationId,
-  projectId: ctx.projectId,
-  sandboxId: ctx.sandboxId,
-  credentials: ctx.credentials,
-  actingUser: ctx.actingUser,
-  identity: ctx.identity,
-  platformEgressHosts: ctx.platformEgressHosts,
-  platformNetworkPolicy: ctx.platformNetworkPolicy
-});
 const createComputerSandboxProvider = (config) => {
   const log = config.log ?? (() => void 0);
   const randomUuid = config.randomUuid ?? (() => crypto.randomUUID());
@@ -237,102 +218,6 @@ const createComputerSandboxProvider = (config) => {
       );
     }
   };
-  const createNetworkingController = (options) => {
-    try {
-      if (config.networking == null) throw new Error("Workspace networking extension is required");
-      return config.networking.controller(options);
-    } catch (cause) {
-      options.onClose?.();
-      throw cause;
-    }
-  };
-  const managedWorkspaces = /* @__PURE__ */ new Set();
-  const savedPolicyWorkspaces = /* @__PURE__ */ new Set();
-  const workspaceKey = (ctx) => `${ctx.organizationId}:${ctx.sandboxId}`;
-  const needsWorkspaceNetworking = async (ctx, query = {}) => {
-    const needed = await config.networking?.enabled({
-      ctx,
-      workspaceId: ctx.sandboxId,
-      grant: FULL_SANDBOX_GRANT,
-      ...query
-    }) ?? false;
-    if (needed) managedWorkspaces.add(workspaceKey(ctx));
-    return needed || managedWorkspaces.has(workspaceKey(ctx));
-  };
-  const preservePolicy = async (args) => {
-    if (config.networking == null) throw new Error("Workspace networking extension is required");
-    const retained = await config.networking.prepare({
-      ctx: args.ctx,
-      workspaceId: args.ctx.sandboxId,
-      policy: args.policy
-    });
-    await args.ctx.platformNetworkPolicy?.(retained ?? args.policy);
-    savedPolicyWorkspaces.add(workspaceKey(args.ctx));
-  };
-  const teardownComputer = async (args) => {
-    const failures = [];
-    let managed = args.policySaved || managedWorkspaces.has(workspaceKey(args.ctx));
-    let queryFailed = false;
-    try {
-      managed = await needsWorkspaceNetworking(args.ctx, { teardown: true }) || args.policySaved;
-    } catch (cause) {
-      failures.push(cause);
-      queryFailed = true;
-    }
-    const results = await Promise.allSettled([
-      (async () => {
-        if (managed && args.fence) {
-          const client = clientFor(args.ctx);
-          let mayFence = args.policySaved || savedPolicyWorkspaces.has(workspaceKey(args.ctx));
-          try {
-            if (config.networking != null) {
-              await preservePolicy({
-                ctx: args.ctx,
-                policy: networkPolicyFor(await client.getNetworkPolicy(args.computerId))
-              });
-              mayFence = true;
-            }
-          } catch (cause) {
-            if (isComputersApiStatus(cause, 404)) mayFence = false;
-            else failures.push(cause);
-          }
-          if (mayFence) {
-            try {
-              await client.setNetworkPolicy(
-                args.computerId,
-                { egress: ComputerEgressPolicy.None },
-                { autoResume: false }
-              );
-            } catch (cause) {
-              let settled = isComputersApiStatus(cause, 404);
-              if (!settled && isComputersApiStatus(cause, 409)) {
-                try {
-                  const latest = await client.getComputer(args.computerId);
-                  settled = latest == null || latest.state === ComputerState.Deleted;
-                } catch (lookup) {
-                  failures.push(lookup);
-                }
-              }
-              if (!settled) failures.push(cause);
-            }
-          }
-        }
-        await args.finish();
-      })(),
-      (async () => {
-        if (managed && config.networking == null)
-          throw new Error(
-            "Managed Computer teardown requires the workspace egress integration to revoke Device access"
-          );
-        if (config.networking != null && (managed || queryFailed))
-          await config.networking.suspend({ ctx: args.ctx, workspaceId: args.ctx.sandboxId });
-      })()
-    ]);
-    for (const result of results) if (result.status === "rejected") failures.push(result.reason);
-    if (failures.length === 1) throw failures[0];
-    if (failures.length > 1)
-      throw new AggregateError(failures, "Computer teardown and egress revocation failed");
-  };
   const setupSession = (args) => {
     const transport = createComputersApiTransport({
       client: args.client,
@@ -356,53 +241,10 @@ const createComputerSandboxProvider = (config) => {
     });
     return { sandbox, transport };
   };
-  const workspaceNetworking = (args) => {
-    if (config.networking == null || !args.enabled) return void 0;
-    return createNetworkingController({
-      ctx: args.ctx,
-      sandbox: args.sandbox,
-      workspaceId: args.ctx.sandboxId,
-      grant: FULL_SANDBOX_GRANT,
-      onClose: args.onClose,
-      initialNetworkPolicy: args.initialNetworkPolicy,
-      namespaceExists: async () => {
-        const current = await args.client.getComputer(args.info.id);
-        return current?.state === ComputerState.Running;
-      },
-      log,
-      afterBlock: () => args.client.setNetworkPolicy(
-        args.info.id,
-        { egress: ComputerEgressPolicy.None },
-        { autoResume: false }
-      ),
-      afterGuard: (policy) => args.client.setNetworkPolicy(
-        args.info.id,
-        egressFor(args.ctx, policy ?? { mode: NetworkPolicy.DenyAll }),
-        { autoResume: false }
-      )
-    });
-  };
   const buildHandle = async (args) => {
     const { client, info } = args;
     const transport = createComputersApiTransport({ client, computerId: info.id });
     let httpToken = null;
-    const fenceOnStop = async () => {
-      if (args.networking != null)
-        await client.setNetworkPolicy(
-          info.id,
-          { egress: ComputerEgressPolicy.None },
-          { autoResume: false }
-        );
-      else if (!args.passive)
-        await teardownComputer({
-          ctx: args.ctx,
-          computerId: info.id,
-          policySaved: args.networkingManaged,
-          fence: true,
-          finish: async () => {
-          }
-        });
-    };
     const session = createTransportSession({
       id: info.id,
       description: `Final computer ${info.name}`,
@@ -414,16 +256,10 @@ const createComputerSandboxProvider = (config) => {
         ports: [...args.ports],
         // The computer's hostname with a preview token, which opens its HTTP ports only.
         getPortEndpoint: async ({ port, protocol }) => {
-          const managed = args.networkingManaged || args.passive && await needsWorkspaceNetworking(args.ctx);
-          if (managed && args.networking == null)
-            throw new Error("Managed workspace previews require an attached sandbox");
-          const deadline = (await args.networking?.authorizeExternalAccess())?.expiresAtMs;
-          if (deadline != null && deadline <= now())
-            throw new Error("Refresh workspace networking before preview access");
           const hostname = info.hostname ?? (await client.getComputer(info.id))?.hostname ?? null;
           if (hostname == null) throw new Error(`computer ${info.name} has no public hostname`);
-          if (httpToken == null || httpToken.expiresAtMs - now() < HTTP_TOKEN_RENEW_MS || deadline != null && httpToken.expiresAtMs > deadline) {
-            const expiresAtMs = Math.min(now() + HTTP_TOKEN_LIFETIME_MS, deadline ?? Infinity);
+          if (httpToken == null || httpToken.expiresAtMs - now() < HTTP_TOKEN_RENEW_MS) {
+            const expiresAtMs = now() + HTTP_TOKEN_LIFETIME_MS;
             const token = await client.createPreviewToken({
               computerId: info.id,
               name: `agent sandbox ${args.ctx.sandboxId}`,
@@ -439,16 +275,6 @@ const createComputerSandboxProvider = (config) => {
         },
         stop: async () => {
           const failures = [];
-          try {
-            await fenceOnStop();
-          } catch (cause) {
-            try {
-              if (!await deletedAfterFenceError({ client, computerId: info.id, cause }))
-                failures.push(cause);
-            } catch (lookup) {
-              failures.push(lookup);
-            }
-          }
           try {
             await closeComputerMcp(info.id);
           } catch (cause) {
@@ -463,35 +289,24 @@ const createComputerSandboxProvider = (config) => {
           args.closeSetup?.();
           if (failures.length === 1) throw failures[0];
           if (failures.length > 1)
-            throw new AggregateError(failures, "Computer stop or networking fence failed");
+            throw new AggregateError(failures, "Computer stop or MCP cleanup failed");
         },
         destroy: async () => {
-          const finish = async () => {
-            const failures = [];
-            try {
-              await closeComputerMcp(info.id);
-            } catch (cause) {
-              failures.push(cause);
-            }
-            transport.close();
-            try {
-              await client.action(info.id, "delete");
-            } catch (cause) {
-              if (!isComputersApiStatus(cause, 404)) failures.push(cause);
-            }
-            if (failures.length === 1) throw failures[0];
-            if (failures.length > 1)
-              throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
-          };
-          if (args.networking == null && !args.passive)
-            await teardownComputer({
-              ctx: args.ctx,
-              computerId: info.id,
-              policySaved: args.networkingManaged,
-              fence: true,
-              finish
-            });
-          else await finish();
+          const failures = [];
+          try {
+            await closeComputerMcp(info.id);
+          } catch (cause) {
+            failures.push(cause);
+          }
+          transport.close();
+          try {
+            await client.action(info.id, "delete");
+          } catch (cause) {
+            if (!isComputersApiStatus(cause, 404)) failures.push(cause);
+          }
+          if (failures.length === 1) throw failures[0];
+          if (failures.length > 1)
+            throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
         }
       }
     });
@@ -535,8 +350,6 @@ const createComputerSandboxProvider = (config) => {
         SandboxCapability.DurableProcesses,
         SandboxCapability.NetworkPolicy
       );
-    if (!args.passive && args.networking != null)
-      capabilities.push(...config.networking?.capabilities ?? []);
     const full = {
       ...session,
       setNetworkPolicy: async (policy) => {
@@ -547,20 +360,10 @@ const createComputerSandboxProvider = (config) => {
     };
     if (computerUse != null) full.computerUse = async () => computerUse.endpoint;
     if (screenAvailable) full.screen = (options) => client.openScreen(info.id, options);
-    let handle = {
+    return {
       sandbox: args.passive ? readOnlySession(full) : full,
       onSandboxStop: async () => {
         const failures = [];
-        try {
-          await fenceOnStop();
-        } catch (cause) {
-          try {
-            if (!await deletedAfterFenceError({ client, computerId: info.id, cause }))
-              failures.push(cause);
-          } catch (lookup) {
-            failures.push(lookup);
-          }
-        }
         for (const finish of [closeMcp, () => transport.close(), () => args.closeSetup?.()]) {
           try {
             await finish();
@@ -569,37 +372,25 @@ const createComputerSandboxProvider = (config) => {
           }
         }
         if (failures.length === 1) throw failures[0];
-        if (failures.length > 1)
-          throw new AggregateError(failures, "Computer fence and MCP cleanup failed");
+        if (failures.length > 1) throw new AggregateError(failures, "Computer MCP cleanup failed");
       },
       onSandboxDelete: async () => {
-        const finish = async () => {
-          const failures = [];
-          try {
-            await closeMcp();
-          } catch (cause) {
-            failures.push(cause);
-          }
-          transport.close();
-          args.closeSetup?.();
-          try {
-            await client.action(info.id, "delete");
-          } catch (cause) {
-            if (!isComputersApiStatus(cause, 404)) failures.push(cause);
-          }
-          if (failures.length === 1) throw failures[0];
-          if (failures.length > 1)
-            throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
-        };
-        if (args.networking == null)
-          await teardownComputer({
-            ctx: args.ctx,
-            computerId: info.id,
-            policySaved: args.networkingManaged,
-            fence: true,
-            finish
-          });
-        else await finish();
+        const failures = [];
+        try {
+          await closeMcp();
+        } catch (cause) {
+          failures.push(cause);
+        }
+        transport.close();
+        args.closeSetup?.();
+        try {
+          await client.action(info.id, "delete");
+        } catch (cause) {
+          if (!isComputersApiStatus(cause, 404)) failures.push(cause);
+        }
+        if (failures.length === 1) throw failures[0];
+        if (failures.length > 1)
+          throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
       },
       onRuntimeShutdown: async () => {
         try {
@@ -610,31 +401,6 @@ const createComputerSandboxProvider = (config) => {
         }
       }
     };
-    if (args.passive) return handle;
-    if (args.networking != null)
-      handle = await withSandboxNetworking({
-        handle,
-        controller: args.networking,
-        grant: FULL_SANDBOX_GRANT,
-        initialized: true,
-        fetch: config.networking?.fetch,
-        executionPolicy: args.ctx.executionPolicy,
-        beforeUse: args.beforeUse
-      });
-    else if (config.networking != null)
-      handle = await withSandboxNetworking({
-        handle,
-        grant: FULL_SANDBOX_GRANT,
-        fetch: config.networking.fetch,
-        executionPolicy: args.ctx.executionPolicy,
-        admission: async () => {
-          if (await needsWorkspaceNetworking(args.ctx))
-            throw new Error(
-              "Workspace networking changed; reconnect this sandbox before running tools"
-            );
-        }
-      });
-    return handle;
   };
   const awaitBase = async (client, baseId, key) => {
     const deadline = now() + (config.buildWaitMs ?? 30 * 6e4);
@@ -840,8 +606,6 @@ ${step.run}`,
         [Capability.Shell]: ShellAccess.Execute,
         [Capability.ComputerUse]: ScreenAccess.Control
       }),
-      // Screen and computer-use availability is known only after attaching the actual Computer.
-      additionalFeatures: async () => config.networking?.capabilities.slice() ?? [],
       processes: async (ctx, rawState, request) => {
         const state = stateOf(rawState);
         if (state.computerId == null) throw new Error("this computer has not started yet");
@@ -862,52 +626,7 @@ ${step.run}`,
           randomUuid,
           expiresAtMs
         });
-        if (request.operation === "available" || request.operation === "close") return open();
-        if (config.networking == null) {
-          if (state.networkPolicySaved)
-            throw new Error("Device networking control is required before opening this editor");
-          return open();
-        }
-        if (ctx.sandboxId == null)
-          throw new Error("The host must name the sandbox before opening an egress-aware editor");
-        const networkingCtx = { ...ctx, sandboxId: ctx.sandboxId };
-        const managed = state.networkPolicySaved || await needsWorkspaceNetworking(networkingCtx);
-        if (!managed) return open();
-        config.networking.validateWorkspaceId?.(ctx.sandboxId);
-        const info = await client.getComputer(computerId);
-        if (info == null || info.state !== ComputerState.Running)
-          throw new Error("Computer must be running before editor access");
-        const initialNetworkPolicy = networkPolicyFor(await client.getNetworkPolicy(info.id));
-        const setup = setupSession({ client, info, env: async () => ({}) });
-        const manager = createNetworkingController({
-          sandbox: setup.sandbox,
-          onClose: () => setup.transport.close(),
-          workspaceId: ctx.sandboxId,
-          ctx,
-          grant: FULL_SANDBOX_GRANT,
-          initialNetworkPolicy,
-          afterBlock: () => client.setNetworkPolicy(
-            info.id,
-            { egress: ComputerEgressPolicy.None },
-            { autoResume: false }
-          ),
-          afterGuard: async (policy) => client.setNetworkPolicy(
-            info.id,
-            policy == null ? { egress: ComputerEgressPolicy.None } : egressFor(ctx, policy),
-            { autoResume: false }
-          ),
-          allowOwnerChange: false
-        });
-        const { expiresAtMs: deadline } = await manager.authorizeExternalAccess().finally(async () => {
-          try {
-            await manager.close();
-          } finally {
-            setup.transport.close();
-          }
-        });
-        if (deadline != null && deadline <= now())
-          throw new Error("Refresh workspace egress before opening the editor");
-        return open(deadline ?? void 0);
+        return open();
       },
       readSnapshot: async (ctx, rawState, request) => {
         const state = stateOf(rawState);
@@ -969,8 +688,7 @@ ${step.run}`,
             computerName: await computerNameFor(ctx.sandboxId),
             computerId: null,
             network,
-            ports,
-            networkPolicySaved: false
+            ports
           },
           region
         };
@@ -997,35 +715,21 @@ ${step.run}`,
             "artifact_unavailable",
             `computer base ${artifact.data.key} was prepared without its build steps; prepare it again`
           );
-        const networkingCtx = offerContextOf(ctx);
         const client = clientFor(ctx);
         const env = platformProcessEnvironment(ctx, {});
         const policy = withPlatformEgressHosts(ctx, state.network);
         const egress = computerEgressOf(policy);
-        const manageNetworking = state.networkPolicySaved || await needsWorkspaceNetworking(networkingCtx);
-        if (manageNetworking) config.networking?.validateWorkspaceId?.(ctx.sandboxId);
         const existing = await findComputer(client, state);
         if (existing?.state === ComputerState.Error)
           throw computerSandboxError(
             "computer_gone",
             `Computer ${existing.id} (${existing.name}) is in the Error state. Recover it through the Computers API before retrying; its disk is preserved.`
           );
-        const initialNetworkPolicy = manageNetworking && existing != null ? networkPolicyFor(await client.getNetworkPolicy(existing.id)) : networkPolicyFor(egress);
-        if (manageNetworking && existing?.state === ComputerState.Running)
-          await client.disableAutoResume(existing.id);
-        if (manageNetworking && config.networking != null)
-          await preservePolicy({ ctx: networkingCtx, policy: initialNetworkPolicy });
         let info;
         let booted;
         if (existing != null) {
           info = existing;
           booted = !isRunningState(existing.state);
-          if (manageNetworking && existing.state !== ComputerState.Running)
-            await client.setNetworkPolicy(
-              existing.id,
-              { egress: ComputerEgressPolicy.None },
-              { autoResume: false }
-            );
           if (existing.state === ComputerState.Paused) await client.action(existing.id, "resume");
           else if (booted) await client.action(existing.id, "start");
         } else {
@@ -1036,11 +740,11 @@ ${step.run}`,
             ...source,
             ...machine,
             env: {},
-            autoResume: !manageNetworking,
+            autoResume: true,
             idleTimeoutSeconds: idleTimeoutFor(ctx),
             // The sandbox owns deletion; VM-level ephemeral disks cannot be paused.
             ephemeral: false,
-            network: manageNetworking ? { egress: ComputerEgressPolicy.None } : egress,
+            network: egress,
             tags: [
               "final-agent-sandbox",
               `agent-sandbox:${ctx.sandboxId}`,
@@ -1050,7 +754,7 @@ ${step.run}`,
           };
           body.idlePolicy = ComputerIdlePolicy.Pause;
           if (region != null) body.regionSlug = region;
-          const idempotencyKey = `agent-sandbox-${(await sha256Hex(`${ctx.sandboxId}:${state.computerName}:${state.computerId ?? "first"}:${source.baseId ?? source.imageVersionId}:${manageNetworking}`)).slice(0, 32)}`;
+          const idempotencyKey = `agent-sandbox-${(await sha256Hex(`${ctx.sandboxId}:${state.computerName}:${state.computerId ?? "first"}:${source.baseId ?? source.imageVersionId}:false`)).slice(0, 32)}`;
           info = await client.createComputer(body, idempotencyKey);
         }
         const fresh = existing == null;
@@ -1058,81 +762,35 @@ ${step.run}`,
         let cleanup = null;
         try {
           info = await awaitComputerRunning(client, info.id, runningWaitMs);
-          if (!manageNetworking) {
-            if (!fresh) await client.setNetworkPolicy(info.id, egress);
-            await reportPlatformNetworkPolicy(ctx, policy);
-          }
+          if (!fresh) await client.setNetworkPolicy(info.id, egress);
+          await reportPlatformNetworkPolicy(ctx, policy);
           const setup = setupSession({ client, info, env });
           cleanup = async () => setup.transport.close();
           await writePlatformFiles(ctx, setup.sandbox);
-          const manager = workspaceNetworking({
-            ctx: networkingCtx,
-            enabled: manageNetworking,
-            sandbox: setup.sandbox,
-            client,
-            info,
-            onClose: () => setup.transport.close(),
-            initialNetworkPolicy
-          });
-          cleanup = async () => {
-            try {
-              await manager?.closeOnFailure();
-            } finally {
-              setup.transport.close();
-            }
-          };
-          await manager?.initialize();
-          const seedMarker = `${WORKSPACE_ROOT}/.final/workspace-prepared/${await sha256Hex(artifact.data.key)}`;
-          let seeding = null;
-          const seedWorkspace = () => seeding ??= (async () => {
-            if (await setup.sandbox.stat({ path: seedMarker }) != null) return;
-            await materializeSandboxSeeds({
-              sandbox: setup.sandbox,
-              root: WORKSPACE_ROOT,
-              files: await sandboxSeedFilesForAttach(ctx, artifact.data)
-            });
-            await setup.sandbox.writeTextFile({ path: seedMarker, content: "complete" });
-          })().catch((cause) => {
-            seeding = null;
-            throw cause;
-          });
-          let ready = true;
-          if (manager != null) {
-            try {
-              await ctx.executionPolicy?.beforeExecution({
-                operation: SandboxExecutionOperation.Run,
-                background: false
-              });
-              await manager.guard();
-            } catch {
-              log("workspace_networking.setup_deferred", {
-                provider: COMPUTER_PROVIDER,
-                computerId: info.id
+          if (fresh) {
+            const seedMarker = `${WORKSPACE_ROOT}/.final/workspace-prepared/${await sha256Hex(artifact.data.key)}`;
+            if (await setup.sandbox.stat({ path: seedMarker }) == null) {
+              await materializeSandboxSeeds({
+                sandbox: setup.sandbox,
+                root: WORKSPACE_ROOT,
+                files: await sandboxSeedFilesForAttach(ctx, artifact.data)
               });
-              ready = false;
+              await setup.sandbox.writeTextFile({ path: seedMarker, content: "complete" });
             }
           }
-          if (fresh && ready) await seedWorkspace();
           const handle = await buildHandle({
-            ctx: { ...networkingCtx, executionPolicy: ctx.executionPolicy },
+            ctx,
             client,
             info,
             env,
             ports: state.ports,
             passive: false,
-            networking: manager,
-            networkingManaged: manageNetworking,
-            closeSetup: () => setup.transport.close(),
-            beforeUse: fresh ? seedWorkspace : void 0
+            closeSetup: () => setup.transport.close()
           });
           return {
             handle,
             region: info.regionSlug ?? region,
-            state: {
-              ...state,
-              computerId: info.id,
-              networkPolicySaved: manageNetworking
-            },
+            state: { ...state, computerId: info.id },
             fresh,
             booted
           };
@@ -1143,7 +801,7 @@ ${step.run}`,
           } catch (cleanupError) {
             cause = new AggregateError(
               [error, cleanupError],
-              "Computer attach and egress cleanup failed"
+              "Computer attach and setup cleanup failed"
             );
           }
           if (fresh) {
@@ -1169,13 +827,12 @@ ${step.run}`,
             "computer is not running for passive access"
           );
         return buildHandle({
-          ctx: { ...offerContextOf(ctx), executionPolicy: ctx.executionPolicy },
+          ctx,
           client,
           info: await awaitComputerRunning(client, info.id, runningWaitMs),
           env: platformProcessEnvironment(ctx, {}),
           ports: state.ports,
-          passive: true,
-          networkingManaged: state.networkPolicySaved
+          passive: true
         });
       },
       // The computer pauses on its own idle policy; nothing to do.
@@ -1184,94 +841,67 @@ ${step.run}`,
         const state = stateOf(rawState);
         if (state.computerId == null) return state;
         const computerId = state.computerId;
-        const networkingCtx = offerContextOf(ctx);
-        await teardownComputer({
-          ctx: networkingCtx,
-          computerId,
-          policySaved: state.networkPolicySaved,
-          fence: true,
-          finish: async () => {
-            const failures = [];
-            try {
-              await closeComputerMcp(computerId);
-            } catch (cause) {
-              failures.push(cause);
-            }
+        const failures = [];
+        try {
+          await closeComputerMcp(computerId);
+        } catch (cause) {
+          failures.push(cause);
+        }
+        try {
+          const client = clientFor(ctx);
+          let current;
+          try {
+            current = await client.getComputer(computerId);
+          } catch (cause) {
+            failures.push(cause);
+          }
+          if (current !== void 0 && (current == null || hasNothingToPause(current.state))) {
+            log("computer_sandbox.park_at_rest", {
+              computerId,
+              state: current?.state ?? null
+            });
+          } else {
             try {
-              const client = clientFor(ctx);
-              let current;
-              try {
-                current = await client.getComputer(computerId);
-              } catch (cause) {
-                failures.push(cause);
-              }
-              if (current !== void 0 && (current == null || hasNothingToPause(current.state))) {
-                log("computer_sandbox.park_at_rest", {
-                  computerId,
-                  state: current?.state ?? null
-                });
-              } else {
-                try {
-                  await client.action(computerId, "pause");
-                } catch (error) {
-                  if (!pauseMayHaveSettled(error)) throw error;
-                  const settled = await client.getComputer(computerId);
-                  if (settled != null && settled.state !== ComputerState.Paused && !hasNothingToPause(settled.state))
-                    throw error;
-                  log("computer_sandbox.park_at_rest", {
-                    computerId,
-                    state: settled?.state ?? null
-                  });
-                }
-              }
-            } catch (cause) {
-              failures.push(cause);
+              await client.action(computerId, "pause");
+            } catch (error) {
+              if (!pauseMayHaveSettled(error)) throw error;
+              const settled = await client.getComputer(computerId);
+              if (settled != null && settled.state !== ComputerState.Paused && !hasNothingToPause(settled.state))
+                throw error;
+              log("computer_sandbox.park_at_rest", {
+                computerId,
+                state: settled?.state ?? null
+              });
             }
-            if (failures.length === 1) throw failures[0];
-            if (failures.length > 1) throw new AggregateError(failures, "Computer pause failed");
           }
-        });
-        return {
-          ...state,
-          networkPolicySaved: state.networkPolicySaved || savedPolicyWorkspaces.has(workspaceKey(networkingCtx))
-        };
+        } catch (cause) {
+          failures.push(cause);
+        }
+        if (failures.length === 1) throw failures[0];
+        if (failures.length > 1) throw new AggregateError(failures, "Computer pause failed");
+        return state;
       },
       delete: async (ctx, { state: rawState }) => {
         const state = stateOf(rawState);
         const client = clientFor(ctx);
         const computer = await findComputer(client, state);
-        if (computer == null) {
-          if (state.networkPolicySaved && config.networking != null)
-            await config.networking.suspend({
-              ctx: offerContextOf(ctx),
-              workspaceId: ctx.sandboxId
-            });
-          return;
+        if (computer == null) return;
+        const failures = [];
+        try {
+          await closeComputerMcp(computer.id);
+        } catch (cause) {
+          failures.push(cause);
         }
-        await teardownComputer({
-          ctx: offerContextOf(ctx),
-          computerId: computer.id,
-          policySaved: state.networkPolicySaved,
-          fence: false,
-          finish: async () => {
-            const failures = [];
-            try {
-              await closeComputerMcp(computer.id);
-            } catch (cause) {
-              failures.push(cause);
-            }
-            log("computer_sandbox.delete", { computerId: computer.id });
-            try {
-              await client.action(computer.id, "delete");
-            } catch (error) {
-              if (!await deletedAfterFenceError({ client, computerId: computer.id, cause: error }))
-                failures.push(error);
-            }
-            if (failures.length === 1) throw failures[0];
-            if (failures.length > 1)
-              throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
-          }
-        });
+        log("computer_sandbox.delete", { computerId: computer.id });
+        try {
+          await client.action(computer.id, "delete");
+        } catch (error) {
+          if (!await deletedAfterFenceError({ client, computerId: computer.id, cause: error }))
+            failures.push(error);
+        }
+        if (failures.length === 1) throw failures[0];
+        if (failures.length > 1)
+          throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
       }
     };
   };