@blaxel/core 0.2.85-preview.159 → 0.2.86-dev.162

package/dist/esm/client/sdk.gen.js

@@ -2,7 +2,7 @@
 import { client as _heyApiClient } from "./client.gen.js";
 /**
  * List all agents
- * Returns all AI agents deployed in the workspace. Each agent includes its deployment status, runtime configuration, and global inference endpoint URL.
+ * Returns AI agents deployed in the workspace. Each agent includes its deployment status, runtime configuration, and global inference endpoint URL. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array with all agents.
  */
 export const listAgents = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -221,7 +221,7 @@ export const verifyCustomDomain = (options) => {
 };
 /**
  * List drives
- * Returns all drives in the workspace. Drives provide persistent storage that can be attached to agents, functions, and sandboxes.
+ * Returns all drives in the workspace. Drives provide persistent storage that can be attached to agents, functions, and sandboxes. Starting with API version 2026-04-28, the response wraps items in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array with all drives.
  */
 export const listDrives = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -348,6 +348,22 @@ export const listAllEgressGateways = (options) => {
         ...options
     });
 };
+/**
+ * Egress gateway sandbox attachments
+ * Returns the inverse map (gateway → sandbox names) for the workspace. Used by the egress-IPs UI to render attachment counts without fetching the sandboxes listing full client-side.
+ */
+export const getEgressGatewayUsage = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/egressgateways/usage',
+        ...options
+    });
+};
 /**
  * List all egress IPs across all VPCs and gateways in the workspace
  */
@@ -397,7 +413,7 @@ export const testFeatureFlag = (options) => {
 };
 /**
  * List all MCP servers
- * Returns all MCP server functions deployed in the workspace. Each function includes its deployment status, transport protocol (websocket or http-stream), and endpoint URL.
+ * Returns MCP server functions deployed in the workspace. Each function includes its deployment status, transport protocol (websocket or http-stream), and endpoint URL. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array with all functions.
  */
 export const listFunctions = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -805,7 +821,7 @@ export const getIntegrationConnectionModel = (options) => {
 };
 /**
  * List batch jobs
- * Returns all batch job definitions in the workspace. Each job can be triggered to run multiple parallel tasks with configurable concurrency and retry settings.
+ * Returns batch job definitions in the workspace. Each job can be triggered to run multiple parallel tasks with configurable concurrency and retry settings. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array with all jobs.
  */
 export const listJobs = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -893,7 +909,7 @@ export const updateJob = (options) => {
 };
 /**
  * List job executions
- * Returns paginated list of executions for a batch job, sorted by creation time. Each execution contains status, task counts, and timing information.
+ * Returns executions for a batch job. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep the legacy offset/limit contract and return a bare array.
  */
 export const listJobExecutions = (options) => {
     return (options.client ?? _heyApiClient).get({
@@ -959,6 +975,22 @@ export const getJobExecution = (options) => {
         ...options
     });
 };
+/**
+ * List execution tasks
+ * Returns one cursor-paginated page of an execution's tasks. Tasks are derived from event history each request; only the in-memory slicing is paginated, the events scan still fetches the whole event log behind the scenes. Available starting with API version 2026-04-28.
+ */
+export const listJobExecutionTasks = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/jobs/{jobId}/executions/{executionId}/tasks',
+        ...options
+    });
+};
 /**
  * List job revisions
  * Returns revisions for a job by name.
@@ -1009,7 +1041,7 @@ export const listMcpHubDefinitions = (options) => {
 };
 /**
  * List model endpoints
- * Returns all model gateway endpoints configured in the workspace. Each model represents a proxy to an external LLM provider (OpenAI, Anthropic, etc.) with unified access control.
+ * Returns model gateway endpoints configured in the workspace. Each model represents a proxy to an external LLM provider (OpenAI, Anthropic, etc.) with unified access control. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array with all models.
  */
 export const listModels = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -1161,7 +1193,7 @@ export const declineImageShare = (options) => {
 };
 /**
  * List governance policies
- * Returns all governance policies in the workspace. Policies control deployment locations, hardware flavors, and token limits for agents, functions, and models.
+ * Returns governance policies in the workspace. Policies control deployment locations, hardware flavors, and token limits for agents, functions, and models. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array with all policies.
  */
 export const listPolicies = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -1247,6 +1279,22 @@ export const updatePolicy = (options) => {
         }
     });
 };
