@blaxel/core 0.2.87-preview.174 → 0.2.87

package/dist/cjs-browser/sandbox/process/process.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxProcess = void 0;
 const settings_js_1 = require("../../common/settings.js");
 const action_js_1 = require("../action.js");
+const transient_retry_js_1 = require("../../common/transient-retry.js");
 const index_js_1 = require("../client/index.js");
 class SandboxProcess extends action_js_1.SandboxAction {
     constructor(sandbox) {
@@ -302,19 +303,27 @@ class SandboxProcess extends action_js_1.SandboxAction {
         return data;
     }
     async get(identifier) {
-        const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)(this.withClient({
-            path: { identifier },
-            baseUrl: this.url,
-        }));
-        this.handleResponseError(response, data, error);
-        return data;
+        // Idempotent GET: self-heal a transient connection reset (also makes the
+        // wait() poll loop resilient). exec() stays un-retried — it is a
+        // non-idempotent POST and retrying it duplicates the process (ENG-2340).
+        return (0, transient_retry_js_1.retryOnTransientReset)(async () => {
+            const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)(this.withClient({
+                path: { identifier },
+                baseUrl: this.url,
+            }));
+            this.handleResponseError(response, data, error);
+            return data;
+        });
     }
     async list() {
-        const { response, data, error } = await (0, index_js_1.getProcess)(this.withClient({
-            baseUrl: this.url,
-        }));
-        this.handleResponseError(response, data, error);
-        return data;
+        // Idempotent GET: self-heal a transient connection reset.
+        return (0, transient_retry_js_1.retryOnTransientReset)(async () => {
+            const { response, data, error } = await (0, index_js_1.getProcess)(this.withClient({
+                baseUrl: this.url,
+            }));
+            this.handleResponseError(response, data, error);
+            return data;
+        });
     }
     async stop(identifier) {
         const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifier)(this.withClient({
@@ -333,11 +342,15 @@ class SandboxProcess extends action_js_1.SandboxAction {
         return data;
     }
     async logs(identifier, type = "all") {
-        const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)(this.withClient({
-            path: { identifier },
-            baseUrl: this.url,
-        }));
-        this.handleResponseError(response, data, error);
+        // Idempotent GET: self-heal a transient connection reset.
+        const data = await (0, transient_retry_js_1.retryOnTransientReset)(async () => {
+            const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)(this.withClient({
+                path: { identifier },
+                baseUrl: this.url,
+            }));
+            this.handleResponseError(response, data, error);
+            return data;
+        });
         if (type === "all") {
             return data?.logs || "";
         }

package/dist/cjs-browser/types/common/h2fetch.d.ts

@@ -1,5 +1,12 @@
 import http2 from "http2";
 import type { H2Pool } from "./h2pool.js";
+/**
+ * Run `fn` while holding an upload slot for `domain`, releasing it when `fn`
+ * settles (the part PUT completes or fails). Bounds concurrent in-flight upload
+ * parts per domain across all files sharing the connection. Used by the
+ * multipart upload path; a no-op wrapper when the upload cap is unset.
+ */
+export declare function withUploadSlot<T>(domain: string, fn: () => Promise<T>): Promise<T>;
 /**
  * Creates a fetch()-compatible function that sends requests over an existing
  * HTTP/2 session. Falls back to globalThis.fetch() only when the session is

package/dist/cjs-browser/types/common/settings.d.ts

@@ -18,10 +18,28 @@ export type Config = {
      */
     maxConcurrentH2Requests?: number;
     /**
-     * Number of retry attempts for transient resets on multipart part uploads.
-     * `0` or `undefined` disables retry (current behavior).
+     * Maximum number of concurrent in-flight multipart upload-part requests per
+     * edge domain on the shared H2 connection. Defaults to 2 (the measured value
+     * that stops concurrent large uploads tripping ENHANCE_YOUR_CALM). Scoped to
+     * the upload-part path only; non-upload traffic is unaffected. `0` disables it.
+     */
+    maxConcurrentUploadH2Requests?: number;
+    /**
+     * Retry attempts for transient connection resets (ECONNRESET, GOAWAY,
+     * ENHANCE_YOUR_CALM, etc.) on file uploads. Covers both small single-PUT
+     * uploads and multipart parts; both are idempotent writes and safe to retry.
+     * Defaults to 3. Set `0` to disable.
      */
     fsPartRetries?: number;
+    /**
+     * Retry attempts for transient connection resets on IDEMPOTENT sandbox reads
+     * (fs.read/readBinary/ls/search/find/grep, drives.list, process.get/list/logs).
+     * Higher than the upload default so a later attempt can span a multi-second
+     * sandbox cold-start/standby wake (the window a first-call read reset falls in).
+     * Defaults to 5. Set `0` to disable. Never applied to non-idempotent ops
+     * (process.exec, drives.mount, etc.).
+     */
+    sandboxReadRetries?: number;
     /**
      * Client credentials for OAuth2 client_credentials flow.
      *
@@ -62,7 +80,9 @@ declare class Settings {
     get region(): string | undefined;
     get disableH2(): boolean;
     get maxConcurrentH2Requests(): number;
+    get maxConcurrentUploadH2Requests(): number;
     get fsPartRetries(): number;
+    get sandboxReadRetries(): number;
     /**
      * Fail fast with a clear, actionable error when credentials are missing or
      * incomplete, instead of sending empty workspace/authorization headers and

package/dist/cjs-browser/types/common/transient-retry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * True only for transport-level resets/drops that are safe to retry on an
+ * IDEMPOTENT request (transient HTTP/2 stream reset, GOAWAY, or a dropped
+ * connection). Application errors (4xx/5xx — even when their body text contains
+ * a marker word) and a bare "fetch failed" with no transport code are
+ * deliberately NOT transient, so auto-retry never masks a real server error or
+ * duplicates a non-idempotent call.
+ *
+ * This is the single classifier shared by the upload-part retry (ENG-2680) and
+ * the idempotent sandbox-op retry (read/list/etc.), so both judge "transient"
+ * identically.
+ */
+export declare function isTransientResetError(error: unknown): boolean;
+export type RetryOptions = {
+    retries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+/**
+ * Run `fn`, retrying only on transient transport resets (see
+ * isTransientResetError) with exponential backoff. Caller owns idempotency:
+ * ONLY wrap idempotent operations (GET-shaped reads/lists, or an idempotent
+ * PUT of the same bytes) — never a non-idempotent POST such as process.exec,
+ * which would duplicate the side effect (ENG-2340).
+ *
+ * Defaults to `settings.sandboxReadRetries` (the higher idempotent-read budget,
+ * sized for a multi-second standby wake). The upload path passes
+ * `{ retries: settings.fsPartRetries }` to keep its own (lower) budget.
+ */
+export declare function retryOnTransientReset<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/cjs-browser/types/sandbox/filesystem/filesystem.d.ts

@@ -1,8 +1,11 @@
 import { Sandbox } from "../../client/types.gen.js";
+import { isTransientResetError } from "../../common/transient-retry.js";
 import { SandboxAction } from "../action.js";
 import { ContentSearchResponse, Directory, FindResponse, FuzzySearchResponse, SuccessResponse } from "../client/index.js";
 import { SandboxProcess } from "../process/index.js";
 import { CopyResponse, FilesystemFindOptions, FilesystemGrepOptions, FilesystemSearchOptions, SandboxFilesystemFile, WatchEvent } from "./types.js";
+export declare const isTransientUploadError: typeof isTransientResetError;
+export declare function retryOnTransient<T>(fn: () => Promise<T>): Promise<T>;
 export declare class SandboxFileSystem extends SandboxAction {
     private process;
     constructor(sandbox: Sandbox, process: SandboxProcess);