@sandboxrouter/sdk 0.4.0 → 0.6.0

package/dist/server.js

@@ -1,8 +1,11 @@
-import { timingSafeEqual } from "node:crypto";
+import { createHash, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
-import { CATALOG, hourlyCost } from "./catalog.js";
+import { CATALOG } from "./catalog.js";
 import { Router } from "./router.js";
+import { splitComputerRequest } from "./computers.js";
 import { ProviderError, RouterError } from "./types.js";
+import { errorStatus } from "./util.js";
+import { splitRequest } from "./validate.js";
 /**
  * OpenRouter-style HTTP API in front of every provider. One token for your clients; provider keys
  * stay on this host.
@@ -46,6 +49,64 @@ corsOrigins = (process.env.SANDBOXROUTER_CORS ?? "").split(",").map((s) => s.tri
         return got.length === expected.length && timingSafeEqual(got, expected);
     };
     const live = new Map();
+    const computersOn = hooks.computers ?? !hooks.authorize;
+    /**
+     * Idempotency-Key: a create retried with the same key (by the same caller, to the same path) gets the
+     * first create's answer instead of starting another sandbox, for 24 hours. A retry that arrives while
+     * the first is still starting waits for it. The same key with a different body is refused (422).
+     * Failed creates aren't remembered, so retrying one runs it again.
+     */
+    const replays = new Map();
+    const once = async (req, res, body, run) => {
+        const raw = req.headers["idempotency-key"];
+        if (raw === undefined) {
+            const r = await run(false);
+            return json(res, r.status, r.body);
+        }
+        const key = Array.isArray(raw) ? raw[0] : raw;
+        if (!key || key.length > 255)
+            throw new HttpError(400, "Idempotency-Key must be 1 to 255 characters");
+        const now = Date.now();
+        for (const [k, v] of replays)
+            if (now - v.at > IDEMPOTENCY_TTL_MS)
+                replays.delete(k);
+        while (replays.size >= IDEMPOTENCY_MAX)
+            replays.delete(replays.keys().next().value);
+        const scope = sha256(`${req.headers.authorization ?? ""}\n${req.url}\n${key}`);
+        const bodyHash = sha256(JSON.stringify(body ?? {}));
+        const hit = replays.get(scope);
+        if (hit) {
+            if (hit.bodyHash !== bodyHash)
+                throw new HttpError(422, "this Idempotency-Key was already used with a different request");
+            const r = await hit.result;
+            hit.claimed = true;
+            res.setHeader("Idempotent-Replayed", "true");
+            return json(res, r.status, r.body);
+        }
+        const entry = { bodyHash, result: run(true), at: now, claimed: false };
+        replays.set(scope, entry);
+        let r;
+        try {
+            r = await entry.result;
+        }
+        catch (err) {
+            replays.delete(scope);
+            throw err;
+        }
+        // The caller hung up but sent a key, so it means to retry: keep the sandbox for a retry to
+        // collect, and only then give up on it.
+        if (!res.writableEnded && (res.destroyed || !res.writable) && r.discard) {
+            setTimeout(() => {
+                if (!entry.claimed) {
+                    replays.delete(scope);
+                    r.discard().catch(() => { });
+                }
+            }, hooks.orphanGraceMs ?? ORPHAN_GRACE_MS).unref();
+        }
+        else
+            entry.claimed = true;
+        return json(res, r.status, r.body);
+    };
     const cors = (req, res) => {
         const origin = req.headers.origin;
         if (!origin || !(corsOrigins.includes("*") || corsOrigins.includes(origin)))
@@ -91,43 +152,73 @@ corsOrigins = (process.env.SANDBOXROUTER_CORS ?? "").split(",").map((s) => s.tri
         // GET /v1/providers
         if (req.method === "GET" && parts[1] === "providers" && parts.length === 2) {
             return json(res, 200, {
-                providers: CATALOG.filter((c) => router.registered().includes(c.id)).map((c) => ({
-                    ...c,
-                    configured: router.isConfigured(c.id),
-                    estimatedHourlyUsd: hourlyCost(c.id),
-                })),
+                providers: CATALOG.filter((c) => router.registered().includes(c.id)).map((c) => {
+                    const p = router.plan({}, { provider: c.id })[0];
+                    return { ...c, configured: router.isConfigured(c.id), estimatedHourlyUsd: p.estimatedHourlyUsd, listHourlyUsd: p.listHourlyUsd, size: p.size };
+                }),
             });
         }
         // POST /v1/route
         if (req.method === "POST" && parts[1] === "route" && parts.length === 2) {
-            const { spec, route } = splitBody(await readJson(req));
+            const { spec, route } = splitRequest(await readJson(req));
             return json(res, 200, { candidates: router.plan(spec, route) });
         }
         if (parts[1] === "computers") {
-            if (hooks.computers === false)
+            if (!computersOn)
                 return json(res, 404, { error: "computers aren't available on this server" });
-            return computers(req, res, url, parts);
+            return computers(req, res, url, parts, caller);
         }
         if (parts[1] !== "sandboxes")
             return json(res, 404, { error: "not found" });
         // POST /v1/sandboxes
         if (req.method === "POST" && parts.length === 2) {
-            const { spec, route } = splitBody(await readJson(req));
-            await hooks.beforeCreate?.(caller, spec, route);
-            const sbx = await router.create(spec, route);
-            try {
-                await hooks.afterCreate?.(caller, sbx, spec);
-            }
-            catch (err) {
-                await sbx.kill().catch(() => { });
-                throw err;
-            }
-            live.set(sbx.id, sbx);
-            return json(res, 201, {
-                id: sbx.id,
-                provider: sbx.provider,
-                estimatedHourlyUsd: sbx.estimatedHourlyUsd,
-                attempts: sbx.attempts,
+            const body = await readJson(req);
+            const { spec, route } = splitRequest(body);
+            // A caller that gives up (client timeout, closed connection) never learns the id: kill what
+            // starts after that rather than leave it running, and billing, unseen. With an Idempotency-Key
+            // it's kept for a retry instead (see once).
+            let hungUp = false;
+            res.on("close", () => (hungUp = !res.writableFinished));
+            return once(req, res, body, async (keepIfHungUp) => {
+                await hooks.beforeCreate?.(caller, spec, route);
+                let sbx;
+                let extra;
+                try {
+                    sbx = await router.create(spec, route);
+                }
+                catch (err) {
+                    await hooks.createFailed?.(caller);
+                    throw err;
+                }
+                try {
+                    if (hungUp && !keepIfHungUp)
+                        throw new HttpError(499, "the client closed the connection before the sandbox was ready; it was killed");
+                    extra = await hooks.afterCreate?.(caller, sbx, spec);
+                }
+                catch (err) {
+                    await sbx.kill().catch(() => { });
+                    await hooks.createFailed?.(caller);
+                    throw err;
+                }
+                live.set(sbx.id, sbx);
+                const made = sbx;
+                return {
+                    status: 201,
+                    body: {
+                        id: sbx.id,
+                        provider: sbx.provider,
+                        size: sbx.size,
+                        estimatedHourlyUsd: sbx.estimatedHourlyUsd,
+                        listHourlyUsd: sbx.listHourlyUsd,
+                        attempts: sbx.attempts,
+                        ...(extra ?? {}),
+                    },
+                    discard: async () => {
+                        live.delete(made.id);
+                        await made.kill().catch(() => { });
+                        await hooks.afterKill?.(caller, made.id);
+                    },
+                };
             });
         }
         const id = parts[2] ? decodeURIComponent(parts[2]) : "";
@@ -149,7 +240,8 @@ corsOrigins = (process.env.SANDBOXROUTER_CORS ?? "").split(",").map((s) => s.tri
                 emit("result", r);
             }
             catch (err) {
-                emit("error", { error: err.message });
+                const e = describeError(err);
+                emit("error", { ...e.body, status: e.status });
             }
             return res.end();
         }
@@ -179,28 +271,67 @@ corsOrigins = (process.env.SANDBOXROUTER_CORS ?? "").split(",").map((s) => s.tri
         }
         // DELETE /v1/sandboxes/:id
         if (req.method === "DELETE" && parts.length === 3) {
-            await (await box(id)).kill();
+            try {
+                await (await box(id)).kill();
+            }
+            catch (err) {
+                // Already gone at the provider: that's what the caller wanted.
+                if (!(err instanceof HttpError) && errorStatus(err) === 404) {
+                    live.delete(id);
+                    await hooks.afterKill?.(caller, id);
+                    return json(res, 200, { id, killed: true });
+                }
+                if (!(err instanceof HttpError))
+                    await hooks.afterKill?.(caller, id, { error: err });
+                throw err;
+            }
             live.delete(id);
             await hooks.afterKill?.(caller, id);
             return json(res, 200, { id, killed: true });
         }
         return json(res, 404, { error: "not found" });
     };
-    const computers = async (req, res, url, parts) => {
+    const computers = async (req, res, url, parts, caller) => {
         if (req.method === "POST" && parts.length === 2) {
-            const { provider, ...spec } = await readJson(req);
-            const c = await router.computer(spec, { provider });
-            return json(res, 201, { ...(await c.info()), id: c.id, nativeId: c.nativeId, provider: c.provider });
+            const body = await readJson(req);
+            const { spec, route } = splitComputerRequest(body);
+            return once(req, res, body, async () => {
+                await hooks.beforeCreateComputer?.(caller, spec);
+                const c = await router.computer(spec, route);
+                let extra;
+                try {
+                    extra = await hooks.afterCreateComputer?.(caller, c);
+                }
+                catch (err) {
+                    await c.delete().catch(() => { });
+                    throw err;
+                }
+                return {
+                    status: 201,
+                    body: { ...(await c.info()), id: c.id, nativeId: c.nativeId, provider: c.provider, estimatedHourlyUsd: c.estimatedHourlyUsd, attempts: c.attempts, ...(extra ?? {}) },
+                };
+            });
         }
         const id = parts[2] ? decodeURIComponent(parts[2]) : "";
         if (!id)
             return json(res, 404, { error: "not found" });
+        if (hooks.owns && !(await hooks.owns(caller, id)))
+            throw new HttpError(404, "no such computer");
         const c = await router.getComputer(id);
         const sub = parts[3];
         if (req.method === "GET" && !sub)
             return json(res, 200, { ...(await c.info()), id, nativeId: c.nativeId });
         if (req.method === "DELETE" && !sub) {
-            await c.delete();
+            try {
+                await c.delete();
+            }
+            catch (err) {
+                if (errorStatus(err) !== 404) {
+                    await hooks.afterDeleteComputer?.(caller, id, { error: err });
+                    throw err;
+                }
+            }
+            await hooks.afterDeleteComputer?.(caller, id);
             return json(res, 200, { id, deleted: true });
         }
         if (req.method === "POST" && sub === "actions") {
@@ -245,11 +376,11 @@ corsOrigins = (process.env.SANDBOXROUTER_CORS ?? "").split(",").map((s) => s.tri
     };
     return createServer((req, res) => {
         handle(req, res).catch((err) => {
-            const status = err instanceof HttpError ? err.status
-                : err instanceof RouterError ? 502
-                    : err instanceof ProviderError && err.status ? err.status
-                        : 500;
-            json(res, status, { error: err.message, attempts: err.attempts });
+            // A closed connection can't be answered.
+            if (res.writableEnded || res.destroyed)
+                return;
+            const e = describeError(err);
+            json(res, e.status, e.body);
         });
     });
 }
@@ -260,19 +391,33 @@ export class HttpError extends Error {
         this.status = status;
     }
 }
-const ROUTE_KEYS = ["provider", "strategy", "fallback", "require", "createTimeoutSeconds"];
-function splitBody(body) {
-    const route = {};
-    const spec = {};
-    for (const [k, v] of Object.entries(body))
-        (ROUTE_KEYS.includes(k) ? route : spec)[k] = v;
-    // A provider id the catalog does not know is the client's mistake, not a routing failure.
-    const ids = route.provider === undefined ? [] : [].concat(route.provider);
-    const unknown = ids.filter((id) => !CATALOG.some((c) => c.id === id));
-    if (unknown.length)
-        throw new HttpError(400, `unknown provider: ${unknown.join(", ")}`);
-    return { spec: spec, route: route };
+/**
+ * The HTTP status and JSON body for an error: `{ error, code?, attempts? }`. RouterErrors carry a code
+ * (see RouterErrorCode) that maps to one status; a ProviderError with an HTTP status passes it on.
+ */
+function describeError(err) {
+    const status = err instanceof HttpError ? err.status
+        : err instanceof RouterError ? ERROR_STATUS[err.code]
+            : err instanceof ProviderError && err.status ? err.status
+                : 500;
+    const code = err instanceof RouterError ? err.code : undefined;
+    return { status, body: { error: err?.message ?? String(err), ...(code ? { code } : {}), ...(err?.attempts?.length ? { attempts: err.attempts } : {}) } };
 }
+/** How long an Idempotency-Key is remembered, and how many at most. */
+const IDEMPOTENCY_TTL_MS = 24 * 3600_000;
+const IDEMPOTENCY_MAX = 10_000;
+/** How long a sandbox whose caller hung up (with an Idempotency-Key) waits for a retry to collect it. */
+export const ORPHAN_GRACE_MS = 120_000;
+const sha256 = (s) => createHash("sha256").update(s).digest("hex");
+/** The HTTP status for each RouterError code (see RouterErrorCode). */
+export const ERROR_STATUS = {
+    bad_request: 400,
+    unsupported: 400,
+    no_provider: 422,
+    setup: 502,
+    all_failed: 503,
+    timeout: 504,
+};
 const MAX_BODY = 100 * 1024 * 1024;
 async function readRaw(req) {
     const chunks = [];

package/dist/types.d.ts

@@ -3,9 +3,14 @@ export type ProviderId = "maritime" | "e2b" | "daytona" | "modal" | "vercel" | "
 export type Capability = "gpu" | "pause" | "custom-image";
 /** What the caller wants. Every field is optional; providers map it to their own knobs. */
 export interface SandboxSpec {
-    /** vCPUs (default 2). */
+    /**
+     * vCPUs. Leave vcpu and memoryGb out to take any provider at the size it starts by default: most give
+     * 2 vCPU / 4 GB, but some only run a fixed, smaller image (E2B 2 vCPU / 0.5 GB, Daytona 1 / 1). Set
+     * either one and only providers that can give that size are tried. `Candidate.size` and
+     * `RoutedSandbox.size` say what you get.
+     */
     vcpu?: number;
-    /** Memory in GB (default 4). */
+    /** Memory in GB. See `vcpu`. */
     memoryGb?: number;
     /** GPU type, e.g. "T4", "A100". Only providers with the "gpu" capability accept it. */
     gpu?: string;
@@ -37,6 +42,12 @@ export interface RouteOptions {
     provider?: ProviderId | ProviderId[];
     /** How to order candidates when no explicit list is given. Default: "balanced" (cheapest real cost, speed breaks near-ties). */
     strategy?: Strategy;
+    /**
+     * Seconds the whole create may take, over every provider it tries (default 240, under the 300 s an
+     * HTTP client usually waits). When it runs out, create stops trying and throws a RouterError with
+     * code "timeout"; a provider still starting is killed when it answers.
+     */
+    deadlineSeconds?: number;
     /**
      * What to do when a create fails. `true` (default): try the next candidate when the provider
      * looks unavailable (timeout, network error, 429, 5xx, or an error without a status) or can't bill
@@ -85,16 +96,29 @@ export interface Provider {
     connect(nativeId: string): Promise<ProviderSandbox>;
 }
 export interface Attempt {
-    provider: ProviderId;
+    /** A sandbox provider, or a computer provider (some sell only computers). */
+    provider: ProviderId | (string & {});
     ok: boolean;
     ms: number;
     error?: string;
     /** HTTP status of the failure, when the provider gave one (402: the account can't pay). */
     status?: number;
 }
+/**
+ * Why the router couldn't do what was asked. Each maps to one HTTP status in the server.
+ * - bad_request (400): an invalid spec, route option or sandbox id
+ * - unsupported (400): the sandbox's provider can't do this (e.g. pause)
+ * - no_provider (422): no provider you have keys for can take this sandbox (`plan()` says why for each)
+ * - setup (502): a provider refused the request or the key (400/401/403/404/422 from it); fix the key,
+ *   image or request rather than retrying
+ * - all_failed (503): every provider tried was down, busy or out of credit; retrying later can work
+ * - timeout (504): the create ran out of `deadlineSeconds`
+ */
+export type RouterErrorCode = "bad_request" | "unsupported" | "no_provider" | "setup" | "all_failed" | "timeout";
 export declare class RouterError extends Error {
     readonly attempts: Attempt[];
-    constructor(message: string, attempts?: Attempt[]);
+    readonly code: RouterErrorCode;
+    constructor(message: string, attempts?: Attempt[], code?: RouterErrorCode);
 }
 /** Thrown by adapters for HTTP failures so the router can report status codes. */
 export declare class ProviderError extends Error {

package/dist/types.js

@@ -1,8 +1,10 @@
 export class RouterError extends Error {
     attempts;
-    constructor(message, attempts = []) {
+    code;
+    constructor(message, attempts = [], code = "all_failed") {
         super(message);
         this.attempts = attempts;
+        this.code = code;
         this.name = "RouterError";
     }
 }

package/dist/util.d.ts

@@ -43,3 +43,11 @@ export declare function optionalImport<T>(pkg: string, provider: string): Promis
  * (E2B's AuthenticationError, AWS's CredentialsProviderError). Undefined when there's none.
  */
 export declare function errorStatus(err: unknown, depth?: number): number | undefined;
+/**
+ * HTTP statuses that mean the request or the key is wrong, not that the provider is down. 402 (out of
+ * balance, plan needed) isn't one: an unfunded account is exactly when the next provider should take the
+ * sandbox, and the failed attempt stays on `attempts` (the CLI prints it), so it isn't hidden.
+ */
+export declare const SETUP_ERRORS: Set<number>;
+/** Resolve with `work`, or reject with `onExpire()` after `ms`. A late `work` rejection is swallowed. */
+export declare function withDeadline<T>(work: Promise<T>, ms: number, onExpire: () => Error): Promise<T>;

package/dist/util.js

@@ -28,7 +28,8 @@ export function wrapCommand(cmd, opts = {}) {
 }
 /** The one error every adapter throws when a command outlives ExecOptions.timeoutSeconds. */
 export function timeoutError(provider, seconds) {
-    return new ProviderError(provider, `command timed out after ${seconds}s`);
+    // 504 for the HTTP API: the command ran out of time, not the server.
+    return new ProviderError(provider, `command timed out after ${seconds}s`, 504);
 }
 /**
  * True when an exit code is the one left behind by a timeout kill and the command really ran
@@ -110,3 +111,24 @@ export function errorStatus(err, depth = 0) {
         return 429;
     return errorStatus(e.cause, depth + 1);
 }
+/**
+ * HTTP statuses that mean the request or the key is wrong, not that the provider is down. 402 (out of
+ * balance, plan needed) isn't one: an unfunded account is exactly when the next provider should take the
+ * sandbox, and the failed attempt stays on `attempts` (the CLI prints it), so it isn't hidden.
+ */
+export const SETUP_ERRORS = new Set([400, 401, 403, 404, 422]);
+/** Resolve with `work`, or reject with `onExpire()` after `ms`. A late `work` rejection is swallowed. */
+export async function withDeadline(work, ms, onExpire) {
+    let timer;
+    const expired = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(onExpire()), ms);
+        timer.unref();
+    });
+    try {
+        return await Promise.race([work, expired]);
+    }
+    finally {
+        clearTimeout(timer);
+        work.catch(() => { });
+    }
+}

package/dist/validate.d.ts

@@ -0,0 +1,17 @@
+import { type RouteOptions, type SandboxSpec, type Strategy } from "./types.js";
+/** Every key a SandboxSpec can have. Anything else in a request is a mistake (e.g. "memory" for "memoryGb"). */
+export declare const SPEC_KEYS: readonly ["vcpu", "memoryGb", "gpu", "env", "timeoutMinutes", "image", "metadata"];
+/** Every key RouteOptions can have. */
+export declare const ROUTE_KEYS: readonly ["provider", "strategy", "fallback", "require", "createTimeoutSeconds", "deadlineSeconds"];
+export declare const STRATEGIES: readonly Strategy[];
+/**
+ * Throws RouterError("bad_request") for a spec or route a provider couldn't make sense of: sizes and
+ * times that aren't positive numbers, an unknown strategy or fallback, maps that aren't string maps.
+ * Called by `plan()`, so every create, route and CLI command goes through it.
+ */
+export declare function validate(spec?: SandboxSpec, route?: RouteOptions): void;
+/** Split a flat request body into spec and route options, refusing keys that are neither. */
+export declare function splitRequest(body: Record<string, unknown>): {
+    spec: SandboxSpec;
+    route: RouteOptions;
+};

package/dist/validate.js

@@ -0,0 +1,66 @@
+import { CATALOG } from "./catalog.js";
+import { RouterError } from "./types.js";
+/** Every key a SandboxSpec can have. Anything else in a request is a mistake (e.g. "memory" for "memoryGb"). */
+export const SPEC_KEYS = ["vcpu", "memoryGb", "gpu", "env", "timeoutMinutes", "image", "metadata"];
+/** Every key RouteOptions can have. */
+export const ROUTE_KEYS = ["provider", "strategy", "fallback", "require", "createTimeoutSeconds", "deadlineSeconds"];
+export const STRATEGIES = ["default", "balanced", "verified", "cheapest", "fastest"];
+const bad = (msg) => new RouterError(msg, [], "bad_request");
+const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+/** How a bad value is shown: numbers as-is (NaN, Infinity), anything else as JSON. */
+const show = (v) => (typeof v === "number" ? String(v) : JSON.stringify(v));
+const stringMap = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((x) => typeof x === "string");
+/**
+ * Throws RouterError("bad_request") for a spec or route a provider couldn't make sense of: sizes and
+ * times that aren't positive numbers, an unknown strategy or fallback, maps that aren't string maps.
+ * Called by `plan()`, so every create, route and CLI command goes through it.
+ */
+export function validate(spec = {}, route = {}) {
+    for (const k of ["vcpu", "memoryGb", "timeoutMinutes"]) {
+        if (spec[k] !== undefined && !positive(spec[k]))
+            throw bad(`${k} must be a positive number, got ${show(spec[k])}`);
+    }
+    if (spec.gpu !== undefined && (typeof spec.gpu !== "string" || !spec.gpu))
+        throw bad(`gpu must be a GPU type such as "T4", got ${JSON.stringify(spec.gpu)}`);
+    for (const k of ["env", "image", "metadata"]) {
+        if (spec[k] !== undefined && !stringMap(spec[k]))
+            throw bad(`${k} must be an object of strings`);
+    }
+    if (route.strategy !== undefined && !STRATEGIES.includes(route.strategy)) {
+        throw bad(`unknown strategy ${JSON.stringify(route.strategy)}: use one of ${STRATEGIES.filter((s) => s !== "default").join(", ")}`);
+    }
+    if (route.fallback !== undefined && route.fallback !== true && route.fallback !== false && route.fallback !== "any") {
+        throw bad(`fallback must be true, false or "any", got ${JSON.stringify(route.fallback)}`);
+    }
+    for (const k of ["createTimeoutSeconds", "deadlineSeconds"]) {
+        if (route[k] !== undefined && !positive(route[k]))
+            throw bad(`${k} must be a positive number, got ${show(route[k])}`);
+    }
+    if (route.require !== undefined && (!Array.isArray(route.require) || !route.require.every((r) => typeof r === "string"))) {
+        throw bad("require must be a list of capabilities, e.g. [\"pause\"]");
+    }
+    if (route.provider !== undefined) {
+        const ids = [].concat(route.provider);
+        const unknown = ids.filter((id) => typeof id !== "string" || !CATALOG.some((c) => c.id === id));
+        if (unknown.length || ids.length === 0)
+            throw bad(`unknown provider: ${unknown.map((u) => JSON.stringify(u)).join(", ") || "(empty list)"}`);
+    }
+}
+/** Split a flat request body into spec and route options, refusing keys that are neither. */
+export function splitRequest(body) {
+    const spec = {};
+    const route = {};
+    const unknown = [];
+    for (const [k, v] of Object.entries(body ?? {})) {
+        if (ROUTE_KEYS.includes(k))
+            route[k] = v;
+        else if (SPEC_KEYS.includes(k))
+            spec[k] = v;
+        else
+            unknown.push(k);
+    }
+    if (unknown.length)
+        throw bad(`unknown field${unknown.length > 1 ? "s" : ""} ${unknown.join(", ")}: a sandbox takes ${SPEC_KEYS.join(", ")}; routing takes ${ROUTE_KEYS.join(", ")}`);
+    validate(spec, route);
+    return { spec: spec, route: route };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sandboxrouter/sdk",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "One API for every sandbox provider: route AI agents' code by price, speed or capability, with automatic fallback. Free and open source.",
   "type": "module",
   "main": "dist/index.js",