withruntime 0.4.0 → 0.5.0

package/dist/vercel/snapshot.d.ts

@@ -0,0 +1,93 @@
+import type { Runtime } from "../client.js";
+import type { Snapshot as RuntimeSnapshot } from "../snapshots.js";
+import { type Credentials, type WithRuntime } from "./client.js";
+type Status = "created" | "failed" | "deleted";
+/** A saved sandbox, as Vercel's Snapshot, over a Runtime snapshot: files,
+ * memory and running processes. `sourceSessionId` is the Runtime id of the
+ * sandbox it came from. */
+export declare class Snapshot {
+    #private;
+    constructor(snapshot: RuntimeSnapshot, client: Runtime);
+    get snapshotId(): string;
+    get sourceSessionId(): string;
+    get regions(): string[];
+    get status(): Status;
+    get sizeBytes(): number;
+    get createdAt(): Date;
+    get updatedAt(): Date;
+    get expiresAt(): Date;
+    static get(params: {
+        snapshotId: string;
+        signal?: AbortSignal;
+    } & Credentials & {
+        withruntime?: WithRuntime;
+    }): Promise<Snapshot>;
+    /** Snapshots, oldest first; `name` narrows to one sandbox's. */
+    static list(params?: {
+        name?: string;
+        limit?: number;
+    } & Credentials & {
+        withruntime?: WithRuntime;
+    } & Record<string, unknown>): Promise<{
+        snapshots: {
+            id: string;
+            sourceSessionId: string;
+            region: string;
+            regions: string[];
+            status: Status;
+            sizeBytes: number;
+            createdAt: number;
+            updatedAt: number;
+            expiresAt: number;
+        }[];
+        pagination: {
+            count: number;
+            next: string | null;
+        };
+    } & {
+        pages(): AsyncGenerator<{
+            snapshots: {
+                id: string;
+                sourceSessionId: string;
+                region: string;
+                regions: string[];
+                status: Status;
+                sizeBytes: number;
+                createdAt: number;
+                updatedAt: number;
+                expiresAt: number;
+            }[];
+            pagination: {
+                count: number;
+                next: string | null;
+            };
+        }, void, unknown>;
+        [Symbol.asyncIterator](): AsyncGenerator<{
+            id: string;
+            sourceSessionId: string;
+            region: string;
+            regions: string[];
+            status: Status;
+            sizeBytes: number;
+            createdAt: number;
+            updatedAt: number;
+            expiresAt: number;
+        }, void, unknown>;
+        toArray(): Promise<{
+            id: string;
+            sourceSessionId: string;
+            region: string;
+            regions: string[];
+            status: Status;
+            sizeBytes: number;
+            createdAt: number;
+            updatedAt: number;
+            expiresAt: number;
+        }[]>;
+    }>;
+    static tree(): Promise<never>;
+    delete(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export {};

package/dist/vercel/snapshot.js

@@ -0,0 +1,123 @@
+import { clientFor, signalOf } from "./client.js";
+import { APIError, guard, NotSupportedError } from "./errors.js";
+function statusOf(state) {
+    if (state === "failed")
+        return "failed";
+    if (state === "deleting" || state === "deleted")
+        return "deleted";
+    return "created";
+}
+function metadataOf(snapshot) {
+    return {
+        id: snapshot.id,
+        sourceSessionId: snapshot.sourceSandboxId,
+        region: "iad1",
+        regions: ["iad1"],
+        status: statusOf(snapshot.state),
+        sizeBytes: snapshot.storedBytes ?? 0,
+        createdAt: Date.parse(snapshot.createdAt),
+        updatedAt: Date.parse(snapshot.readyAt ?? snapshot.createdAt),
+        expiresAt: Date.parse(snapshot.expiresAt),
+    };
+}
+/** A saved sandbox, as Vercel's Snapshot, over a Runtime snapshot: files,
+ * memory and running processes. `sourceSessionId` is the Runtime id of the
+ * sandbox it came from. */
+export class Snapshot {
+    #snapshot;
+    #client;
+    constructor(snapshot, client) {
+        this.#snapshot = snapshot;
+        this.#client = client;
+    }
+    get snapshotId() {
+        return this.#snapshot.id;
+    }
+    get sourceSessionId() {
+        return this.#snapshot.sourceSandboxId;
+    }
+    get regions() {
+        return ["iad1"];
+    }
+    get status() {
+        return statusOf(this.#snapshot.state);
+    }
+    get sizeBytes() {
+        return this.#snapshot.storedBytes ?? 0;
+    }
+    get createdAt() {
+        return new Date(this.#snapshot.createdAt);
+    }
+    get updatedAt() {
+        return new Date(this.#snapshot.readyAt ?? this.#snapshot.createdAt);
+    }
+    get expiresAt() {
+        return new Date(this.#snapshot.expiresAt);
+    }
+    static async get(params) {
+        const client = clientFor(params);
+        return new Snapshot(await guard(() => client.snapshots.get(params.snapshotId, signalOf(params))), client);
+    }
+    /** Snapshots, oldest first; `name` narrows to one sandbox's. */
+    static async list(params = {}) {
+        for (const field of ["since", "until", "cursor", "sortOrder"])
+            if (params[field] !== undefined)
+                throw new NotSupportedError(`Listing snapshots by ${field}`, "List them all and filter the result yourself.");
+        const client = clientFor(params);
+        let sandboxId;
+        if (params.name !== undefined) {
+            const found = (await guard(() => client.sandboxes.list({ name: params.name, includeStopped: true }))).data[0];
+            if (!found)
+                return paginate([], null);
+            sandboxId = found.id;
+        }
+        const page = await guard(() => client.snapshots.list({
+            ...(sandboxId ? { sandboxId } : {}),
+            ...(params.limit ? { limit: params.limit } : {}),
+        }));
+        return paginate(page.data, page.nextCursor, page);
+    }
+    static tree() {
+        return Promise.reject(new NotSupportedError("Snapshot ancestry (Snapshot.tree)", "Use Snapshot.list and sourceSessionId."));
+    }
+    async delete(opts = {}) {
+        try {
+            await guard(() => this.#client.snapshots.delete(this.#snapshot.id, signalOf(opts)));
+        }
+        catch (error) {
+            if (error instanceof APIError && error.response.status === 404)
+                return;
+            throw error;
+        }
+    }
+}
+function paginate(data, next, page) {
+    const toPage = (items, cursor) => ({
+        snapshots: items.map(metadataOf),
+        pagination: { count: items.length, next: cursor },
+    });
+    return Object.assign(toPage(data, next), {
+        async *pages() {
+            if (!page) {
+                yield toPage(data, next);
+                return;
+            }
+            for await (const one of page.pages())
+                yield toPage(one.data, one.nextCursor);
+        },
+        async *[Symbol.asyncIterator]() {
+            if (!page)
+                return;
+            for await (const one of page.pages())
+                yield* one.data.map(metadataOf);
+        },
+        async toArray() {
+            const all = [];
+            if (!page)
+                return all;
+            for await (const one of page.pages())
+                all.push(...one.data.map(metadataOf));
+            return all;
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "withruntime",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "mcpName": "com.withruntime/runtime",
   "type": "module",
   "exports": {
@@ -15,6 +15,30 @@
     "./e2b/code-interpreter": {
       "types": "./dist/e2b/code-interpreter.d.ts",
       "import": "./dist/e2b/code-interpreter.js"
+    },
+    "./daytona": {
+      "types": "./dist/daytona/index.d.ts",
+      "import": "./dist/daytona/index.js"
+    },
+    "./vercel": {
+      "types": "./dist/vercel/index.d.ts",
+      "import": "./dist/vercel/index.js"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "import": "./dist/tools/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "import": "./dist/ai/index.js"
+    },
+    "./claude-agent-sdk": {
+      "types": "./dist/claude-agent-sdk/index.d.ts",
+      "import": "./dist/claude-agent-sdk/index.js"
+    },
+    "./openai-agents": {
+      "types": "./dist/openai-agents/index.d.ts",
+      "import": "./dist/openai-agents/index.js"
     }
   },
   "bin": {
@@ -24,7 +48,9 @@
   "files": [
     "dist",
     "README.md",
-    "E2B.md"
+    "E2B.md",
+    "DAYTONA.md",
+    "VERCEL.md"
   ],
   "engines": {
     "node": ">=22"
@@ -34,8 +60,9 @@
     "prepack": "bun run build",
     "check-types": "tsc --noEmit",
     "lint": "eslint",
-    "test": "bun test && bun scripts/test-python.ts",
-    "test:python": "bun scripts/test-python.ts"
+    "test": "bun test && bun scripts/test-python.ts && bun scripts/test-go.ts",
+    "test:python": "bun scripts/test-python.ts",
+    "test:go": "bun scripts/test-go.ts"
   },
   "devDependencies": {
     "@runtime/eslint-config": "workspace:*",
@@ -45,6 +72,7 @@
     "eslint": "^9",
     "typescript": "^5",
     "@openai/agents": "0.18.0",
+    "@openai/agents-core": "0.18.0",
     "@anthropic-ai/claude-agent-sdk": "0.3.277",
     "ai": "7.0.87",
     "zod": "^4.1.8",
@@ -66,5 +94,29 @@
   ],
   "dependencies": {
     "undici": "^7.29.1"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/claude-agent-sdk": ">=0.2.0",
+    "@openai/agents": ">=0.18.0",
+    "@openai/agents-core": ">=0.18.0",
+    "ai": ">=5.0.0",
+    "zod": ">=3.25.0"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    },
+    "@openai/agents": {
+      "optional": true
+    },
+    "@openai/agents-core": {
+      "optional": true
+    },
+    "ai": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
   }
 }