@opengeni/runtime 4.0.3 → 4.1.0-canary.36239117573001

package/dist/{chunk-GBVN7WSK.js → chunk-ORTF5RRC.js}

@@ -15606,6 +15606,9 @@ import {
   canonicalModalCheckpointProviderBinding
 } from "@opengeni/contracts";
 
+// src/sandbox/channel-a.ts
+import { constants as zlibConstants, createGunzip } from "zlib";
+
 // src/sandbox/selfhosted/workspace-path.ts
 var MAX_MACHINE_PATH_LENGTH = 4096;
 var CONTROL_CHARACTER = /[\u0000-\u001f\u007f]/u;
@@ -15848,6 +15851,9 @@ function notifyDurableOpOwnershipTransferred(opId) {
   storage.getStore()?.onDurableOpOwnershipTransferred?.(opId);
 }
 
+// src/sandbox/routing/routing-session.ts
+import { SandboxFilesystemNotFoundError } from "modal";
+
 // src/sandbox/providers/modal-command-router-wire.ts
 import { Client, Metadata, credentials, status } from "@grpc/grpc-js";
 import protobuf from "protobufjs";
@@ -16579,6 +16585,10 @@ function eligibleForSupervision(args) {
     args && typeof args === "object" && !args.tty && !args.runAs
   );
 }