+/**
+ * List resources using a policy
+ * Returns the names of every resource (agent, function, model, sandbox, job) currently referencing the given policy. Replaces the client-side fan-out the policies UI used to do over the listings.
+ */
+export const getPolicyUsages = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/policies/{policyName}/usages',
+        ...options
+    });
+};
 /**
  * List public ips
  * Returns a list of all public ips used in Blaxel..
@@ -1281,7 +1329,7 @@ export const listSandboxHubDefinitions = (options) => {
 };
 /**
  * List sandboxes
- * Returns all sandboxes in the workspace. Each sandbox includes its configuration, status, and endpoint URL.
+ * Returns sandboxes in the workspace. Each sandbox includes its configuration, status, and endpoint URL. Terminated sandboxes are hidden by default; pass `showTerminated=true` to include them. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array of all sandboxes.
  */
 export const listSandboxes = (options) => {
     return (options?.client ?? _heyApiClient).get({
@@ -1841,7 +1889,7 @@ export const deleteVolumeTemplateVersion = (options) => {
 };
 /**
  * List persistent volumes
- * Returns all persistent storage volumes in the workspace. Volumes can be attached to sandboxes for durable file storage that persists across sessions and sandbox deletions.
+ * Returns persistent storage volumes in the workspace. Volumes can be attached to sandboxes for durable file storage that persists across sessions and sandbox deletions. Starting with API version 2026-04-28 the response is wrapped in `{data, meta}` and supports cursor pagination via the `cursor` and `limit` query parameters; older versions keep returning a bare array of volumes.
  */
 export const listVolumes = (options) => {
     return (options?.client ?? _heyApiClient).get({

package/dist/esm/common/h2fetch.js

@@ -1,6 +1,74 @@
+import { settings } from "./settings.js";
 import { refH2SessionForActiveRequest } from "./h2ref.js";
 const MIN_H2_SESSION_MAX_LISTENERS = 64;
 const sessionsWithListenerBudget = new WeakSet();
+/**
+ * Per-domain async semaphore that bounds the number of in-flight HTTP/2
+ * requests against a single edge domain (one H2 session). The cap is keyed
+ * by domain so throttling one sandbox's uploads never blocks requests to an
+ * unrelated sandbox served by a different edge.
+ *
+ * When `settings.maxConcurrentH2Requests` is `0`/unset the gate is a no-op
+ * (current default behavior: unlimited concurrency).
+ */
+// Safety timeout for a held slot. A request that never resolves (no response,
+// no error, no abort) would otherwise hold its slot forever and starve every
+// queued request for the same domain. After this window we release the slot
+// and let the underlying request continue or reject on its own; we never
+// cancel the in-flight request here, we only stop it from blocking the queue.
+// Kept deliberately conservative (well above any realistic part-upload time)
+// so it does not interfere with legitimately slow but healthy requests.
+const H2_SLOT_TIMEOUT_MS = 120_000;
+const h2GatesByDomain = new Map();
+function getH2Gate(domain) {
+    let gate = h2GatesByDomain.get(domain);
+    if (!gate) {
+        gate = { active: 0, queue: [] };
+        h2GatesByDomain.set(domain, gate);
+    }
+    return gate;
+}
+/**
+ * Acquire an in-flight slot for `domain`. Resolves with a release function
+ * that is idempotent and FIFO-fair: releasing wakes the longest-waiting
+ * queued caller for the same domain. A safety timer also releases the slot
+ * if the caller never does, preventing per-domain starvation.
+ */
+async function acquireH2Slot(domain) {
+    const max = settings.maxConcurrentH2Requests; // 0/undefined = unlimited
+    if (!max || max <= 0)
+        return () => { };
+    const gate = getH2Gate(domain);
+    while (gate.active >= max) {
+        await new Promise((resolve) => gate.queue.push(resolve));
+    }
+    gate.active++;
+    let released = false;
+    // Holder so `release` can clear the safety timer that is created after it.
+    const timer = {};
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        if (timer.handle !== undefined)
+            clearTimeout(timer.handle);
+        gate.active--;
+        const next = gate.queue.shift();
+        if (next) {
+            next();
+        }
+        else if (gate.active === 0 && gate.queue.length === 0) {
+            // No active requests and nothing waiting: drop the empty gate so the
+            // Map does not grow unbounded across many short-lived domains.
+            h2GatesByDomain.delete(domain);
+        }
+    };
+    timer.handle = setTimeout(release, H2_SLOT_TIMEOUT_MS);
+    // unref() so a pending safety timer never keeps the process alive. Guarded
+    // because not every runtime's timer handle exposes unref().
+    timer.handle.unref?.();
+    return release;
+}
 /**
  * Creates a fetch()-compatible function that sends requests over an existing
  * HTTP/2 session. Falls back to globalThis.fetch() only when the session is
@@ -26,11 +94,40 @@ export function createH2Fetch(session) {
  */
 export function createPoolBackedH2Fetch(pool, domain) {
     return async (input) => {
+        const rel = await acquireH2Slot(domain);
+        try {
+            const session = await pool.get(domain);
+            if (session) {
+                let h2RequestCreated = false;
+                try {
+                    return await _h2Request(session, input, {
+                        onH2RequestCreated: () => {
+                            h2RequestCreated = true;
+                        },
+                    });
+                }
+                catch (err) {
+                    if (h2RequestCreated) {
+                        pool.evictSession(domain, session);
+                    }
+                    throw err;
+                }
+            }
+            return await globalThis.fetch(input);
+        }
+        finally {
+            rel();
+        }
+    };
+}
+export async function h2RequestDirectFromPool(pool, domain, url, init) {
+    const rel = await acquireH2Slot(domain);
+    try {
         const session = await pool.get(domain);
         if (session) {
             let h2RequestCreated = false;
             try {
-                return await _h2Request(session, input, {
+                return await h2RequestDirectInternal(session, url, init, {
                     onH2RequestCreated: () => {
                         h2RequestCreated = true;
                     },
@@ -43,28 +140,11 @@ export function createPoolBackedH2Fetch(pool, domain) {
                 throw err;
             }
         }
-        return globalThis.fetch(input);
-    };
-}
-export async function h2RequestDirectFromPool(pool, domain, url, init) {
-    const session = await pool.get(domain);
-    if (session) {
-        let h2RequestCreated = false;
-        try {
-            return await h2RequestDirectInternal(session, url, init, {
-                onH2RequestCreated: () => {
-                    h2RequestCreated = true;
-                },
-            });
-        }
-        catch (err) {
-            if (h2RequestCreated) {
-                pool.evictSession(domain, session);
-            }
-            throw err;
-        }
+        return await globalThis.fetch(url, init);
+    }
+    finally {
+        rel();
     }
-    return globalThis.fetch(url, init);
 }
 /**
  * Low-level H2 request that takes raw URL + init, skipping Request construction.

package/dist/esm/common/pagination.js

@@ -0,0 +1,83 @@
+export function unwrapListData(response) {
+    if (!response) {
+        return [];
+    }
+    if (Array.isArray(response)) {
+        return response;
+    }
+    return response.data ?? [];
+}
+function unwrapListMeta(response) {
+    if (!response || Array.isArray(response)) {
+        return { hasMore: false };
+    }
+    return response.meta ?? { hasMore: false };
+}
+export async function createPaginatedList({ response, fetchPage, mapItem, query, seenCursors, }) {
+    const meta = unwrapListMeta(response);
+    const data = await Promise.all(unwrapListData(response).map(mapItem));
+    const cursors = new Set(seenCursors);
+    if (query?.cursor) {
+        cursors.add(query.cursor);
+    }
+    const list = {
+        data,
+        meta,
+        get hasMore() {
+            return Boolean(meta.hasMore);
+        },
+        get nextCursor() {
+            return meta.nextCursor || undefined;
+        },
+        async nextPage() {
+            const cursor = list.nextCursor;
+            if (!cursor) {
+                return null;
+            }
+            if (cursors.has(cursor)) {
+                throw new Error("Pagination returned a repeated cursor");
+            }
+            const nextQuery = { ...(query ?? {}), cursor };
+            const nextSeenCursors = new Set(cursors);
+            nextSeenCursors.add(cursor);
+            return createPaginatedList({
+                response: await fetchPage(nextQuery),
+                fetchPage,
+                mapItem,
+                query: nextQuery,
+                seenCursors: nextSeenCursors,
+            });
+        },
+        async autoPagingEach(onItem) {
+            for await (const item of list) {
+                const shouldContinue = await onItem(item);
+                if (shouldContinue === false) {
+                    return;
+                }
+            }
+        },
+        async autoPagingToArray(options) {
+            if (!options || !Number.isFinite(options.limit) || options.limit <= 0) {
+                throw new Error("autoPagingToArray requires a positive limit");
+            }
+            const items = [];
+            for await (const item of list) {
+                items.push(item);
+                if (items.length >= options.limit) {
+                    return items;
+                }
+            }
+            return items;
+        },
+        async *[Symbol.asyncIterator]() {
+            let page = list;
+            while (page) {
+                for (const item of page.data) {
+                    yield item;
+                }
+                page = await page.nextPage();
+            }
+        },
+    };
+    return list;
+}

package/dist/esm/common/pagination.test.js

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { createPaginatedList, unwrapListData } from "./pagination.js";
+describe("pagination helpers", () => {
+    it("unwraps legacy array and paginated list responses", () => {
+        expect(unwrapListData([{ name: "legacy" }])).toEqual([{ name: "legacy" }]);
+        expect(unwrapListData({
+            data: [{ name: "paginated" }],
+            meta: { hasMore: false },
+        })).toEqual([{ name: "paginated" }]);
+    });
+    it("returns page data and lets callers request the next page", async () => {
+        const cursors = [];
+        const fetchPage = async (query) => {
+            await Promise.resolve();
+            cursors.push(query?.cursor);
+            if (!query?.cursor) {
+                return {
+                    data: ["first"],
+                    meta: { hasMore: true, nextCursor: "next-page" },
+                };
+            }
+            return {
+                data: ["second"],
+                meta: { hasMore: false },
+            };
+        };
+        const page = await createPaginatedList({
+            response: await fetchPage(),
+            fetchPage,
+            mapItem: (item) => item.toUpperCase(),
+        });
+        expect(page.data).toEqual(["FIRST"]);
+        expect(page.hasMore).toBe(true);
+        expect(page.nextCursor).toBe("next-page");
+        const nextPage = await page.nextPage();
+        expect(nextPage?.data).toEqual(["SECOND"]);
+        expect(cursors).toEqual([undefined, "next-page"]);
+    });
+    it("supports auto paging with an explicit limit", async () => {
+        const fetchPage = async (query) => {
+            await Promise.resolve();
+            if (!query?.cursor) {
+                return {
+                    data: ["first"],
+                    meta: { hasMore: true, nextCursor: "next-page" },
+                };
+            }
+            return {
+                data: ["second"],
+                meta: { hasMore: false },
+            };
+        };
+        const page = await createPaginatedList({
+            response: await fetchPage(),
+            fetchPage,
+            mapItem: (item) => item,
+        });
+        await expect(page.autoPagingToArray({ limit: 2 })).resolves.toEqual(["first", "second"]);
+    });
+});

package/dist/esm/common/settings.js

@@ -5,10 +5,10 @@ import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
 import { fs, os, path } from "../common/node.js";
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.85-preview.159";
-const BUILD_COMMIT = "a9c088b49239125f1b129fbc95d1887556112a33";
+const BUILD_VERSION = "0.2.86-dev.162";
+const BUILD_COMMIT = "67e269718e3381ddd43832b1def2532c2b218e61";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
-const BLAXEL_API_VERSION = "2026-04-16";
+const BLAXEL_API_VERSION = "2026-04-28";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;
 let configTrackingLoaded = false;
@@ -226,6 +226,32 @@ class Settings {
         }
         return isDenoRuntime();
     }
+    get maxConcurrentH2Requests() {
+        if (typeof this.config.maxConcurrentH2Requests === "number") {
+            return this.config.maxConcurrentH2Requests;
+        }
+        const value = env.BL_MAX_H2_INFLIGHT;
+        if (value) {
+            const parsed = parseInt(value, 10);
+            if (!Number.isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        return 0;
+    }
+    get fsPartRetries() {
+        if (typeof this.config.fsPartRetries === "number") {
+            return this.config.fsPartRetries;
+        }
+        const value = env.BL_FS_PART_RETRIES;
+        if (value) {
+            const parsed = parseInt(value, 10);
+            if (!Number.isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        return 0;
+    }
     async authenticate() {
         await this.credentials.authenticate();
     }

package/dist/esm/common/settings.test.js

@@ -7,14 +7,14 @@ describe('Settings.apiVersion', () => {
     afterEach(() => {
         delete env.BL_API_VERSION;
     });
-    it('defaults to 2026-04-16 when BL_API_VERSION is not set', async () => {
+    it('defaults to 2026-04-28 when BL_API_VERSION is not set', async () => {
         delete env.BL_API_VERSION;
         const { settings } = await import('./settings.js');
-        expect(settings.apiVersion).toBe('2026-04-16');
+        expect(settings.apiVersion).toBe('2026-04-28');
     });
     it('headers include Blaxel-Version set to the default', async () => {
         delete env.BL_API_VERSION;
         const { settings } = await import('./settings.js');
-        expect(settings.headers['Blaxel-Version']).toBe('2026-04-16');
+        expect(settings.headers['Blaxel-Version']).toBe('2026-04-28');
     });
 });

package/dist/esm/drive/index.js

@@ -1,5 +1,6 @@
 import { v4 as uuidv4 } from "uuid";
 import { createDrive, deleteDrive, getDrive, listDrives, updateDrive } from "../client/index.js";
+import { createPaginatedList } from "../common/pagination.js";
 import { settings } from "../common/settings.js";
 export class DriveInstance {
     drive;
@@ -83,9 +84,44 @@ export class DriveInstance {
         });
         return new DriveInstance(data);
     }
-    static async list() {
-        const { data } = await listDrives({ throwOnError: true });
-        return data.map((drive) => new DriveInstance(drive));
+    /**
+     * List one page of drives.
+     *
+     * The returned page exposes `data` for the current page, `meta` for cursor
+     * metadata, and helpers to fetch more pages only when you need them.
+     *
+     * @example
+     * ```ts
+     * const page = await DriveInstance.list({ limit: 50 });
+     *
+     * for (const drive of page.data) {
+     *   console.log(drive.name);
+     * }
+     *
+     * const nextPage = await page.nextPage();
+     * ```
+     *
+     * @example
+     * ```ts
+     * const allDrives = await (await DriveInstance.list()).autoPagingToArray({
+     *   limit: 1000,
+     * });
+     * ```
+     */
+    static async list(query) {
+        const fetchPage = async (pageQuery) => {
+            const { data } = await listDrives({
+                query: pageQuery,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return createPaginatedList({
+            response: await fetchPage(query),
+            fetchPage,
+            mapItem: (drive) => new DriveInstance(drive),
+            query,
+        });
     }
     static async delete(driveName) {
         const { data } = await deleteDrive({

package/dist/esm/index.js

@@ -7,6 +7,7 @@ export * from "./common/node.js";
 export * from "./common/errors.js";
 export * from "./common/internal.js";
 export * from "./common/logger.js";
+export * from "./common/pagination.js";
 export * from "./common/settings.js";
 export * from "./common/webhook.js";
 export * from "./drive/index.js";

package/dist/esm/jobs/jobs.js

@@ -1,5 +1,6 @@
 import { createJobExecution, deleteJobExecution, getJobExecution, listJobExecutions, } from "../client/index.js";
 import { logger } from "../common/logger.js";
+import { createPaginatedList } from "../common/pagination.js";
 import { settings } from "../common/settings.js";
 import { startSpan } from "../telemetry/telemetry.js";
 class BlJob {
@@ -75,18 +76,50 @@ class BlJob {
         return data;
     }
     /**
-     * List all executions for this job
+     * List one page of executions for this job.
+     *
+     * The returned page exposes `data` for the current page, `meta` for cursor
+     * metadata, and helpers to fetch more pages only when you need them.
+     *
+     * @example
+     * ```ts
+     * const job = blJob("daily-import");
+     * const page = await job.listExecutions({ limit: 50 });
+     *
+     * for (const execution of page.data) {
+     *   console.log(execution.status);
+     * }
+     *
+     * const nextPage = await page.nextPage();
+     * ```
+     *
+     * @example
+     * ```ts
+     * const job = blJob("daily-import");
+     * const executions = await (await job.listExecutions()).autoPagingToArray({
+     *   limit: 1000,
+     * });
+     * ```
      */
-    async listExecutions() {
+    async listExecutions(query) {
         logger.debug(`Listing executions for job: ${this.jobName}`);
-        const { data } = await listJobExecutions({
-            path: {
-                jobId: this.jobName,
-            },
-            headers: settings.headers,
-            throwOnError: true,
+        const fetchPage = async (pageQuery) => {
+            const { data } = await listJobExecutions({
+                path: {
+                    jobId: this.jobName,
+                },
+                query: pageQuery,
+                headers: settings.headers,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return createPaginatedList({
+            response: await fetchPage(query),
+            fetchPage,
+            mapItem: (execution) => execution,
+            query,
         });
-        return data ?? [];
     }
     /**
      * Get the status of a specific execution