@evolvingmachines/e2b 0.0.55 → 0.0.57

package/README.md

@@ -8,9 +8,9 @@
 
 # Evolving Machines — Evolve E2B Provider
 
-E2B sandbox provider for [Evolve SDK](https://www.npmjs.com/package/@evolvingmachines/sdk).
+E2B sandbox provider for [Evolve SDK](https://www.npmjs.com/package/@evolvingmachines/evolve).
 
-**Note:** This package is automatically installed as a dependency of `@evolvingmachines/sdk`. You don't need to install it separately.
+**Note:** This package is automatically installed as a dependency of `@evolvingmachines/evolve`. You don't need to install it separately.
 
 Check out the [official documentation](https://github.com/evolving-machines-lab/evolve/tree/main/docs) and [cookbooks](https://github.com/evolving-machines-lab/evolve/tree/main/cookbooks).
 

package/dist/index.cjs

@@ -1,2 +1,8 @@
-'use strict';var codeInterpreter=require('@e2b/code-interpreter');var p=new Set([".xlsx",".xls",".docx",".doc",".pptx",".ppt",".pdf",".zip",".tar",".gz",".7z",".rar",".png",".jpg",".jpeg",".gif",".webp",".ico",".bmp",".mp3",".wav",".ogg",".flac",".aac",".mp4",".avi",".mov",".mkv",".webm",".woff",".woff2",".ttf",".otf",".eot",".exe",".dll",".so",".dylib",".sqlite",".db",".pickle",".pkl",".parquet"]);function a(i){return i instanceof Date?i.toISOString():String(i)}function l(i){if(typeof i=="string"||i instanceof ArrayBuffer)return i;if(i instanceof Buffer)return new Uint8Array(i).buffer;if(i instanceof Uint8Array)return new Uint8Array(i).buffer;throw new Error(`Unsupported data type for file upload: ${typeof i}. Expected string, Buffer, ArrayBuffer, or Uint8Array.`)}function g(i){let t=i.substring(i.lastIndexOf(".")).toLowerCase();return p.has(t)}var m=class{constructor(t){this.sandbox=t;}async run(t,e){try{let n=await this.sandbox.commands.run(t,{timeoutMs:e?.timeoutMs,envs:e?.envs,cwd:e?.cwd,onStdout:e?.onStdout,onStderr:e?.onStderr});return {exitCode:n.exitCode,stdout:n.stdout,stderr:n.stderr}}catch(n){if(n&&typeof n=="object"&&"exitCode"in n){let r=n;return {exitCode:r.exitCode,stdout:r.stdout??"",stderr:r.stderr??""}}throw n}}async spawn(t,e){let n=await this.sandbox.commands.run(t,{background:true,stdin:e?.stdin??true,timeoutMs:e?.timeoutMs,envs:e?.envs,cwd:e?.cwd,onStdout:e?.onStdout,onStderr:e?.onStderr});return {processId:String(n.pid),wait:async()=>{try{let r=await n.wait();return {exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch(r){if(r&&typeof r=="object"&&"exitCode"in r){let s=r;return {exitCode:s.exitCode,stdout:s.stdout??"",stderr:s.stderr??""}}throw r}},kill:()=>this.sandbox.commands.kill(n.pid)}}async list(){return (await this.sandbox.commands.list()).map(e=>({...e,processId:String(e.pid)}))}async connect(t,e){let n=await this.sandbox.commands.connect(Number(t),{onStdout:e?.onStdout,onStderr:e?.onStderr,timeoutMs:e?.timeoutMs});return {processId:String(n.pid),wait:async()=>{try{let r=await n.wait();return {exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch(r){if(r&&typeof r=="object"&&"exitCode"in r){let s=r;return {exitCode:s.exitCode,stdout:s.stdout??"",stderr:s.stderr??""}}throw r}},kill:()=>this.sandbox.commands.kill(n.pid)}}async sendStdin(t,e){await this.sandbox.commands.sendStdin(Number(t),e);}async kill(t){return this.sandbox.commands.kill(Number(t))}},c=class{constructor(t){this.sandbox=t;}async read(t){return g(t)?this.sandbox.files.read(t,{format:"bytes",requestTimeoutMs:3e5}):this.sandbox.files.read(t,{format:"text",requestTimeoutMs:3e5})}async write(t,e){await this.sandbox.files.write(t,l(e),{requestTimeoutMs:3e5});}async writeBatch(t){let e=t.map(n=>({path:n.path,data:l(n.data)}));await this.sandbox.files.write(e,{requestTimeoutMs:3e5});}async makeDir(t){await this.sandbox.files.makeDir(t);}async uploadUrl(t,e){return this.sandbox.uploadUrl(t,e?{useSignatureExpiration:e}:void 0)}async downloadUrl(t,e){return this.sandbox.downloadUrl(t,e?{useSignatureExpiration:e}:void 0)}async exists(t){return this.sandbox.files.exists(t)}async list(t){return (await this.sandbox.files.list(t)).map(n=>({name:n.name,path:n.path,type:n.type==="dir"?"dir":"file"}))}async remove(t){await this.sandbox.files.remove(t);}async rename(t,e){await this.sandbox.files.rename(t,e);}async readStream(t){return this.sandbox.files.read(t,{format:"stream"})}async writeStream(t,e){await this.sandbox.files.write(t,e);}async watchDir(t,e,n){let r=await this.sandbox.files.watchDir(t,e,{recursive:n?.recursive,timeoutMs:n?.timeoutMs,onExit:n?.onExit});return {stop:()=>r.stop()}}},o=class{constructor(t,e,n){this.sandbox=t;this.apiKey=e;this.apiUrl=n;this.commands=new m(t),this.files=new c(t);}commands;files;get sandboxId(){return this.sandbox.sandboxId}getHost(t){return Promise.resolve(this.sandbox.getHost(t))}async isRunning(){return this.sandbox.isRunning()}async getInfo(){let t=await this.sandbox.getInfo();return {sandboxId:t.sandboxId,image:t.templateId,name:t.name,metadata:t.metadata??{},startedAt:a(t.startedAt),endAt:t.endAt?a(t.endAt):void 0}}async kill(){try{await this.sandbox.kill();}catch{await new Promise(t=>setTimeout(t,500)),await this.sandbox.kill();}}async pause(){await this.sandbox.betaPause({apiKey:this.apiKey,apiUrl:this.apiUrl});}},u=class{providerType="e2b";apiKey;apiUrl;defaultTimeoutMs;templateId;constructor(t){this.apiKey=t.apiKey,this.apiUrl=t.apiUrl,this.defaultTimeoutMs=t.defaultTimeoutMs??36e5,this.templateId=t.templateId;}async create(t){let e=t.timeoutMs??this.defaultTimeoutMs,n=t.image??this.templateId??"evolve-all",r=await codeInterpreter.Sandbox.create(n,{apiKey:this.apiKey,apiUrl:this.apiUrl,envs:t.envs,metadata:t.metadata,timeoutMs:e});return t.workingDirectory&&await r.files.makeDir(t.workingDirectory),new o(r,this.apiKey,this.apiUrl)}async connect(t,e){let n=await codeInterpreter.Sandbox.connect(t,{apiKey:this.apiKey,apiUrl:this.apiUrl,timeoutMs:e??this.defaultTimeoutMs});return new o(n,this.apiKey,this.apiUrl)}async list(t){return (await codeInterpreter.Sandbox.list({apiKey:this.apiKey,apiUrl:this.apiUrl,query:{state:t?.state,metadata:t?.metadata},limit:t?.limit??100}).nextItems()).map(r=>({sandboxId:r.sandboxId,image:r.templateId,name:r.name,metadata:r.metadata??{},startedAt:a(r.startedAt),endAt:r.endAt?a(r.endAt):void 0}))}};function b(i={}){let t=i.apiKey??process.env.E2B_API_KEY;if(!t)throw new Error("E2B API key required. Set E2B_API_KEY environment variable or pass apiKey in config. Get your key at https://e2b.dev/sign-in");return new u({...i,apiKey:t})}
-exports.E2BProvider=u;exports.createE2BProvider=b;
+'use strict';var codeInterpreter=require('@e2b/code-interpreter');function b(s){if(!s||typeof s!="object")return  false;if(s.name==="TimeoutError")return  true;let e=s.message;return typeof e=="string"&&/timed?\s*out/i.test(e)}var k=100,I=100;function u(s){return s instanceof Date?s.toISOString():String(s)}function U(s){if(typeof s=="string"||s instanceof ArrayBuffer)return s;if(s instanceof Buffer)return new Uint8Array(s).buffer;if(s instanceof Uint8Array)return new Uint8Array(s).buffer;throw new Error(`Unsupported data type for file upload: ${typeof s}. Expected string, Buffer, ArrayBuffer, or Uint8Array.`)}var l=class extends Error{constructor(e){super(e),this.name="E2BResourcesError";}},B="2.25.0",g=class extends Error{constructor(e){super(e),this.name="E2BNetworkUpdateUnsupportedError";}};function x(s){if(s?.outbound==="open"&&s.allowedDestinations?.length)throw new Error("network.allowedDestinations is only valid when outbound is blocked");let e=s?.allowedDestinations??[],t=s?.outbound==="blocked"&&e.length>0;return {allowInternetAccess:s?.outbound!=="blocked"||t,network:t?{denyOut:["0.0.0.0/0"],allowOut:e}:void 0}}var h=class extends Error{constructor(){super("E2B takes no create-time boot command: the sandbox boots its template's own init, and a start command is a template-BUILD field (Template startCmd) this provider never sets. The boot is already inert \u2014 run the process by exec after create, or bake it into the template the `image` names."),this.name="E2BBootCommandError";}},y=class extends Error{constructor(){super("E2B has no idle timeout: its sandbox timeout is an ABSOLUTE lifetime that in-sandbox activity never extends. Use `timeoutMs` for the lifetime, and call setTimeout() to extend a sandbox you know is still working."),this.name="E2BIdleTimeoutError";}},w=class{constructor(e,t){this.sandbox=e;this.defaultUser=t;}async run(e,t){try{let r=await this.sandbox.commands.run(e,{timeoutMs:t?.timeoutMs,envs:t?.envs,cwd:t?.cwd,user:this.defaultUser,onStdout:t?.onStdout,onStderr:t?.onStderr});return {exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch(r){if(r&&typeof r=="object"&&"exitCode"in r){let n=r;return {exitCode:n.exitCode,stdout:n.stdout??"",stderr:n.stderr??""}}if(b(r))return {exitCode:124,stdout:"",stderr:r instanceof Error?r.message:"command timed out"};throw r}}async spawn(e,t){let r=await this.sandbox.commands.run(e,{background:true,stdin:t?.stdin??true,timeoutMs:t?.timeoutMs,envs:t?.envs,cwd:t?.cwd,user:this.defaultUser,onStdout:t?.onStdout,onStderr:t?.onStderr});return {processId:String(r.pid),wait:async()=>{try{let n=await r.wait();return {exitCode:n.exitCode,stdout:n.stdout,stderr:n.stderr}}catch(n){if(n&&typeof n=="object"&&"exitCode"in n){let i=n;return {exitCode:i.exitCode,stdout:i.stdout??"",stderr:i.stderr??""}}if(b(n))return {exitCode:124,stdout:"",stderr:n instanceof Error?n.message:"command timed out"};throw n}},kill:()=>this.sandbox.commands.kill(r.pid)}}async list(){return (await this.sandbox.commands.list()).map(t=>({...t,processId:String(t.pid)}))}async connect(e,t){let r=await this.sandbox.commands.connect(Number(e),{onStdout:t?.onStdout,onStderr:t?.onStderr,timeoutMs:t?.timeoutMs});return {processId:String(r.pid),wait:async()=>{try{let n=await r.wait();return {exitCode:n.exitCode,stdout:n.stdout,stderr:n.stderr}}catch(n){if(n&&typeof n=="object"&&"exitCode"in n){let i=n;return {exitCode:i.exitCode,stdout:i.stdout??"",stderr:i.stderr??""}}if(b(n))return {exitCode:124,stdout:"",stderr:n instanceof Error?n.message:"command timed out"};throw n}},kill:()=>this.sandbox.commands.kill(r.pid)}}async sendStdin(e,t){await this.sandbox.commands.sendStdin(Number(e),t);}async kill(e){return this.sandbox.commands.kill(Number(e))}},S=class{constructor(e,t){this.sandbox=e;this.defaultUser=t;}async read(e){let t=await this.sandbox.files.read(e,{format:"bytes",requestTimeoutMs:3e5,user:this.defaultUser});if(!t.includes(0))try{return new TextDecoder("utf-8",{fatal:!0,ignoreBOM:!0}).decode(t)}catch{}return t}async write(e,t){await this.sandbox.files.write(e,U(t),{requestTimeoutMs:3e5,user:this.defaultUser});}async writeBatch(e){let t=e.map(r=>({path:r.path,data:U(r.data)}));await this.sandbox.files.write(t,{requestTimeoutMs:3e5,user:this.defaultUser});}async makeDir(e){await this.sandbox.files.makeDir(e,{user:this.defaultUser});}async uploadUrl(e,t){return this.sandbox.uploadUrl(e,{user:this.defaultUser,...t?{useSignatureExpiration:t}:{}})}async downloadUrl(e,t){return this.sandbox.downloadUrl(e,{user:this.defaultUser,...t?{useSignatureExpiration:t}:{}})}async exists(e){return this.sandbox.files.exists(e,{user:this.defaultUser})}async list(e){return (await this.sandbox.files.list(e,{user:this.defaultUser})).map(r=>({name:r.name,path:r.path,type:r.type==="dir"?"dir":"file"}))}async remove(e){await this.sandbox.files.remove(e,{user:this.defaultUser});}async rename(e,t){await this.sandbox.files.rename(e,t,{user:this.defaultUser});}async readStream(e){return this.sandbox.files.read(e,{format:"stream",user:this.defaultUser})}async writeStream(e,t){await this.sandbox.files.write(e,t,{user:this.defaultUser});}async writeFromPath(e,t){let{createReadStream:r,statSync:n}=await import('fs'),{Readable:i}=await import('stream'),{randomBytes:d}=await import('crypto'),a=n(t).size,p=`----evolve${d(16).toString("hex")}`,v=Buffer.from(`--${p}\r
+Content-Disposition: form-data; name="file"; filename="blob"\r
+Content-Type: application/octet-stream\r
+\r
+`),A=Buffer.from(`\r
+--${p}--\r
+`);async function*C(){yield v;for await(let o of r(t))yield o;yield A;}try{let o=await this.uploadUrl(e),m=await fetch(o,{method:"POST",body:i.toWeb(i.from(C())),headers:{"Content-Type":`multipart/form-data; boundary=${p}`,"Content-Length":String(v.length+a+A.length)},duplex:"half"});if(!m.ok)throw new Error(`streamed upload to ${e} failed (HTTP ${m.status})`)}catch(o){console.warn(`[e2b] streamed upload of ${t} failed, falling back to a buffered write:`,o instanceof Error?o.message:o);let m=i.toWeb(r(t));await this.writeStream(e,m);}}async watchDir(e,t,r){let n=await this.sandbox.files.watchDir(e,t,{recursive:r?.recursive,timeoutMs:r?.timeoutMs,user:this.defaultUser,onExit:r?.onExit});return {stop:()=>n.stop()}}},c=class{constructor(e,t,r,n){this.sandbox=e;this.apiKey=t;this.apiUrl=r;this.commands=new w(e,n),this.files=new S(e,n);}commands;files;get sandboxId(){return this.sandbox.sandboxId}getHost(e){return Promise.resolve(this.sandbox.getHost(e))}async isRunning(){return this.sandbox.isRunning()}async getInfo(){let e=await this.sandbox.getInfo();return {sandboxId:e.sandboxId,image:e.templateId,name:e.name,metadata:e.metadata??{},startedAt:u(e.startedAt),endAt:e.endAt?u(e.endAt):void 0}}async updateNetwork(e){let t=x(e),r=this.sandbox;if(typeof r.updateNetwork!="function")throw new g(`The installed e2b client cannot change a running sandbox's network policy: Sandbox.updateNetwork requires e2b >= ${B}. Upgrade the e2b dependency (it is pulled in by @e2b/code-interpreter), or create the sandbox with the policy it needs for its whole lifetime.`);await r.updateNetwork({allowInternetAccess:t.allowInternetAccess,...t.network??{}});}async kill(){try{await this.sandbox.kill();}catch{await new Promise(e=>setTimeout(e,500)),await this.sandbox.kill();}}async pause(){await this.sandbox.betaPause({apiKey:this.apiKey,apiUrl:this.apiUrl});}},P=class{providerType="e2b";name="E2B";apiKey;apiUrl;defaultTimeoutMs;templateId;sandboxUsers=new Map;constructor(e){this.apiKey=e.apiKey,this.apiUrl=e.apiUrl,this.defaultTimeoutMs=e.defaultTimeoutMs??36e5,this.templateId=e.templateId;}async create(e){if(e.bootCommand!==void 0)throw new h;if(e.idleTimeoutMs!==void 0)throw new y;if(e.resources?.gpu!==void 0||e.resources?.gpuTypes!==void 0)throw new l("E2B offers no GPU allocation at any tier \u2014 a `resources.gpu` request cannot be enforced. Run GPU workloads on a provider that reserves GPUs (modal).");if(e.resources&&(e.resources.cpu!==void 0||e.resources.memory!==void 0||e.resources.disk!==void 0))throw new l("E2B cannot size a sandbox at create time: sizing is fixed by the template (Template.build cpuCount/memoryMB; disk is plan-fixed). Build a template with the desired resources and pass it as `image` instead of `resources`.");let t=e.timeoutMs??this.defaultTimeoutMs,r=e.image??this.templateId??"evolve-all";for(let d of e.phaseNetworkPolicies??[])x(d);let n=x(e.network),i=await codeInterpreter.Sandbox.create(r,{apiKey:this.apiKey,apiUrl:this.apiUrl,envs:e.envs,metadata:e.metadata,timeoutMs:t,...n});return e.workingDirectory&&await i.files.makeDir(e.workingDirectory,{user:e.user}),e.user&&this.sandboxUsers.set(i.sandboxId,e.user),new c(i,this.apiKey,this.apiUrl,e.user)}async connect(e,t){let r=await codeInterpreter.Sandbox.connect(e,{apiKey:this.apiKey,apiUrl:this.apiUrl,timeoutMs:t??this.defaultTimeoutMs});return new c(r,this.apiKey,this.apiUrl,this.sandboxUsers.get(e))}async list(e){let t=await this.paginate(e);if(t.error&&!t.stoppedAtLimit)throw new Error(t.error);return t.sandboxes}async listAll(e){let{stoppedAtLimit:t,...r}=await this.paginate(e);return r}async paginate(e){let t=e?.limit;return E(codeInterpreter.Sandbox.list({apiKey:this.apiKey,apiUrl:this.apiUrl,query:{state:e?.state,metadata:e?.metadata},limit:t===void 0?k:Math.min(t,k)}),t)}};async function E(s,e){let t=[],r=0,n=new Set;for(;s.hasNext;){if(r>=I)return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:false,error:`sandbox list exceeded ${I} pages`};let i=s.nextToken;if(i!==void 0){if(n.has(i))return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:false,error:"pagination token repeated"};n.add(i);}let d;try{d=await s.nextItems();}catch(a){return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:false,error:`sandbox list failed: ${a instanceof Error?a.message:String(a)}`}}r+=1;for(let a of d){if(e!==void 0&&t.length>=e)return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:true,error:`stopped at the requested limit of ${e} with more sandboxes available`};t.push({sandboxId:a.sandboxId,image:a.templateId,name:a.name,metadata:a.metadata??{},startedAt:u(a.startedAt),endAt:a.endAt?u(a.endAt):void 0});}if(e!==void 0&&t.length>=e&&s.hasNext)return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:true,error:`stopped at the requested limit of ${e} with more sandboxes available`};if(e!==void 0&&t.length>=e)break}return {sandboxes:t,complete:true,pagesFetched:r,stoppedAtLimit:false}}var T=E;function M(s={}){let e=s.apiKey??process.env.E2B_API_KEY;if(!e)throw new Error("E2B API key required. Set E2B_API_KEY environment variable or pass apiKey in config. Get your key at https://e2b.dev/sign-in");return new P({...s,apiKey:e})}
+exports.E2BBootCommandError=h;exports.E2BCommands=w;exports.E2BFiles=S;exports.E2BIdleTimeoutError=y;exports.E2BNetworkUpdateUnsupportedError=g;exports.E2BProvider=P;exports.E2BResourcesError=l;exports.E2B_MAX_LIST_PAGES=I;exports.E2B_MAX_PAGE_SIZE=k;exports.E2B_MIN_UPDATE_NETWORK_VERSION=B;exports._testCollectSandboxPages=T;exports.createE2BProvider=M;

package/dist/index.d.cts

@@ -1,3 +1,5 @@
+import { Sandbox } from '@e2b/code-interpreter';
+
 /**
  * E2B Sandbox Provider - Clean Architecture
  *
@@ -11,6 +13,72 @@
  * - Configuration externalized (no hardcoded mappings)
  * - Clear naming (run = blocking, spawn = background)
  */
+
+/**
+ * Largest page E2B will serve. Not a taste choice — a larger `limit` is refused
+ * outright: `400 validation error: parameter "limit" in query has an error:
+ * number must be at most 100`.
+ */
+declare const E2B_MAX_PAGE_SIZE = 100;
+/**
+ * Page ceiling for one enumeration — 10,000 sandboxes at the maximum page size.
+ * A walk that reaches it stops and reports itself INCOMPLETE, because the one
+ * thing a fleet enumeration may never do is return a short list that reads like
+ * a whole one.
+ */
+declare const E2B_MAX_LIST_PAGES = 100;
+/**
+ * Typed error for create-time sizing requests E2B cannot enforce.
+ * E2B sandboxes inherit cpu/memory from their TEMPLATE (Template.build
+ * cpuCount/memoryMB; disk is plan-fixed) — Sandbox.create has no sizing
+ * parameters, so a `resources` request would be silently ignored. Per the
+ * provider law (reject what you cannot enforce) it is refused loudly here.
+ */
+declare class E2BResourcesError extends Error {
+    constructor(message: string);
+}
+/**
+ * Minimum `e2b` client that can switch a running sandbox's egress.
+ *
+ * 2.25.0, per e2b's own release notes: "Add `Sandbox.updateNetwork` /
+ * `update_network` to replace a running sandbox's egress configuration"
+ * (e2b@2.25.0). Confirmed against the published type declarations — absent in
+ * 2.24.0, present in 2.25.0.
+ *
+ * IT SAID 2.26.0 UNTIL THE RELEASE NOTES WERE READ. That number came from a
+ * binary search over published tarballs that happened to sample only even
+ * minors, so 2.25.0 was never tested and the first "present" result looked
+ * like the boundary. The search was sound and the conclusion was still wrong
+ * by one release — which is the argument for reading the vendor's own record
+ * rather than inferring version history from artifacts.
+ */
+declare const E2B_MIN_UPDATE_NETWORK_VERSION = "2.25.0";
+/**
+ * Typed error for a runtime egress switch the INSTALLED client cannot make.
+ *
+ * E2B the service supports it; an older `e2b` package simply has no method to
+ * call. That distinction matters to whoever reads this: the fix is a
+ * dependency bump, not a plan change or a different provider. Refused loudly
+ * rather than skipped, because a policy switch that quietly does nothing
+ * leaves the sandbox running under the previous policy — which, when the
+ * switch was meant to TIGHTEN egress, is the failure nobody notices.
+ */
+declare class E2BNetworkUpdateUnsupportedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Typed error for an idle timeout E2B cannot enforce. E2B has exactly one
+ * clock and it is absolute: the sandbox is killed when its timeout expires,
+ * and only explicit client calls (create, connect, setTimeout) move that
+ * deadline — never what the sandbox is or is not doing. An `idleTimeoutMs`
+ * would therefore be silently ignored, so it is refused instead.
+ */
+declare class E2BBootCommandError extends Error {
+    constructor();
+}
+declare class E2BIdleTimeoutError extends Error {
+    constructor();
+}
 /** Result of a completed sandbox command */
 interface SandboxCommandResult {
     exitCode: number;
@@ -85,11 +153,71 @@ interface SandboxConnectOptions {
 }
 /** Options for creating a sandbox */
 interface SandboxCreateOptions {
-    image: string;
+    /**
+     * E2B template ID. OPTIONAL: create() falls back to the provider's
+     * configured `templateId`, then to "evolve-all" — declaring it required
+     * contradicted that implementation and only went unnoticed because TS
+     * method parameters are bivariant, so the SDK could already call
+     * create({}) through the shared contract.
+     */
+    image?: string;
     envs?: Record<string, string>;
     metadata?: Record<string, string>;
     timeoutMs?: number;
+    /**
+     * REJECTED with E2BIdleTimeoutError. E2B's timeout is an ABSOLUTE lifetime
+     * that in-sandbox activity never extends, so there is no inactivity clock to
+     * map this onto and honouring it would be a lie.
+     */
+    idleTimeoutMs?: number;
+    /**
+     * REJECTED with E2BBootCommandError. The sandbox boots the template's own
+     * init — a start command is a template-BUILD field (startCmd) this provider
+     * never sets, so a create-time argv cannot be honored. The boot is already
+     * inert; exec the process after create instead.
+     */
+    bootCommand?: string[];
     workingDirectory?: string;
+    /**
+     * Per-sandbox compute sizing (cpu cores, memory GiB, disk GiB). E2B sizes
+     * sandboxes at TEMPLATE BUILD time only (Template.build cpuCount/memoryMB;
+     * disk is plan-fixed) — create-time sizing cannot be enforced, so any value
+     * here is REJECTED with E2BResourcesError rather than silently ignored.
+     * Bake sizing into the template the `image` names instead. `gpu`/`gpuTypes`
+     * are rejected the same way: e2b offers no GPU allocation at any tier.
+     */
+    resources?: {
+        cpu?: number;
+        memory?: number;
+        disk?: number;
+        gpu?: number;
+        gpuTypes?: string[];
+    };
+    network?: {
+        outbound: "open" | "blocked";
+        allowedDestinations?: string[];
+    };
+    /**
+     * Every policy `updateNetwork()` may later be asked for on this box.
+     *
+     * ACCEPTED AND IGNORED HERE, deliberately. It exists because on modal the
+     * create call decides whether switching is possible at all, and a box built
+     * the blunt way can never be widened. E2B has no such constraint — it
+     * switches freely at any time — so this changes nothing about the sandbox
+     * it creates.
+     *
+     * Declared anyway so the option means the SAME thing in every provider
+     * package: a caller reading these types must not conclude that E2B
+     * cannot do phase switching because the option is missing here.
+     */
+    phaseNetworkPolicies?: Array<{
+        outbound: "open" | "blocked";
+        allowedDestinations?: string[];
+    }>;
+    /** Run all commands and file operations as this user (passed on every E2B operation that supports it). */
+    user?: string;
+    /** Home directory used by the SDK for agent config paths; not consumed by the provider. */
+    homeDir?: string;
 }
 /** Options for listing sandboxes */
 interface SandboxListOptions {
@@ -97,6 +225,20 @@ interface SandboxListOptions {
     metadata?: Record<string, string>;
     limit?: number;
 }
+/**
+ * A COMPLETE (or admittedly incomplete) enumeration of the project's fleet.
+ *
+ * `complete` is the load-bearing field. Callers that need a whole fleet —
+ * orphan sweeps, lifecycle reconciliation — read a sandbox's ABSENCE from the
+ * list as evidence it is gone, so a truncated page and a small fleet must never
+ * be the same answer. `complete: false` means leave every row alone.
+ */
+interface SandboxListPage {
+    sandboxes: SandboxInfo[];
+    complete: boolean;
+    pagesFetched: number;
+    error?: string;
+}
 /** Command execution capabilities */
 interface SandboxCommands {
     /** Run command and wait for completion */
@@ -127,6 +269,8 @@ interface SandboxFiles {
     readStream(path: string): Promise<ReadableStream<Uint8Array>>;
     /** Write from stream */
     writeStream(path: string, stream: ReadableStream<Uint8Array>): Promise<void>;
+    /** Upload a local file by path, streamed off disk (never buffered whole) */
+    writeFromPath(sandboxPath: string, localPath: string): Promise<void>;
     /** Get pre-signed upload URL for large files (expiration in seconds) */
     uploadUrl(path: string, expiresInSeconds?: number): Promise<string>;
     /** Get pre-signed download URL for large files (expiration in seconds) */
@@ -159,17 +303,23 @@ interface SandboxInstance {
     kill(): Promise<void>;
     /** Pause sandbox (preserves state) */
     pause(): Promise<void>;
+    /** Replace the outbound network policy of the running sandbox. */
+    updateNetwork(network: SandboxCreateOptions["network"]): Promise<void>;
 }
 /** Sandbox lifecycle management */
 interface SandboxProvider {
     /** Provider type identifier */
     readonly providerType: string;
+    /** Human-readable provider name for logging */
+    readonly name?: string;
     /** Create new sandbox */
     create(options: SandboxCreateOptions): Promise<SandboxInstance>;
     /** Connect to existing sandbox */
     connect(sandboxId: string, timeoutMs?: number): Promise<SandboxInstance>;
-    /** List sandboxes (first page only, up to limit) */
+    /** List sandboxes, paginating to exhaustion. `limit` bounds items returned. */
     list(options?: SandboxListOptions): Promise<SandboxInfo[]>;
+    /** The same enumeration for fleet bookkeeping: never throws, reports completeness. */
+    listAll(options?: SandboxListOptions): Promise<SandboxListPage>;
 }
 interface E2BConfig {
     /** E2B API key. Default: reads from E2B_API_KEY env var */
@@ -187,17 +337,169 @@ interface ResolvedE2BConfig {
     defaultTimeoutMs?: number;
     templateId?: string;
 }
+declare class E2BCommands implements SandboxCommands {
+    private sandbox;
+    private defaultUser?;
+    constructor(sandbox: Sandbox, defaultUser?: string | undefined);
+    run(command: string, options?: SandboxRunOptions): Promise<SandboxCommandResult>;
+    spawn(command: string, options?: SandboxSpawnOptions): Promise<SandboxCommandHandle>;
+    list(): Promise<ProcessInfo[]>;
+    connect(processId: string, options?: SandboxConnectOptions): Promise<SandboxCommandHandle>;
+    sendStdin(processId: string, data: string): Promise<void>;
+    kill(processId: string): Promise<boolean>;
+}
+declare class E2BFiles implements SandboxFiles {
+    private sandbox;
+    private defaultUser?;
+    constructor(sandbox: Sandbox, defaultUser?: string | undefined);
+    read(path: string): Promise<string | Uint8Array>;
+    write(path: string, content: string | Buffer | ArrayBuffer | Uint8Array): Promise<void>;
+    writeBatch(files: Array<{
+        path: string;
+        data: string | Buffer | ArrayBuffer | Uint8Array;
+    }>): Promise<void>;
+    makeDir(path: string): Promise<void>;
+    uploadUrl(path: string, expiresInSeconds?: number): Promise<string>;
+    downloadUrl(path: string, expiresInSeconds?: number): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    list(path: string): Promise<FileInfo[]>;
+    remove(path: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    readStream(path: string): Promise<ReadableStream<Uint8Array>>;
+    writeStream(path: string, stream: ReadableStream<Uint8Array>): Promise<void>;
+    /**
+     * Upload a local file by PATH, streamed off disk with real backpressure.
+     *
+     * Why this does NOT go through files.write(): that method calls
+     * `new Response(data).blob()` on whatever it is given, which MATERIALIZES the
+     * body — measured at +463 MB RSS for a 200 MB source, whether the input is a
+     * stream, a Buffer, or even a file-backed Blob. So handing it a stream looks
+     * like streaming and is not, which is precisely the trap this method exists to
+     * avoid: a caller uploading a large artifact once per concurrent task would
+     * still pay the full size every time.
+     *
+     * Instead the multipart body is assembled as a ReadableStream and POSTed to
+     * the signed upload URL with `duplex: "half"` — the same shape E2B's own
+     * template-context upload uses. Verified to hold backpressure: against a
+     * deliberately slow sink the producer had read 7 MB of a 200 MB file after
+     * four seconds, rather than racing to the end.
+     *
+     * The wire format mirrors files.write()'s single-file case exactly: the
+     * destination is the `path` query parameter of the signed URL, and the body is
+     * one `file` part. If E2B ever changes that, the POST fails and we fall back to
+     * the SDK's own (buffering) path — a correct upload beats a cheap one.
+     */
+    writeFromPath(sandboxPath: string, localPath: string): Promise<void>;
+    watchDir(path: string, onEvent: (event: FilesystemEvent) => void | Promise<void>, options?: WatchOptions): Promise<WatchHandle>;
+}
+declare class E2BSandboxImpl implements SandboxInstance {
+    private sandbox;
+    private apiKey;
+    private apiUrl?;
+    readonly commands: SandboxCommands;
+    readonly files: SandboxFiles;
+    constructor(sandbox: Sandbox, apiKey: string, apiUrl?: string | undefined, defaultUser?: string);
+    get sandboxId(): string;
+    getHost(port: number): Promise<string>;
+    isRunning(): Promise<boolean>;
+    getInfo(): Promise<SandboxInfo>;
+    /**
+     * Replace the running sandbox's outbound policy — E2B's
+     * `Sandbox.updateNetwork`: "Update the network configuration of the sandbox.
+     * Replaces the current egress configuration atomically — fields that are
+     * omitted are cleared on the server." (from the published e2b 2.25.0+ type
+     * declarations for Sandbox.updateNetwork).
+     *
+     * That "omitted fields are cleared" rule is why the whole policy is sent
+     * every time and never a delta: mapNetworkPolicy always states
+     * allowInternetAccess, and states `network` only when an allowlist is in
+     * force — so switching from an allowlist to a sealed box clears the
+     * allowlist by the server's own rule rather than by a second call that could
+     * fail in between and leave the box half-switched.
+     *
+     * VERSION GATE. `updateNetwork` landed in e2b 2.25.0; the client resolved in
+     * this workspace today is older and has no such method. Feature-detected
+     * rather than assumed, and refused loudly when absent — a `catch` around a
+     * missing method, or an early return, would leave the sandbox on its
+     * previous policy while the caller believes the switch happened.
+     */
+    updateNetwork(network: SandboxCreateOptions["network"]): Promise<void>;
+    kill(): Promise<void>;
+    pause(): Promise<void>;
+}
 declare class E2BProvider implements SandboxProvider {
     readonly providerType: "e2b";
+    readonly name = "E2B";
     private readonly apiKey;
     private readonly apiUrl?;
     private readonly defaultTimeoutMs;
     private readonly templateId?;
+    /**
+     * Sandbox user configured at create time, reapplied on connect() (e.g., resume).
+     * In-memory only: a connect() from a fresh process runs as the template default
+     * user — callers reconnecting across processes must recreate the provider config
+     * with the same user, or operations on user-owned files fail loudly.
+     */
+    private readonly sandboxUsers;
     constructor(config: ResolvedE2BConfig);
     create(options: SandboxCreateOptions): Promise<SandboxInstance>;
     connect(sandboxId: string, timeoutMs?: number): Promise<SandboxInstance>;
+    /**
+     * List sandboxes, walking every page.
+     *
+     * This used to call `nextItems()` exactly once and return whatever the first
+     * page held — an account with more than E2B_MAX_PAGE_SIZE sandboxes was
+     * silently truncated, and nothing in the return value said so. That is a
+     * correctness bug rather than a performance one for any caller that reads
+     * absence from the list as "this sandbox is gone".
+     *
+     * `limit` still means what a caller expects: stop after this many ITEMS, so
+     * an explicit limit remains a cost bound. The per-request page size is capped
+     * separately at E2B_MAX_PAGE_SIZE because E2B rejects anything larger
+     * outright (`400 validation error: parameter "limit" ... must be at most
+     * 100`), so a caller asking for 500 gets five requests, not one refusal.
+     */
     list(options?: SandboxListOptions): Promise<SandboxInfo[]>;
+    /**
+     * The fleet-bookkeeping enumeration: same walk, never throws.
+     *
+     * The distinction from `list()` is what a failure MEANS to the caller. An
+     * orphan sweep treats a missing sandbox as a terminated one, so it must be
+     * able to tell "the project has no sandboxes" from "the enumeration stopped
+     * early" — and an exception it catches and turns into an empty array erases
+     * exactly that difference.
+     */
+    listAll(options?: SandboxListOptions): Promise<SandboxListPage>;
+    private paginate;
+}
+/** The paginator surface this walk needs — E2B's SandboxPaginator satisfies it. */
+interface E2BSandboxPaginator {
+    readonly hasNext: boolean;
+    readonly nextToken?: string;
+    nextItems(): Promise<Array<{
+        sandboxId: string;
+        templateId: string;
+        name?: string;
+        metadata?: Record<string, string>;
+        startedAt: unknown;
+        endAt?: unknown;
+    }>>;
 }
+/**
+ * Drain a paginator into one answer, with an honest completeness verdict.
+ *
+ * Separate from the provider because everything worth getting wrong lives here
+ * and none of it needs a network: the two ways a walk can fail to terminate,
+ * the difference between "the caller asked for ten" and "the provider ran out",
+ * and the rule that a failure mid-walk yields the sandboxes seen so far marked
+ * INCOMPLETE rather than either an exception or a short complete list.
+ *
+ * Exported for its test (`_testCollectSandboxPages`).
+ */
+declare function collectSandboxPages(paginator: E2BSandboxPaginator, wanted?: number): Promise<SandboxListPage & {
+    stoppedAtLimit: boolean;
+}>;
+declare const _testCollectSandboxPages: typeof collectSandboxPages;
 /**
  * Create E2B sandbox provider.
  *
@@ -205,5 +507,13 @@ declare class E2BProvider implements SandboxProvider {
  * @throws Error if apiKey cannot be resolved
  */
 declare function createE2BProvider(config?: E2BConfig): SandboxProvider;
+/**
+ * TYPE-ONLY handle on the concrete sandbox class, for the contract-conformance
+ * seam. create() is declared to return the local SandboxInstance INTERFACE, so
+ * a seam reading create()'s return type checks the interface and never the
+ * class — which let a narrowed method on the class pass unnoticed. Exporting
+ * the type (never the constructor) gives the seam the real methods to pin.
+ */
+type _testE2BSandboxImpl = E2BSandboxImpl;
 
-export { type E2BConfig, E2BProvider, type FileInfo, type FilesystemEvent, type ProcessInfo, type SandboxCommandHandle, type SandboxCommandResult, type SandboxCommands, type SandboxConnectOptions, type SandboxCreateOptions, type SandboxFiles, type SandboxInfo, type SandboxInstance, type SandboxListOptions, type SandboxProvider, type SandboxRunOptions, type SandboxSpawnOptions, type WatchHandle, type WatchOptions, createE2BProvider };
+export { E2BBootCommandError, E2BCommands, type E2BConfig, E2BFiles, E2BIdleTimeoutError, E2BNetworkUpdateUnsupportedError, E2BProvider, E2BResourcesError, type E2BSandboxPaginator, E2B_MAX_LIST_PAGES, E2B_MAX_PAGE_SIZE, E2B_MIN_UPDATE_NETWORK_VERSION, type FileInfo, type FilesystemEvent, type ProcessInfo, type SandboxCommandHandle, type SandboxCommandResult, type SandboxCommands, type SandboxConnectOptions, type SandboxCreateOptions, type SandboxFiles, type SandboxInfo, type SandboxInstance, type SandboxListOptions, type SandboxListPage, type SandboxProvider, type SandboxRunOptions, type SandboxSpawnOptions, type WatchHandle, type WatchOptions, _testCollectSandboxPages, type _testE2BSandboxImpl, createE2BProvider };

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Sandbox } from '@e2b/code-interpreter';
+
 /**
  * E2B Sandbox Provider - Clean Architecture
  *
@@ -11,6 +13,72 @@
  * - Configuration externalized (no hardcoded mappings)
  * - Clear naming (run = blocking, spawn = background)
  */
+
+/**
+ * Largest page E2B will serve. Not a taste choice — a larger `limit` is refused
+ * outright: `400 validation error: parameter "limit" in query has an error:
+ * number must be at most 100`.
+ */
+declare const E2B_MAX_PAGE_SIZE = 100;
+/**
+ * Page ceiling for one enumeration — 10,000 sandboxes at the maximum page size.
+ * A walk that reaches it stops and reports itself INCOMPLETE, because the one
+ * thing a fleet enumeration may never do is return a short list that reads like
+ * a whole one.
+ */
+declare const E2B_MAX_LIST_PAGES = 100;
+/**
+ * Typed error for create-time sizing requests E2B cannot enforce.
+ * E2B sandboxes inherit cpu/memory from their TEMPLATE (Template.build
+ * cpuCount/memoryMB; disk is plan-fixed) — Sandbox.create has no sizing
+ * parameters, so a `resources` request would be silently ignored. Per the
+ * provider law (reject what you cannot enforce) it is refused loudly here.
+ */
+declare class E2BResourcesError extends Error {
+    constructor(message: string);
+}
+/**
+ * Minimum `e2b` client that can switch a running sandbox's egress.
+ *
+ * 2.25.0, per e2b's own release notes: "Add `Sandbox.updateNetwork` /
+ * `update_network` to replace a running sandbox's egress configuration"
+ * (e2b@2.25.0). Confirmed against the published type declarations — absent in
+ * 2.24.0, present in 2.25.0.
+ *
+ * IT SAID 2.26.0 UNTIL THE RELEASE NOTES WERE READ. That number came from a
+ * binary search over published tarballs that happened to sample only even
+ * minors, so 2.25.0 was never tested and the first "present" result looked
+ * like the boundary. The search was sound and the conclusion was still wrong
+ * by one release — which is the argument for reading the vendor's own record
+ * rather than inferring version history from artifacts.
+ */
+declare const E2B_MIN_UPDATE_NETWORK_VERSION = "2.25.0";
+/**
+ * Typed error for a runtime egress switch the INSTALLED client cannot make.
+ *
+ * E2B the service supports it; an older `e2b` package simply has no method to
+ * call. That distinction matters to whoever reads this: the fix is a
+ * dependency bump, not a plan change or a different provider. Refused loudly
+ * rather than skipped, because a policy switch that quietly does nothing
+ * leaves the sandbox running under the previous policy — which, when the
+ * switch was meant to TIGHTEN egress, is the failure nobody notices.
+ */
+declare class E2BNetworkUpdateUnsupportedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Typed error for an idle timeout E2B cannot enforce. E2B has exactly one
+ * clock and it is absolute: the sandbox is killed when its timeout expires,
+ * and only explicit client calls (create, connect, setTimeout) move that
+ * deadline — never what the sandbox is or is not doing. An `idleTimeoutMs`
+ * would therefore be silently ignored, so it is refused instead.
+ */
+declare class E2BBootCommandError extends Error {
+    constructor();
+}
+declare class E2BIdleTimeoutError extends Error {
+    constructor();
+}
 /** Result of a completed sandbox command */
 interface SandboxCommandResult {
     exitCode: number;
@@ -85,11 +153,71 @@ interface SandboxConnectOptions {
 }
 /** Options for creating a sandbox */
 interface SandboxCreateOptions {
-    image: string;
+    /**
+     * E2B template ID. OPTIONAL: create() falls back to the provider's
+     * configured `templateId`, then to "evolve-all" — declaring it required
+     * contradicted that implementation and only went unnoticed because TS
+     * method parameters are bivariant, so the SDK could already call
+     * create({}) through the shared contract.
+     */
+    image?: string;
     envs?: Record<string, string>;
     metadata?: Record<string, string>;
     timeoutMs?: number;
+    /**
+     * REJECTED with E2BIdleTimeoutError. E2B's timeout is an ABSOLUTE lifetime
+     * that in-sandbox activity never extends, so there is no inactivity clock to
+     * map this onto and honouring it would be a lie.
+     */
+    idleTimeoutMs?: number;
+    /**
+     * REJECTED with E2BBootCommandError. The sandbox boots the template's own
+     * init — a start command is a template-BUILD field (startCmd) this provider
+     * never sets, so a create-time argv cannot be honored. The boot is already
+     * inert; exec the process after create instead.
+     */
+    bootCommand?: string[];
     workingDirectory?: string;
+    /**
+     * Per-sandbox compute sizing (cpu cores, memory GiB, disk GiB). E2B sizes
+     * sandboxes at TEMPLATE BUILD time only (Template.build cpuCount/memoryMB;
+     * disk is plan-fixed) — create-time sizing cannot be enforced, so any value
+     * here is REJECTED with E2BResourcesError rather than silently ignored.
+     * Bake sizing into the template the `image` names instead. `gpu`/`gpuTypes`
+     * are rejected the same way: e2b offers no GPU allocation at any tier.
+     */
+    resources?: {
+        cpu?: number;
+        memory?: number;
+        disk?: number;
+        gpu?: number;
+        gpuTypes?: string[];
+    };
+    network?: {
+        outbound: "open" | "blocked";
+        allowedDestinations?: string[];
+    };
+    /**
+     * Every policy `updateNetwork()` may later be asked for on this box.
+     *
+     * ACCEPTED AND IGNORED HERE, deliberately. It exists because on modal the
+     * create call decides whether switching is possible at all, and a box built
+     * the blunt way can never be widened. E2B has no such constraint — it
+     * switches freely at any time — so this changes nothing about the sandbox
+     * it creates.
+     *
+     * Declared anyway so the option means the SAME thing in every provider
+     * package: a caller reading these types must not conclude that E2B
+     * cannot do phase switching because the option is missing here.
+     */
+    phaseNetworkPolicies?: Array<{
+        outbound: "open" | "blocked";
+        allowedDestinations?: string[];
+    }>;
+    /** Run all commands and file operations as this user (passed on every E2B operation that supports it). */
+    user?: string;
+    /** Home directory used by the SDK for agent config paths; not consumed by the provider. */
+    homeDir?: string;
 }
 /** Options for listing sandboxes */
 interface SandboxListOptions {
@@ -97,6 +225,20 @@ interface SandboxListOptions {
     metadata?: Record<string, string>;
     limit?: number;
 }
+/**
+ * A COMPLETE (or admittedly incomplete) enumeration of the project's fleet.
+ *
+ * `complete` is the load-bearing field. Callers that need a whole fleet —
+ * orphan sweeps, lifecycle reconciliation — read a sandbox's ABSENCE from the
+ * list as evidence it is gone, so a truncated page and a small fleet must never
+ * be the same answer. `complete: false` means leave every row alone.
+ */
+interface SandboxListPage {
+    sandboxes: SandboxInfo[];
+    complete: boolean;
+    pagesFetched: number;
+    error?: string;
+}
 /** Command execution capabilities */
 interface SandboxCommands {
     /** Run command and wait for completion */
@@ -127,6 +269,8 @@ interface SandboxFiles {
     readStream(path: string): Promise<ReadableStream<Uint8Array>>;
     /** Write from stream */
     writeStream(path: string, stream: ReadableStream<Uint8Array>): Promise<void>;
+    /** Upload a local file by path, streamed off disk (never buffered whole) */
+    writeFromPath(sandboxPath: string, localPath: string): Promise<void>;
     /** Get pre-signed upload URL for large files (expiration in seconds) */
     uploadUrl(path: string, expiresInSeconds?: number): Promise<string>;
     /** Get pre-signed download URL for large files (expiration in seconds) */
@@ -159,17 +303,23 @@ interface SandboxInstance {
     kill(): Promise<void>;
     /** Pause sandbox (preserves state) */
     pause(): Promise<void>;
+    /** Replace the outbound network policy of the running sandbox. */
+    updateNetwork(network: SandboxCreateOptions["network"]): Promise<void>;
 }
 /** Sandbox lifecycle management */
 interface SandboxProvider {
     /** Provider type identifier */
     readonly providerType: string;
+    /** Human-readable provider name for logging */
+    readonly name?: string;
     /** Create new sandbox */
     create(options: SandboxCreateOptions): Promise<SandboxInstance>;
     /** Connect to existing sandbox */
     connect(sandboxId: string, timeoutMs?: number): Promise<SandboxInstance>;
-    /** List sandboxes (first page only, up to limit) */
+    /** List sandboxes, paginating to exhaustion. `limit` bounds items returned. */
     list(options?: SandboxListOptions): Promise<SandboxInfo[]>;
+    /** The same enumeration for fleet bookkeeping: never throws, reports completeness. */
+    listAll(options?: SandboxListOptions): Promise<SandboxListPage>;
 }
 interface E2BConfig {
     /** E2B API key. Default: reads from E2B_API_KEY env var */
@@ -187,17 +337,169 @@ interface ResolvedE2BConfig {
     defaultTimeoutMs?: number;
     templateId?: string;
 }
+declare class E2BCommands implements SandboxCommands {
+    private sandbox;
+    private defaultUser?;
+    constructor(sandbox: Sandbox, defaultUser?: string | undefined);
+    run(command: string, options?: SandboxRunOptions): Promise<SandboxCommandResult>;
+    spawn(command: string, options?: SandboxSpawnOptions): Promise<SandboxCommandHandle>;
+    list(): Promise<ProcessInfo[]>;
+    connect(processId: string, options?: SandboxConnectOptions): Promise<SandboxCommandHandle>;
+    sendStdin(processId: string, data: string): Promise<void>;
+    kill(processId: string): Promise<boolean>;
+}
+declare class E2BFiles implements SandboxFiles {
+    private sandbox;
+    private defaultUser?;
+    constructor(sandbox: Sandbox, defaultUser?: string | undefined);
+    read(path: string): Promise<string | Uint8Array>;
+    write(path: string, content: string | Buffer | ArrayBuffer | Uint8Array): Promise<void>;
+    writeBatch(files: Array<{
+        path: string;
+        data: string | Buffer | ArrayBuffer | Uint8Array;
+    }>): Promise<void>;
+    makeDir(path: string): Promise<void>;
+    uploadUrl(path: string, expiresInSeconds?: number): Promise<string>;
+    downloadUrl(path: string, expiresInSeconds?: number): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    list(path: string): Promise<FileInfo[]>;
+    remove(path: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    readStream(path: string): Promise<ReadableStream<Uint8Array>>;
+    writeStream(path: string, stream: ReadableStream<Uint8Array>): Promise<void>;
+    /**
+     * Upload a local file by PATH, streamed off disk with real backpressure.
+     *
+     * Why this does NOT go through files.write(): that method calls
+     * `new Response(data).blob()` on whatever it is given, which MATERIALIZES the
+     * body — measured at +463 MB RSS for a 200 MB source, whether the input is a
+     * stream, a Buffer, or even a file-backed Blob. So handing it a stream looks
+     * like streaming and is not, which is precisely the trap this method exists to
+     * avoid: a caller uploading a large artifact once per concurrent task would
+     * still pay the full size every time.
+     *
+     * Instead the multipart body is assembled as a ReadableStream and POSTed to
+     * the signed upload URL with `duplex: "half"` — the same shape E2B's own
+     * template-context upload uses. Verified to hold backpressure: against a
+     * deliberately slow sink the producer had read 7 MB of a 200 MB file after
+     * four seconds, rather than racing to the end.
+     *
+     * The wire format mirrors files.write()'s single-file case exactly: the
+     * destination is the `path` query parameter of the signed URL, and the body is
+     * one `file` part. If E2B ever changes that, the POST fails and we fall back to
+     * the SDK's own (buffering) path — a correct upload beats a cheap one.
+     */
+    writeFromPath(sandboxPath: string, localPath: string): Promise<void>;
+    watchDir(path: string, onEvent: (event: FilesystemEvent) => void | Promise<void>, options?: WatchOptions): Promise<WatchHandle>;
+}
+declare class E2BSandboxImpl implements SandboxInstance {
+    private sandbox;
+    private apiKey;
+    private apiUrl?;
+    readonly commands: SandboxCommands;
+    readonly files: SandboxFiles;
+    constructor(sandbox: Sandbox, apiKey: string, apiUrl?: string | undefined, defaultUser?: string);
+    get sandboxId(): string;
+    getHost(port: number): Promise<string>;
+    isRunning(): Promise<boolean>;
+    getInfo(): Promise<SandboxInfo>;
+    /**
+     * Replace the running sandbox's outbound policy — E2B's
+     * `Sandbox.updateNetwork`: "Update the network configuration of the sandbox.
+     * Replaces the current egress configuration atomically — fields that are
+     * omitted are cleared on the server." (from the published e2b 2.25.0+ type
+     * declarations for Sandbox.updateNetwork).
+     *
+     * That "omitted fields are cleared" rule is why the whole policy is sent
+     * every time and never a delta: mapNetworkPolicy always states
+     * allowInternetAccess, and states `network` only when an allowlist is in
+     * force — so switching from an allowlist to a sealed box clears the
+     * allowlist by the server's own rule rather than by a second call that could
+     * fail in between and leave the box half-switched.
+     *
+     * VERSION GATE. `updateNetwork` landed in e2b 2.25.0; the client resolved in
+     * this workspace today is older and has no such method. Feature-detected
+     * rather than assumed, and refused loudly when absent — a `catch` around a
+     * missing method, or an early return, would leave the sandbox on its
+     * previous policy while the caller believes the switch happened.
+     */
+    updateNetwork(network: SandboxCreateOptions["network"]): Promise<void>;
+    kill(): Promise<void>;
+    pause(): Promise<void>;
+}
 declare class E2BProvider implements SandboxProvider {
     readonly providerType: "e2b";
+    readonly name = "E2B";
     private readonly apiKey;
     private readonly apiUrl?;
     private readonly defaultTimeoutMs;
     private readonly templateId?;
+    /**
+     * Sandbox user configured at create time, reapplied on connect() (e.g., resume).
+     * In-memory only: a connect() from a fresh process runs as the template default
+     * user — callers reconnecting across processes must recreate the provider config
+     * with the same user, or operations on user-owned files fail loudly.
+     */
+    private readonly sandboxUsers;
     constructor(config: ResolvedE2BConfig);
     create(options: SandboxCreateOptions): Promise<SandboxInstance>;
     connect(sandboxId: string, timeoutMs?: number): Promise<SandboxInstance>;
+    /**
+     * List sandboxes, walking every page.
+     *
+     * This used to call `nextItems()` exactly once and return whatever the first
+     * page held — an account with more than E2B_MAX_PAGE_SIZE sandboxes was
+     * silently truncated, and nothing in the return value said so. That is a
+     * correctness bug rather than a performance one for any caller that reads
+     * absence from the list as "this sandbox is gone".
+     *
+     * `limit` still means what a caller expects: stop after this many ITEMS, so
+     * an explicit limit remains a cost bound. The per-request page size is capped
+     * separately at E2B_MAX_PAGE_SIZE because E2B rejects anything larger
+     * outright (`400 validation error: parameter "limit" ... must be at most
+     * 100`), so a caller asking for 500 gets five requests, not one refusal.
+     */
     list(options?: SandboxListOptions): Promise<SandboxInfo[]>;
+    /**
+     * The fleet-bookkeeping enumeration: same walk, never throws.
+     *
+     * The distinction from `list()` is what a failure MEANS to the caller. An
+     * orphan sweep treats a missing sandbox as a terminated one, so it must be
+     * able to tell "the project has no sandboxes" from "the enumeration stopped
+     * early" — and an exception it catches and turns into an empty array erases
+     * exactly that difference.
+     */
+    listAll(options?: SandboxListOptions): Promise<SandboxListPage>;
+    private paginate;
+}
+/** The paginator surface this walk needs — E2B's SandboxPaginator satisfies it. */
+interface E2BSandboxPaginator {
+    readonly hasNext: boolean;
+    readonly nextToken?: string;
+    nextItems(): Promise<Array<{
+        sandboxId: string;
+        templateId: string;
+        name?: string;
+        metadata?: Record<string, string>;
+        startedAt: unknown;
+        endAt?: unknown;
+    }>>;
 }
+/**
+ * Drain a paginator into one answer, with an honest completeness verdict.
+ *
+ * Separate from the provider because everything worth getting wrong lives here
+ * and none of it needs a network: the two ways a walk can fail to terminate,
+ * the difference between "the caller asked for ten" and "the provider ran out",
+ * and the rule that a failure mid-walk yields the sandboxes seen so far marked
+ * INCOMPLETE rather than either an exception or a short complete list.
+ *
+ * Exported for its test (`_testCollectSandboxPages`).
+ */
+declare function collectSandboxPages(paginator: E2BSandboxPaginator, wanted?: number): Promise<SandboxListPage & {
+    stoppedAtLimit: boolean;
+}>;
+declare const _testCollectSandboxPages: typeof collectSandboxPages;
 /**
  * Create E2B sandbox provider.
  *
@@ -205,5 +507,13 @@ declare class E2BProvider implements SandboxProvider {
  * @throws Error if apiKey cannot be resolved
  */
 declare function createE2BProvider(config?: E2BConfig): SandboxProvider;
+/**
+ * TYPE-ONLY handle on the concrete sandbox class, for the contract-conformance
+ * seam. create() is declared to return the local SandboxInstance INTERFACE, so
+ * a seam reading create()'s return type checks the interface and never the
+ * class — which let a narrowed method on the class pass unnoticed. Exporting
+ * the type (never the constructor) gives the seam the real methods to pin.
+ */
+type _testE2BSandboxImpl = E2BSandboxImpl;
 
-export { type E2BConfig, E2BProvider, type FileInfo, type FilesystemEvent, type ProcessInfo, type SandboxCommandHandle, type SandboxCommandResult, type SandboxCommands, type SandboxConnectOptions, type SandboxCreateOptions, type SandboxFiles, type SandboxInfo, type SandboxInstance, type SandboxListOptions, type SandboxProvider, type SandboxRunOptions, type SandboxSpawnOptions, type WatchHandle, type WatchOptions, createE2BProvider };
+export { E2BBootCommandError, E2BCommands, type E2BConfig, E2BFiles, E2BIdleTimeoutError, E2BNetworkUpdateUnsupportedError, E2BProvider, E2BResourcesError, type E2BSandboxPaginator, E2B_MAX_LIST_PAGES, E2B_MAX_PAGE_SIZE, E2B_MIN_UPDATE_NETWORK_VERSION, type FileInfo, type FilesystemEvent, type ProcessInfo, type SandboxCommandHandle, type SandboxCommandResult, type SandboxCommands, type SandboxConnectOptions, type SandboxCreateOptions, type SandboxFiles, type SandboxInfo, type SandboxInstance, type SandboxListOptions, type SandboxListPage, type SandboxProvider, type SandboxRunOptions, type SandboxSpawnOptions, type WatchHandle, type WatchOptions, _testCollectSandboxPages, type _testE2BSandboxImpl, createE2BProvider };

package/dist/index.js

@@ -1,2 +1,8 @@
-import {Sandbox}from'@e2b/code-interpreter';var p=new Set([".xlsx",".xls",".docx",".doc",".pptx",".ppt",".pdf",".zip",".tar",".gz",".7z",".rar",".png",".jpg",".jpeg",".gif",".webp",".ico",".bmp",".mp3",".wav",".ogg",".flac",".aac",".mp4",".avi",".mov",".mkv",".webm",".woff",".woff2",".ttf",".otf",".eot",".exe",".dll",".so",".dylib",".sqlite",".db",".pickle",".pkl",".parquet"]);function a(i){return i instanceof Date?i.toISOString():String(i)}function l(i){if(typeof i=="string"||i instanceof ArrayBuffer)return i;if(i instanceof Buffer)return new Uint8Array(i).buffer;if(i instanceof Uint8Array)return new Uint8Array(i).buffer;throw new Error(`Unsupported data type for file upload: ${typeof i}. Expected string, Buffer, ArrayBuffer, or Uint8Array.`)}function g(i){let t=i.substring(i.lastIndexOf(".")).toLowerCase();return p.has(t)}var m=class{constructor(t){this.sandbox=t;}async run(t,e){try{let n=await this.sandbox.commands.run(t,{timeoutMs:e?.timeoutMs,envs:e?.envs,cwd:e?.cwd,onStdout:e?.onStdout,onStderr:e?.onStderr});return {exitCode:n.exitCode,stdout:n.stdout,stderr:n.stderr}}catch(n){if(n&&typeof n=="object"&&"exitCode"in n){let r=n;return {exitCode:r.exitCode,stdout:r.stdout??"",stderr:r.stderr??""}}throw n}}async spawn(t,e){let n=await this.sandbox.commands.run(t,{background:true,stdin:e?.stdin??true,timeoutMs:e?.timeoutMs,envs:e?.envs,cwd:e?.cwd,onStdout:e?.onStdout,onStderr:e?.onStderr});return {processId:String(n.pid),wait:async()=>{try{let r=await n.wait();return {exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch(r){if(r&&typeof r=="object"&&"exitCode"in r){let s=r;return {exitCode:s.exitCode,stdout:s.stdout??"",stderr:s.stderr??""}}throw r}},kill:()=>this.sandbox.commands.kill(n.pid)}}async list(){return (await this.sandbox.commands.list()).map(e=>({...e,processId:String(e.pid)}))}async connect(t,e){let n=await this.sandbox.commands.connect(Number(t),{onStdout:e?.onStdout,onStderr:e?.onStderr,timeoutMs:e?.timeoutMs});return {processId:String(n.pid),wait:async()=>{try{let r=await n.wait();return {exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch(r){if(r&&typeof r=="object"&&"exitCode"in r){let s=r;return {exitCode:s.exitCode,stdout:s.stdout??"",stderr:s.stderr??""}}throw r}},kill:()=>this.sandbox.commands.kill(n.pid)}}async sendStdin(t,e){await this.sandbox.commands.sendStdin(Number(t),e);}async kill(t){return this.sandbox.commands.kill(Number(t))}},c=class{constructor(t){this.sandbox=t;}async read(t){return g(t)?this.sandbox.files.read(t,{format:"bytes",requestTimeoutMs:3e5}):this.sandbox.files.read(t,{format:"text",requestTimeoutMs:3e5})}async write(t,e){await this.sandbox.files.write(t,l(e),{requestTimeoutMs:3e5});}async writeBatch(t){let e=t.map(n=>({path:n.path,data:l(n.data)}));await this.sandbox.files.write(e,{requestTimeoutMs:3e5});}async makeDir(t){await this.sandbox.files.makeDir(t);}async uploadUrl(t,e){return this.sandbox.uploadUrl(t,e?{useSignatureExpiration:e}:void 0)}async downloadUrl(t,e){return this.sandbox.downloadUrl(t,e?{useSignatureExpiration:e}:void 0)}async exists(t){return this.sandbox.files.exists(t)}async list(t){return (await this.sandbox.files.list(t)).map(n=>({name:n.name,path:n.path,type:n.type==="dir"?"dir":"file"}))}async remove(t){await this.sandbox.files.remove(t);}async rename(t,e){await this.sandbox.files.rename(t,e);}async readStream(t){return this.sandbox.files.read(t,{format:"stream"})}async writeStream(t,e){await this.sandbox.files.write(t,e);}async watchDir(t,e,n){let r=await this.sandbox.files.watchDir(t,e,{recursive:n?.recursive,timeoutMs:n?.timeoutMs,onExit:n?.onExit});return {stop:()=>r.stop()}}},o=class{constructor(t,e,n){this.sandbox=t;this.apiKey=e;this.apiUrl=n;this.commands=new m(t),this.files=new c(t);}commands;files;get sandboxId(){return this.sandbox.sandboxId}getHost(t){return Promise.resolve(this.sandbox.getHost(t))}async isRunning(){return this.sandbox.isRunning()}async getInfo(){let t=await this.sandbox.getInfo();return {sandboxId:t.sandboxId,image:t.templateId,name:t.name,metadata:t.metadata??{},startedAt:a(t.startedAt),endAt:t.endAt?a(t.endAt):void 0}}async kill(){try{await this.sandbox.kill();}catch{await new Promise(t=>setTimeout(t,500)),await this.sandbox.kill();}}async pause(){await this.sandbox.betaPause({apiKey:this.apiKey,apiUrl:this.apiUrl});}},u=class{providerType="e2b";apiKey;apiUrl;defaultTimeoutMs;templateId;constructor(t){this.apiKey=t.apiKey,this.apiUrl=t.apiUrl,this.defaultTimeoutMs=t.defaultTimeoutMs??36e5,this.templateId=t.templateId;}async create(t){let e=t.timeoutMs??this.defaultTimeoutMs,n=t.image??this.templateId??"evolve-all",r=await Sandbox.create(n,{apiKey:this.apiKey,apiUrl:this.apiUrl,envs:t.envs,metadata:t.metadata,timeoutMs:e});return t.workingDirectory&&await r.files.makeDir(t.workingDirectory),new o(r,this.apiKey,this.apiUrl)}async connect(t,e){let n=await Sandbox.connect(t,{apiKey:this.apiKey,apiUrl:this.apiUrl,timeoutMs:e??this.defaultTimeoutMs});return new o(n,this.apiKey,this.apiUrl)}async list(t){return (await Sandbox.list({apiKey:this.apiKey,apiUrl:this.apiUrl,query:{state:t?.state,metadata:t?.metadata},limit:t?.limit??100}).nextItems()).map(r=>({sandboxId:r.sandboxId,image:r.templateId,name:r.name,metadata:r.metadata??{},startedAt:a(r.startedAt),endAt:r.endAt?a(r.endAt):void 0}))}};function b(i={}){let t=i.apiKey??process.env.E2B_API_KEY;if(!t)throw new Error("E2B API key required. Set E2B_API_KEY environment variable or pass apiKey in config. Get your key at https://e2b.dev/sign-in");return new u({...i,apiKey:t})}
-export{u as E2BProvider,b as createE2BProvider};
+import {Sandbox}from'@e2b/code-interpreter';function b(s){if(!s||typeof s!="object")return  false;if(s.name==="TimeoutError")return  true;let e=s.message;return typeof e=="string"&&/timed?\s*out/i.test(e)}var k=100,I=100;function u(s){return s instanceof Date?s.toISOString():String(s)}function U(s){if(typeof s=="string"||s instanceof ArrayBuffer)return s;if(s instanceof Buffer)return new Uint8Array(s).buffer;if(s instanceof Uint8Array)return new Uint8Array(s).buffer;throw new Error(`Unsupported data type for file upload: ${typeof s}. Expected string, Buffer, ArrayBuffer, or Uint8Array.`)}var l=class extends Error{constructor(e){super(e),this.name="E2BResourcesError";}},B="2.25.0",g=class extends Error{constructor(e){super(e),this.name="E2BNetworkUpdateUnsupportedError";}};function x(s){if(s?.outbound==="open"&&s.allowedDestinations?.length)throw new Error("network.allowedDestinations is only valid when outbound is blocked");let e=s?.allowedDestinations??[],t=s?.outbound==="blocked"&&e.length>0;return {allowInternetAccess:s?.outbound!=="blocked"||t,network:t?{denyOut:["0.0.0.0/0"],allowOut:e}:void 0}}var h=class extends Error{constructor(){super("E2B takes no create-time boot command: the sandbox boots its template's own init, and a start command is a template-BUILD field (Template startCmd) this provider never sets. The boot is already inert \u2014 run the process by exec after create, or bake it into the template the `image` names."),this.name="E2BBootCommandError";}},y=class extends Error{constructor(){super("E2B has no idle timeout: its sandbox timeout is an ABSOLUTE lifetime that in-sandbox activity never extends. Use `timeoutMs` for the lifetime, and call setTimeout() to extend a sandbox you know is still working."),this.name="E2BIdleTimeoutError";}},w=class{constructor(e,t){this.sandbox=e;this.defaultUser=t;}async run(e,t){try{let r=await this.sandbox.commands.run(e,{timeoutMs:t?.timeoutMs,envs:t?.envs,cwd:t?.cwd,user:this.defaultUser,onStdout:t?.onStdout,onStderr:t?.onStderr});return {exitCode:r.exitCode,stdout:r.stdout,stderr:r.stderr}}catch(r){if(r&&typeof r=="object"&&"exitCode"in r){let n=r;return {exitCode:n.exitCode,stdout:n.stdout??"",stderr:n.stderr??""}}if(b(r))return {exitCode:124,stdout:"",stderr:r instanceof Error?r.message:"command timed out"};throw r}}async spawn(e,t){let r=await this.sandbox.commands.run(e,{background:true,stdin:t?.stdin??true,timeoutMs:t?.timeoutMs,envs:t?.envs,cwd:t?.cwd,user:this.defaultUser,onStdout:t?.onStdout,onStderr:t?.onStderr});return {processId:String(r.pid),wait:async()=>{try{let n=await r.wait();return {exitCode:n.exitCode,stdout:n.stdout,stderr:n.stderr}}catch(n){if(n&&typeof n=="object"&&"exitCode"in n){let i=n;return {exitCode:i.exitCode,stdout:i.stdout??"",stderr:i.stderr??""}}if(b(n))return {exitCode:124,stdout:"",stderr:n instanceof Error?n.message:"command timed out"};throw n}},kill:()=>this.sandbox.commands.kill(r.pid)}}async list(){return (await this.sandbox.commands.list()).map(t=>({...t,processId:String(t.pid)}))}async connect(e,t){let r=await this.sandbox.commands.connect(Number(e),{onStdout:t?.onStdout,onStderr:t?.onStderr,timeoutMs:t?.timeoutMs});return {processId:String(r.pid),wait:async()=>{try{let n=await r.wait();return {exitCode:n.exitCode,stdout:n.stdout,stderr:n.stderr}}catch(n){if(n&&typeof n=="object"&&"exitCode"in n){let i=n;return {exitCode:i.exitCode,stdout:i.stdout??"",stderr:i.stderr??""}}if(b(n))return {exitCode:124,stdout:"",stderr:n instanceof Error?n.message:"command timed out"};throw n}},kill:()=>this.sandbox.commands.kill(r.pid)}}async sendStdin(e,t){await this.sandbox.commands.sendStdin(Number(e),t);}async kill(e){return this.sandbox.commands.kill(Number(e))}},S=class{constructor(e,t){this.sandbox=e;this.defaultUser=t;}async read(e){let t=await this.sandbox.files.read(e,{format:"bytes",requestTimeoutMs:3e5,user:this.defaultUser});if(!t.includes(0))try{return new TextDecoder("utf-8",{fatal:!0,ignoreBOM:!0}).decode(t)}catch{}return t}async write(e,t){await this.sandbox.files.write(e,U(t),{requestTimeoutMs:3e5,user:this.defaultUser});}async writeBatch(e){let t=e.map(r=>({path:r.path,data:U(r.data)}));await this.sandbox.files.write(t,{requestTimeoutMs:3e5,user:this.defaultUser});}async makeDir(e){await this.sandbox.files.makeDir(e,{user:this.defaultUser});}async uploadUrl(e,t){return this.sandbox.uploadUrl(e,{user:this.defaultUser,...t?{useSignatureExpiration:t}:{}})}async downloadUrl(e,t){return this.sandbox.downloadUrl(e,{user:this.defaultUser,...t?{useSignatureExpiration:t}:{}})}async exists(e){return this.sandbox.files.exists(e,{user:this.defaultUser})}async list(e){return (await this.sandbox.files.list(e,{user:this.defaultUser})).map(r=>({name:r.name,path:r.path,type:r.type==="dir"?"dir":"file"}))}async remove(e){await this.sandbox.files.remove(e,{user:this.defaultUser});}async rename(e,t){await this.sandbox.files.rename(e,t,{user:this.defaultUser});}async readStream(e){return this.sandbox.files.read(e,{format:"stream",user:this.defaultUser})}async writeStream(e,t){await this.sandbox.files.write(e,t,{user:this.defaultUser});}async writeFromPath(e,t){let{createReadStream:r,statSync:n}=await import('fs'),{Readable:i}=await import('stream'),{randomBytes:d}=await import('crypto'),a=n(t).size,p=`----evolve${d(16).toString("hex")}`,v=Buffer.from(`--${p}\r
+Content-Disposition: form-data; name="file"; filename="blob"\r
+Content-Type: application/octet-stream\r
+\r
+`),A=Buffer.from(`\r
+--${p}--\r
+`);async function*C(){yield v;for await(let o of r(t))yield o;yield A;}try{let o=await this.uploadUrl(e),m=await fetch(o,{method:"POST",body:i.toWeb(i.from(C())),headers:{"Content-Type":`multipart/form-data; boundary=${p}`,"Content-Length":String(v.length+a+A.length)},duplex:"half"});if(!m.ok)throw new Error(`streamed upload to ${e} failed (HTTP ${m.status})`)}catch(o){console.warn(`[e2b] streamed upload of ${t} failed, falling back to a buffered write:`,o instanceof Error?o.message:o);let m=i.toWeb(r(t));await this.writeStream(e,m);}}async watchDir(e,t,r){let n=await this.sandbox.files.watchDir(e,t,{recursive:r?.recursive,timeoutMs:r?.timeoutMs,user:this.defaultUser,onExit:r?.onExit});return {stop:()=>n.stop()}}},c=class{constructor(e,t,r,n){this.sandbox=e;this.apiKey=t;this.apiUrl=r;this.commands=new w(e,n),this.files=new S(e,n);}commands;files;get sandboxId(){return this.sandbox.sandboxId}getHost(e){return Promise.resolve(this.sandbox.getHost(e))}async isRunning(){return this.sandbox.isRunning()}async getInfo(){let e=await this.sandbox.getInfo();return {sandboxId:e.sandboxId,image:e.templateId,name:e.name,metadata:e.metadata??{},startedAt:u(e.startedAt),endAt:e.endAt?u(e.endAt):void 0}}async updateNetwork(e){let t=x(e),r=this.sandbox;if(typeof r.updateNetwork!="function")throw new g(`The installed e2b client cannot change a running sandbox's network policy: Sandbox.updateNetwork requires e2b >= ${B}. Upgrade the e2b dependency (it is pulled in by @e2b/code-interpreter), or create the sandbox with the policy it needs for its whole lifetime.`);await r.updateNetwork({allowInternetAccess:t.allowInternetAccess,...t.network??{}});}async kill(){try{await this.sandbox.kill();}catch{await new Promise(e=>setTimeout(e,500)),await this.sandbox.kill();}}async pause(){await this.sandbox.betaPause({apiKey:this.apiKey,apiUrl:this.apiUrl});}},P=class{providerType="e2b";name="E2B";apiKey;apiUrl;defaultTimeoutMs;templateId;sandboxUsers=new Map;constructor(e){this.apiKey=e.apiKey,this.apiUrl=e.apiUrl,this.defaultTimeoutMs=e.defaultTimeoutMs??36e5,this.templateId=e.templateId;}async create(e){if(e.bootCommand!==void 0)throw new h;if(e.idleTimeoutMs!==void 0)throw new y;if(e.resources?.gpu!==void 0||e.resources?.gpuTypes!==void 0)throw new l("E2B offers no GPU allocation at any tier \u2014 a `resources.gpu` request cannot be enforced. Run GPU workloads on a provider that reserves GPUs (modal).");if(e.resources&&(e.resources.cpu!==void 0||e.resources.memory!==void 0||e.resources.disk!==void 0))throw new l("E2B cannot size a sandbox at create time: sizing is fixed by the template (Template.build cpuCount/memoryMB; disk is plan-fixed). Build a template with the desired resources and pass it as `image` instead of `resources`.");let t=e.timeoutMs??this.defaultTimeoutMs,r=e.image??this.templateId??"evolve-all";for(let d of e.phaseNetworkPolicies??[])x(d);let n=x(e.network),i=await Sandbox.create(r,{apiKey:this.apiKey,apiUrl:this.apiUrl,envs:e.envs,metadata:e.metadata,timeoutMs:t,...n});return e.workingDirectory&&await i.files.makeDir(e.workingDirectory,{user:e.user}),e.user&&this.sandboxUsers.set(i.sandboxId,e.user),new c(i,this.apiKey,this.apiUrl,e.user)}async connect(e,t){let r=await Sandbox.connect(e,{apiKey:this.apiKey,apiUrl:this.apiUrl,timeoutMs:t??this.defaultTimeoutMs});return new c(r,this.apiKey,this.apiUrl,this.sandboxUsers.get(e))}async list(e){let t=await this.paginate(e);if(t.error&&!t.stoppedAtLimit)throw new Error(t.error);return t.sandboxes}async listAll(e){let{stoppedAtLimit:t,...r}=await this.paginate(e);return r}async paginate(e){let t=e?.limit;return E(Sandbox.list({apiKey:this.apiKey,apiUrl:this.apiUrl,query:{state:e?.state,metadata:e?.metadata},limit:t===void 0?k:Math.min(t,k)}),t)}};async function E(s,e){let t=[],r=0,n=new Set;for(;s.hasNext;){if(r>=I)return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:false,error:`sandbox list exceeded ${I} pages`};let i=s.nextToken;if(i!==void 0){if(n.has(i))return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:false,error:"pagination token repeated"};n.add(i);}let d;try{d=await s.nextItems();}catch(a){return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:false,error:`sandbox list failed: ${a instanceof Error?a.message:String(a)}`}}r+=1;for(let a of d){if(e!==void 0&&t.length>=e)return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:true,error:`stopped at the requested limit of ${e} with more sandboxes available`};t.push({sandboxId:a.sandboxId,image:a.templateId,name:a.name,metadata:a.metadata??{},startedAt:u(a.startedAt),endAt:a.endAt?u(a.endAt):void 0});}if(e!==void 0&&t.length>=e&&s.hasNext)return {sandboxes:t,complete:false,pagesFetched:r,stoppedAtLimit:true,error:`stopped at the requested limit of ${e} with more sandboxes available`};if(e!==void 0&&t.length>=e)break}return {sandboxes:t,complete:true,pagesFetched:r,stoppedAtLimit:false}}var T=E;function M(s={}){let e=s.apiKey??process.env.E2B_API_KEY;if(!e)throw new Error("E2B API key required. Set E2B_API_KEY environment variable or pass apiKey in config. Get your key at https://e2b.dev/sign-in");return new P({...s,apiKey:e})}
+export{h as E2BBootCommandError,w as E2BCommands,S as E2BFiles,y as E2BIdleTimeoutError,g as E2BNetworkUpdateUnsupportedError,P as E2BProvider,l as E2BResourcesError,I as E2B_MAX_LIST_PAGES,k as E2B_MAX_PAGE_SIZE,B as E2B_MIN_UPDATE_NETWORK_VERSION,T as _testCollectSandboxPages,M as createE2BProvider};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@evolvingmachines/e2b",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "keywords": [
     "ai",
     "agents",
     "sandbox",
     "e2b",
-    "evolve-sdk",
+    "evolve",
     "orchestration"
   ],
   "homepage": "https://github.com/evolving-machines-lab/evolve",
@@ -32,10 +32,11 @@
   "scripts": {
     "build": "tsup --minify",
     "dev": "tsup --watch",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "test:unit": "tsx tests/unit/e2b-list-pagination.test.ts && tsx tests/unit/e2b-files-read.test.ts && tsx tests/unit/e2b-gpu-rejection.test.ts && tsx tests/unit/e2b-boot-command-rejection.test.ts && tsx tests/unit/e2b-template-refresh.test.ts"
   },
   "dependencies": {
-    "@e2b/code-interpreter": "^2.0.1"
+    "@e2b/code-interpreter": "^2.7.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.18",