+var READ_ONLY_PATH_PROBE_OPERATIONS = /* @__PURE__ */ new Set(["readFile", "listDir", "pathExists", "viewImage"]);
+function isReadOnlyPathProbeMiss(op, error) {
+  return READ_ONLY_PATH_PROBE_OPERATIONS.has(op) && (isDefinitePathNotFoundError(error) || error instanceof SandboxWorkspaceReadNotFoundError || error instanceof SandboxFilesystemNotFoundError);
+}
 function recordFirstOperationPhase(timing, phase, durationMs, outcome) {
   if (!timing) return;
   const prior = timing.phases[phase];
@@ -17386,6 +17396,9 @@ var RoutingSandboxSession = class {
       );
       outcome = "completed";
       return result;
+    } catch (error) {
+      if (isReadOnlyPathProbeMiss(op, error)) outcome = "completed";
+      throw error;
     } finally {
       try {
         firstOperationObserver({
@@ -17545,6 +17558,9 @@ var RoutingSandboxSession = class {
             }
           );
           providerOutcome = "completed";
+        } catch (error) {
+          if (isReadOnlyPathProbeMiss(op, error)) providerOutcome = "completed";
+          throw error;
         } finally {
           recordFirstOperationPhase(
             firstOperationTiming,
@@ -17755,7 +17771,7 @@ var RoutingSandboxSession = class {
       return result;
     } catch (error) {
       materializationFailureReason = materializationVerificationDiagnostic(error)?.reason;
-      if ((op === "readFile" || op === "listDir" || op === "pathExists" || op === "viewImage") && isDefinitePathNotFoundError(error)) {
+      if (isReadOnlyPathProbeMiss(op, error)) {
         outcome = "not_found";
       }
       throw error;
@@ -19881,6 +19897,97 @@ var ChannelAPartialMutationError = class extends Error {
 };
 var REPOSITORY_DISCOVERY_LIMIT = 256;
 var REPOSITORY_DISCOVERY_TRUNCATED_SENTINEL = "__OPENGENI_REPOSITORY_DISCOVERY_TRUNCATED__";
+var CODE_SEARCH_RG_MAX_BYTES = 64 * 1024 * 1024;
+var CODE_SEARCH_RG_CHUNK_BYTES = 512 * 1024;
+var CODE_SEARCH_RG_FRAME_CHARS = 768 * 1024;
+var CODE_SEARCH_RG_MAX_TRANSFER_BYTES = 8 * 1024 * 1024;
+var CODE_SEARCH_RG_TOKEN = /^opengeni-code-search\.[A-Za-z0-9]+$/;
+var CODE_SEARCH_RG_BEGIN = "__OPENGENI_CODE_SEARCH_RG_BEGIN__";
+var CODE_SEARCH_RG_END = "__OPENGENI_CODE_SEARCH_RG_END__";
+var CODE_SEARCH_RG_TRAILER = new RegExp(
+  `${CODE_SEARCH_RG_END}(\\d+):([01])(?::(\\d+):([A-Za-z0-9._-]+)(?::(\\d+):([01]))?)?__`
+);
+var CODE_SEARCH_RG_STORE_FAILED = "code search could not store its output on this machine; its temporary directory may be full";
+var CODE_SEARCH_KINDS_BEGIN = "__OPENGENI_CODE_SEARCH_KINDS_BEGIN__";
+var CODE_SEARCH_KINDS_END = "__OPENGENI_CODE_SEARCH_KINDS_END__";
+var CODE_SEARCH_RG_FLAGS = /* @__PURE__ */ new Set([
+  "--files",
+  "--null",
+  "--line-number",
+  "--with-filename",
+  "--no-heading",
+  "-i",
+  "-w",
+  "--no-require-git",
+  "--hidden"
+]);
+var CODE_SEARCH_RG_VALUE_FLAGS = /* @__PURE__ */ new Map([
+  ["--color", (value) => value === "never"],
+  ["-m", (value) => /^[1-9]\d{0,5}$/.test(value)],
+  ["--max-columns", (value) => /^[1-9]\d{0,6}$/.test(value)],
+  ["--max-filesize", (value) => /^[1-9]\d{0,9}$/.test(value)],
+  ["-g", (value) => value.length > 0 && value.length <= 512],
+  ["-e", (value) => value.length > 0 && value.length <= 16384]
+]);
+function validateCodeSearchRipgrepArgs(args, workspaceRoot = "") {
+  const out = [];
+  let index = 0;
+  for (; index < args.length; index++) {
+    const arg = args[index];
+    if (arg.includes(NUL)) throw new ChannelAValidationError("ripgrep argument contains NUL");
+    if (arg === "--") break;
+    if (CODE_SEARCH_RG_FLAGS.has(arg)) {
+      out.push(arg);
+      continue;
+    }
+    const valid = CODE_SEARCH_RG_VALUE_FLAGS.get(arg);
+    const value = args[index + 1];
+    if (!valid || value === void 0 || value.includes(NUL) || !valid(value)) {
+      throw new ChannelAValidationError(`ripgrep argument is not allowed: ${arg}`);
+    }
+    out.push(arg, value);
+    index++;
+  }
+  const paths = args.slice(index + 1);
+  if (index >= args.length || paths.length === 0) {
+    throw new ChannelAValidationError("ripgrep arguments must end with -- and paths");
+  }
+  out.push("--");
+  for (const path of paths) {
+    if (path.includes(NUL) || path.startsWith("-") || path.startsWith("/")) {
+      throw new ChannelAValidationError(`ripgrep path is not allowed: ${path}`);
+    }
+    out.push(assertSafeRelPathOrRoot(path, workspaceRoot) || ".");
+  }
+  return ["--no-config", ...out];
+}
+function decodeCodeSearchChunk(stdout, trailerIndex) {
+  const begin = stdout.indexOf(CODE_SEARCH_RG_BEGIN);
+  if (begin < 0 || begin > trailerIndex) {
+    throw new ChannelAUnavailableError("code search output frame is missing");
+  }
+  const encoded = stdout.slice(begin + CODE_SEARCH_RG_BEGIN.length, trailerIndex).replace(/\s+/g, "");
+  if (encoded.length > Math.ceil(CODE_SEARCH_RG_CHUNK_BYTES / 3) * 4) {
+    throw new ChannelAUnavailableError("code search output frame is malformed");
+  }
+  return Buffer.from(encoded, "base64");
+}
+async function gunzipCodeSearchPrefix(input, limit) {
+  const gunzip = createGunzip({ finishFlush: zlibConstants.Z_SYNC_FLUSH, chunkSize: 64 * 1024 });
+  gunzip.end(input);
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of gunzip) {
+      chunks.push(chunk);
+      size += chunk.length;
+      if (size >= limit) break;
+    }
+  } catch {
+    throw new ChannelAUnavailableError("code search output could not be decoded");
+  }
+  return Buffer.concat(chunks, size).subarray(0, limit);
+}
 var REPOSITORY_DISCOVERY_STATUS_PREFIX = "__OPENGENI_REPOSITORY_DISCOVERY_STATUS__:";
 var NUL = String.fromCharCode(0);
 var FS_LIST_TRUNCATED_MARKER = "__OPENGENI_FS_LIST_TRUNCATED__";
@@ -21471,6 +21578,215 @@ var SandboxChannelAService = class {
   async detectRepos() {
     return (await this.detectReposDetailed()).repos;
   }
+  // ═════════════════════════ Code search (worker-only) ═══════════════════════
+  /**
+   * Run ripgrep read-only in the workspace root for the Jev `code_search` tool.
+   * Arguments are checked against a closed allowlist (no `--pre`, `-z` or other
+   * flags that run programs), so the command is provably read-only and skips
+   * durable mutation admission. stdout is capped at `maxBytes`, gzip+base64
+   * framed so providers that drop newlines or retain limited output cannot
+   * corrupt it, and bounded by a wall-clock watchdog (not GNU `timeout`, which
+   * stock macOS lacks). Resolves `available: false` when `rg` is not installed,
+   * and throws when the box could not store the output whole (a full
+   * temporary directory) rather than returning a prefix as complete.
+   */
+  async codeSearchRipgrep(args, options) {
+    const argv = validateCodeSearchRipgrepArgs(args, this.workspaceRoot);
+    const maxBytes = Math.max(1, Math.min(CODE_SEARCH_RG_MAX_BYTES, Math.floor(options.maxBytes)));
+    const maxTransferBytes = Math.max(
+      CODE_SEARCH_RG_CHUNK_BYTES,
+      Math.min(
+        CODE_SEARCH_RG_MAX_TRANSFER_BYTES,
+        Math.floor(options.maxTransferBytes ?? CODE_SEARCH_RG_MAX_TRANSFER_BYTES)
+      )
+    );
+    const seconds = Math.max(1, Math.min(120, Math.ceil(options.timeoutMs / 1e3)));
+    const script = [
+      // Remove output a previous call could not fetch (worker gone mid-transfer).
+      // The trailing slash makes find enter a symlinked /tmp, as on macOS.
+      `find "\${TMPDIR:-/tmp}/" -maxdepth 1 -name 'opengeni-code-search.*' -mmin +15 -exec rm -f {} + 2>/dev/null`,
+      'gz_file=$(mktemp "${TMPDIR:-/tmp}/opengeni-code-search.XXXXXX") || exit 70',
+      'status_file="${gz_file}.status"',
+      'timeout_file="${gz_file}.timed-out"',
+      "keep_gz=",
+      "search_pid=",
+      "watchdog_pid=",
+      'cleanup() { if [ -n "$search_pid" ]; then kill -TERM -- "-$search_pid" 2>/dev/null || kill "$search_pid" 2>/dev/null || true; fi; if [ -n "$watchdog_pid" ]; then kill "$watchdog_pid" 2>/dev/null || true; fi; rm -f "$status_file" "$timeout_file"; [ -n "$keep_gz" ] || rm -f "$gz_file"; }',
+      "abort() { trap - EXIT; keep_gz=; cleanup; exit 143; }",
+      "trap cleanup EXIT",
+      "trap abort HUP INT TERM",
+      `if ! command -v rg >/dev/null 2>&1; then printf '${CODE_SEARCH_RG_END}127:0__'; exit 0; fi`,
+      // Job control gives the pipeline its own process group, so the watchdog
+      // and cleanup stop ripgrep itself rather than only the subshell. Output is
+      // compressed once, straight into the kept file: providers retain only
+      // about 1 MiB per output stream, and later chunks are fetched by name.
+      // That TERM stops only ripgrep and head. The subshell and gzip ignore it
+      // (bash 3.2 runs a trap before the pipeline ends), so a stopped search
+      // still stores a whole member and records every stage's status.
+      "set -m",
+      `( trap '' TERM; ( trap - TERM; exec rg ${argv.map(shellQuote3).join(" ")} ) 2>/dev/null | ( trap - TERM; exec head -c ${maxBytes + 1} ) | gzip -c > "$gz_file"; printf '%s %s %s' "\${PIPESTATUS[0]}" "\${PIPESTATUS[1]}" "\${PIPESTATUS[2]}" > "$status_file" ) </dev/null >/dev/null 2>&1 &`,
+      "search_pid=$!",
+      `(sleeper_pid=; stop_watchdog() { if [ -n "$sleeper_pid" ]; then kill "$sleeper_pid" 2>/dev/null || true; wait "$sleeper_pid" 2>/dev/null || true; fi; exit 0; }; trap stop_watchdog HUP INT TERM; sleep ${seconds} & sleeper_pid=$!; wait "$sleeper_pid"; sleeper_pid=; if kill -TERM -- "-$search_pid" 2>/dev/null; then : > "$timeout_file"; fi) </dev/null >/dev/null 2>&1 &`,
+      "watchdog_pid=$!",
+      'wait "$search_pid" 2>/dev/null',
+      "search_pid=",
+      'kill "$watchdog_pid" 2>/dev/null || true',
+      'wait "$watchdog_pid" 2>/dev/null || true',
+      "watchdog_pid=",
+      "set +m",
+      "rg_status= head_status= gzip_status=",
+      'if [ -f "$status_file" ]; then read -r rg_status head_status gzip_status < "$status_file"; fi',
+      '[ -n "$rg_status" ] || rg_status=125',
+      "timed_out=0",
+      'if [ -f "$timeout_file" ]; then timed_out=1; fi',
+      // A full temporary directory cuts the member without a word, so decode it
+      // end to end: that yields the raw size and fails on a cut or corrupt member.
+      "stored=0",
+      `if raw_size=$(set -o pipefail; gzip -dc < "$gz_file" 2>/dev/null | wc -c | tr -d ' ') && [ "$head_status" = 0 ] && [ "$gzip_status" = 0 ]; then stored=1; fi`,
+      '[ -n "$raw_size" ] || raw_size=0',
+      `gz_size=$(wc -c < "$gz_file" | tr -d ' ')`,
+      '[ -n "$gz_size" ] || gz_size=0',
+      "token=-",
+      // The worker fails an unstored search that did not time out, so only
+      // keep output it will fetch.
+      `if [ "$gz_size" -gt ${CODE_SEARCH_RG_CHUNK_BYTES} ] && { [ "$stored" = 1 ] || [ "$timed_out" = 1 ]; }; then keep_gz=1; token=$(basename "$gz_file"); fi`,
+      `printf '${CODE_SEARCH_RG_BEGIN}'`,
+      `head -c ${CODE_SEARCH_RG_CHUNK_BYTES} "$gz_file" | base64 | tr -d '\\r\\n'`,
+      `printf '${CODE_SEARCH_RG_END}%s:%s:%s:%s:%s:%s__' "$rg_status" "$timed_out" "$gz_size" "$token" "$raw_size" "$stored"`
+    ].join("\n");
+    const { stdout } = await this.runReadOnly({
+      cmd: internalBashCommand(script),
+      workdir: this.providerWorkspaceRoot(),
+      yieldTimeMs: (seconds + 15) * 1e3,
+      maxOutputTokens: CODE_SEARCH_RG_FRAME_CHARS
+    });
+    const trailer = CODE_SEARCH_RG_TRAILER.exec(stdout);
+    if (!trailer) {
+      throw new ChannelAUnavailableError("code search did not complete in this workspace");
+    }
+    const exitCode = Number.parseInt(trailer[1], 10);
+    if (exitCode === 127) {
+      return { available: false, stdout: "", exitCode: null, truncated: false, timedOut: false };
+    }
+    if (trailer[3] === void 0 || trailer[5] === void 0) {
+      throw new ChannelAUnavailableError("code search output trailer is malformed");
+    }
+    const timedOut = trailer[2] === "1";
+    if (!timedOut && exitCode === 125) {
+      throw new ChannelAUnavailableError(
+        "code search did not record its status on this machine; its temporary directory may be full"
+      );
+    }
+    if (!timedOut && trailer[6] !== "1") {
+      throw new ChannelAUnavailableError(CODE_SEARCH_RG_STORE_FAILED);
+    }
+    const first = decodeCodeSearchChunk(stdout, trailer.index);
+    const reportedSize = Number.parseInt(trailer[3], 10);
+    const rawSize = Number.parseInt(trailer[5], 10);
+    const token = trailer[4] === "-" ? null : trailer[4];
+    const parts = [first];
+    let fetched = first.length;
+    if (token !== null && reportedSize > fetched) {
+      if (!CODE_SEARCH_RG_TOKEN.test(token)) {
+        throw new ChannelAUnavailableError("code search output frame is malformed");
+      }
+      const target = Math.min(reportedSize, maxTransferBytes);
+      const maxCalls = Math.ceil(maxTransferBytes / CODE_SEARCH_RG_CHUNK_BYTES);
+      for (let call = 0; call < maxCalls && fetched < target; call++) {
+        const length = Math.min(CODE_SEARCH_RG_CHUNK_BYTES, target - fetched);
+        const chunk = await this.codeSearchRipgrepChunk(
+          token,
+          fetched,
+          length,
+          fetched + length >= target
+        );
+        if (chunk === null) break;
+        parts.push(chunk);
+        fetched += chunk.length;
+        if (chunk.length < length) break;
+      }
+    }
+    const transferCut = fetched < reportedSize;
+    const compressed = Buffer.concat(parts);
+    const raw = compressed.length ? await gunzipCodeSearchPrefix(compressed, maxBytes + 1) : Buffer.alloc(0);
+    const rawCut = raw.length > maxBytes;
+    const sizeMismatch = !rawCut && !transferCut && !timedOut && raw.length !== rawSize;
+    const truncated = rawCut || transferCut || sizeMismatch;
+    let text = (rawCut ? raw.subarray(0, maxBytes) : raw).toString("utf8");
+    if (truncated || timedOut) {
+      const lastNewline = text.lastIndexOf("\n");
+      text = lastNewline >= 0 ? text.slice(0, lastNewline + 1) : "";
+    }
+    return {
+      available: true,
+      stdout: text,
+      exitCode: timedOut ? null : exitCode,
+      truncated,
+      timedOut
+    };
+  }
+  /**
+   * Fetch one chunk of compressed ripgrep output kept on the box by a previous
+   * codeSearchRipgrep call. The last fetch deletes the file. Null when the
+   * file is gone.
+   */
+  async codeSearchRipgrepChunk(token, offset, length, last) {
+    const script = [
+      'f="${TMPDIR:-/tmp}/$1"',
+      `if [ ! -f "$f" ]; then printf '${CODE_SEARCH_RG_END}0:0:0:missing__'; exit 0; fi`,
+      `printf '${CODE_SEARCH_RG_BEGIN}'`,
+      `tail -c +"$2" "$f" | head -c "$3" | base64 | tr -d '\\r\\n'`,
+      `printf '${CODE_SEARCH_RG_END}0:0:0:-__'`,
+      'if [ "$4" = 1 ]; then rm -f "$f"; fi'
+    ].join("\n");
+    const { stdout } = await this.runReadOnly({
+      cmd: `${internalBashCommand(script)} opengeni-code-search ${shellQuote3(token)} ${offset + 1} ${length} ${last ? 1 : 0}`,
+      workdir: this.providerWorkspaceRoot(),
+      yieldTimeMs: 3e4,
+      maxOutputTokens: CODE_SEARCH_RG_FRAME_CHARS
+    });
+    const trailer = CODE_SEARCH_RG_TRAILER.exec(stdout);
+    if (!trailer) {
+      throw new ChannelAUnavailableError("code search did not complete in this workspace");
+    }
+    if (trailer[4] === "missing") return null;
+    const chunk = decodeCodeSearchChunk(stdout, trailer.index);
+    if (chunk.length > length) {
+      throw new ChannelAUnavailableError("code search output frame is malformed");
+    }
+    return chunk;
+  }
+  /** Classify workspace-relative paths for `code_search` path filters. */
+  async codeSearchPathKinds(paths) {
+    const checked = paths.map((path) => {
+      if (path.startsWith("-")) throw new ChannelAValidationError(`invalid path: ${path}`);
+      return assertSafeRelPathOrRoot(path, this.workspaceRoot) || ".";
+    });
+    if (checked.length === 0) return {};
+    const script = [
+      `printf '${CODE_SEARCH_KINDS_BEGIN}'`,
+      'for p in "$@"; do if [ -d "$p" ]; then printf d; elif [ -e "$p" ]; then printf f; else printf m; fi; done',
+      `printf '${CODE_SEARCH_KINDS_END}'`
+    ].join("\n");
+    const { stdout } = await this.runReadOnly({
+      cmd: `${internalBashCommand(script)} opengeni-code-search ${checked.map(shellQuote3).join(" ")}`,
+      workdir: this.providerWorkspaceRoot(),
+      yieldTimeMs: 2e4,
+      maxOutputTokens: 4096
+    });
+    const match = new RegExp(`${CODE_SEARCH_KINDS_BEGIN}([dfm]*)${CODE_SEARCH_KINDS_END}`).exec(
+      stdout
+    );
+    if (!match || match[1].length !== checked.length) {
+      throw new ChannelAUnavailableError("code search path check did not complete");
+    }
+    const kinds = {};
+    paths.forEach((path, index) => {
+      const code = match[1][index];
+      kinds[path] = code === "d" ? "directory" : code === "f" ? "file" : "missing";
+    });
+    return kinds;
+  }
   // ════════════════════════ Terminal exec + PTY (A2) ════════════════════════
   /** Run a bounded command to physical completion and return buffered output.
    *  A deadline cancels the exact provider operation, proves its process group
@@ -33600,7 +33916,7 @@ var BrowserControlClient = class {
               this.session.runtimeMetrics
             );
           } catch (error) {
-            if (retryNativeEndpoint && !requireHostFetch && error instanceof BrowserControlTransportError) {
+            if (retryNativeEndpoint && !requireHostFetch && input.method === "GET" && error instanceof BrowserControlTransportError) {
               return await this.requestJson(input, false);
             }
             throw error;
@@ -33695,7 +34011,7 @@ var BrowserControlClient = class {
         throw error;
       }
       if (error instanceof BrowserControlTransportError) {
-        if (retryNativeEndpoint && this.nativeAuthority && this.session.ensureBrowserControl) {
+        if (retryNativeEndpoint && input.method === "GET" && this.nativeAuthority && this.session.ensureBrowserControl) {
           nativeControllerPorts.delete(nativeControllerKey(this.nativeAuthority));
           await this.controllerPort();
           return await this.requestJson(input, false);
@@ -34312,21 +34628,24 @@ async function requestExposedController(endpoint, input, defaultTimeoutMs, metri
   if (body !== void 0 && Buffer.byteLength(body) > BROWSER_CONTROL_MAX_JSON_BYTES) {
     throw new RangeError("browser controller request body is too large");
   }
-  const response = await fetch(streamUrl, {
-    method: input.method,
-    headers: {
-      ...exposedPortHeaders(endpoint),
-      authorization: `Bearer ${token}`,
-      ...body === void 0 ? {} : { "content-type": "application/json" }
-    },
-    ...body === void 0 ? {} : { body },
-    redirect: "manual",
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  const responseText = await response.text();
+  const response = await controllerTransport(
+    async () => await fetch(streamUrl, {
+      method: input.method,
+      headers: {
+        ...exposedPortHeaders(endpoint),
+        authorization: `Bearer ${token}`,
+        ...body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      ...body === void 0 ? {} : { body },
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+  );
+  const responseText = await controllerTransport(async () => await response.text());
   if (Buffer.byteLength(responseText) > BROWSER_CONTROL_MAX_JSON_BYTES) {
     throw new BrowserControlProtocolError("browser controller response is too large");
   }
+  rejectProviderGatewayResponse(responseText, response.status);
   if ((response.status === 401 || response.status === 403) && !looksLikeBrowserControlEnvelope(responseText)) {
     const signed = parseOpenSandboxSignedUriPath(endpoint.path ?? "");
     if (signed) {
@@ -34347,21 +34666,24 @@ async function requestExposedControllerBytes(endpoint, input, defaultTimeoutMs)
   const timeoutMs = boundedTimeout2(input.timeoutMs ?? defaultTimeoutMs);
   const streamUrl = exposedControllerUrl(endpoint, input.path);
   streamUrl.protocol = streamUrl.protocol === "wss:" ? "https:" : "http:";
-  const response = await fetch(streamUrl, {
-    method: input.method,
-    headers: {
-      ...exposedPortHeaders(endpoint),
-      authorization: `Bearer ${token}`,
-      accept: "image/jpeg, image/png"
-    },
-    redirect: "manual",
-    signal: AbortSignal.timeout(timeoutMs)
-  });
+  const response = await controllerTransport(
+    async () => await fetch(streamUrl, {
+      method: input.method,
+      headers: {
+        ...exposedPortHeaders(endpoint),
+        authorization: `Bearer ${token}`,
+        accept: "image/jpeg, image/png"
+      },
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+  );
   if (!response.ok) {
-    const responseText = await response.text();
+    const responseText = await controllerTransport(async () => await response.text());
     if (Buffer.byteLength(responseText) > BROWSER_CONTROL_MAX_JSON_BYTES) {
       throw new BrowserControlProtocolError("browser controller response is too large");
     }
+    rejectProviderGatewayResponse(responseText, response.status);
     parseEnvelope(responseText, response.status);
     throw new BrowserControlProtocolError("browser controller image response is invalid");
   }
@@ -34371,9 +34693,23 @@ async function requestExposedControllerBytes(endpoint, input, defaultTimeoutMs)
     await response.body?.cancel("frame exceeds its byte bound").catch(() => void 0);
     throw new RangeError("frame exceeds its byte bound");
   }
-  const data = await readBoundedFrameResponse(response, maxBytes);
+  const data = await controllerTransport(
+    async () => await readBoundedFrameResponse(response, maxBytes)
+  );
   return controllerImageFrame(data, response.headers, input);
 }
+async function controllerTransport(readOrDispatch) {
+  try {
+    return await readOrDispatch();
+  } catch (error) {
+    if (error instanceof BrowserControlProtocolError || error instanceof BrowserControlTransportError || error instanceof RangeError) {
+      throw error;
+    }
+    throw new BrowserControlTransportError("browser controller host-fetch failed", {
+      cause: error
+    });
+  }
+}
 async function readBoundedFrameResponse(response, maxBytes) {
   if (!response.body) throw new BrowserControlProtocolError("browser controller image is empty");
   const reader = response.body.getReader();
@@ -34572,6 +34908,11 @@ function looksLikeBrowserControlEnvelope(body) {
     return false;
   }
 }
+function rejectProviderGatewayResponse(body, status2) {
+  if ([502, 503, 504].includes(status2) && !looksLikeBrowserControlEnvelope(body)) {
+    throw new BrowserControlTransportError(`browser controller returned HTTP ${status2}`);
+  }
+}
 function parseEnvelope(body, status2) {
   let value;
   try {
@@ -38520,6 +38861,8 @@ export {
   ChannelAUnsupportedError,
   ChannelAPartialMutationError,
   REPOSITORY_DISCOVERY_LIMIT,
+  CODE_SEARCH_RG_MAX_BYTES,
+  validateCodeSearchRipgrepArgs,
   SandboxChannelAService,
   stripExecBanner,
   isDefinitePathNotFoundError,
@@ -38738,4 +39081,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-GBVN7WSK.js.map
+//# sourceMappingURL=chunk-ORTF5RRC.js.map