@bubblebrain-ai/bubble 0.0.19 → 0.0.20

package/dist/network/chatgpt-transport.js

@@ -1,8 +1,8 @@
-import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { delimiter } from "node:path";
 import { rootCertificates } from "node:tls";
 import { Agent, ProxyAgent } from "undici";
+import { getSystemProxyForUrl } from "./system-proxy.js";
 let cachedDefaultFetch;
 export function chatGptFetch(input, init) {
     return getChatGptFetch()(input, init);
@@ -20,8 +20,9 @@ export function getChatGptFetch(env = process.env) {
 export function createChatGptFetch(options = {}) {
     const env = options.env ?? process.env;
     const fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    const dispatcher = createChatGptDispatcher(env);
     return async (input, init) => {
-        const requestInit = withChatGptNetworkOptions(input, init, env);
+        const requestInit = withChatGptNetworkOptions(input, init, env, dispatcher);
         try {
             return await fetchImpl(input, requestInit);
         }
@@ -62,10 +63,15 @@ export function withChatGptNetworkOptions(input, init, env = process.env, dispat
     return next;
 }
 export function normalizeChatGptNetworkError(error, env = process.env) {
+    // Already normalized — wrapping again would nest "Original error:" messages.
+    if (error instanceof Error && error.message.includes("connection failed before Bubble received a response")) {
+        return error;
+    }
     const text = errorMessageChain(error).join("\n");
     if (!isChatGptNetworkErrorText(text)) {
         return error instanceof Error ? error : new Error(String(error));
     }
+    const systemProxy = hasProxyEnv(env) ? undefined : getSystemProxyForUrl(new URL("https://chatgpt.com/"), env);
     const message = [
         "ChatGPT connection failed before Bubble received a response.",
         isCertificateErrorText(text)
@@ -73,8 +79,8 @@ export function normalizeChatGptNetworkError(error, env = process.env) {
             : "This looks like a proxy or network transport failure.",
         hasProxyEnv(env)
             ? "Bubble is using proxy environment variables for ChatGPT requests. Make sure NO_PROXY includes localhost,127.0.0.1."
-            : hasMacSystemProxy(env)
-                ? "Bubble detected the macOS system proxy for ChatGPT requests. If it is stale, restart your proxy client or set BUBBLE_DISABLE_SYSTEM_PROXY=1 and configure HTTPS_PROXY explicitly."
+            : systemProxy
+                ? `Bubble is routing this request through the OS system proxy at ${systemProxy} (detected automatically). Check that the proxy app is running and healthy, or set BUBBLE_SYSTEM_PROXY=0 to disable system proxy detection.`
                 : "If your network requires a proxy, set HTTPS_PROXY or HTTP_PROXY, and set NO_PROXY=localhost,127.0.0.1.",
         "Do not disable TLS verification with NODE_TLS_REJECT_UNAUTHORIZED=0.",
         `Original error: ${firstMeaningfulErrorMessage(error) || "unknown network error"}`,
@@ -82,135 +88,46 @@ export function normalizeChatGptNetworkError(error, env = process.env) {
     return new Error(message, { cause: error });
 }
 function hasProxyEnv(env) {
-    return Boolean(env.BUBBLE_CHATGPT_PROXY ||
-        env.bubble_chatgpt_proxy ||
-        env.HTTPS_PROXY ||
-        env.https_proxy ||
-        env.HTTP_PROXY ||
-        env.http_proxy ||
-        env.ALL_PROXY ||
-        env.all_proxy);
+    return Boolean(env.BUBBLE_CHATGPT_PROXY || env.bubble_chatgpt_proxy
+        || env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy);
+}
+function chatGptProxyOverride(env) {
+    return env.BUBBLE_CHATGPT_PROXY ?? env.bubble_chatgpt_proxy;
 }
 function isBunRuntime() {
     return typeof globalThis.Bun !== "undefined";
 }
 function bunProxyForUrl(input, env) {
-    return proxyForUrl(input, env);
-}
-function nodeProxyForUrl(input, env) {
-    return proxyForUrl(input, env);
-}
-function proxyForUrl(input, env) {
     const url = urlFromInput(input);
     if (!url || shouldBypassProxy(url, env))
         return undefined;
-    const explicit = explicitProxyForUrl(url, env);
-    return explicit ?? macSystemProxyForUrl(url, env);
-}
-function defaultNodeProxy(env) {
-    return (env.BUBBLE_CHATGPT_PROXY ??
-        env.bubble_chatgpt_proxy ??
-        env.HTTPS_PROXY ??
-        env.https_proxy ??
-        env.HTTP_PROXY ??
-        env.http_proxy ??
-        env.ALL_PROXY ??
-        env.all_proxy ??
-        macSystemProxyForUrl(new URL("https://chatgpt.com/"), env));
-}
-function explicitProxyForUrl(url, env) {
-    const chatGptProxy = env.BUBBLE_CHATGPT_PROXY ?? env.bubble_chatgpt_proxy;
-    if (chatGptProxy)
-        return chatGptProxy;
+    const override = chatGptProxyOverride(env);
+    if (override)
+        return override;
     const allProxy = env.ALL_PROXY ?? env.all_proxy;
     if (url.protocol === "https:")
-        return env.HTTPS_PROXY ?? env.https_proxy ?? allProxy;
+        return env.HTTPS_PROXY ?? env.https_proxy ?? allProxy ?? getSystemProxyForUrl(url, env);
     if (url.protocol === "http:")
-        return env.HTTP_PROXY ?? env.http_proxy ?? allProxy;
-    return allProxy;
-}
-function hasMacSystemProxy(env) {
-    return Boolean(macSystemProxyForUrl(new URL("https://chatgpt.com/"), env));
-}
-function macSystemProxyForUrl(url, env) {
-    if (process.platform !== "darwin" || truthyEnv(env.BUBBLE_DISABLE_SYSTEM_PROXY))
-        return undefined;
-    const output = readMacSystemProxy();
-    return output ? parseMacSystemProxyForUrl(output, url) : undefined;
-}
-export function parseMacSystemProxyForUrl(output, url) {
-    if (macProxyExceptionMatches(output, url.hostname, url.port))
-        return undefined;
-    const values = parseScutilProxyValues(output);
-    if (url.protocol === "https:") {
-        return formatMacProxy(values.HTTPSEnable, values.HTTPSProxy, values.HTTPSPort);
-    }
-    if (url.protocol === "http:") {
-        return formatMacProxy(values.HTTPEnable, values.HTTPProxy, values.HTTPPort);
-    }
+        return env.HTTP_PROXY ?? env.http_proxy ?? allProxy ?? getSystemProxyForUrl(url, env);
     return undefined;
 }
-function parseScutilProxyValues(output) {
-    const values = {};
-    for (const line of output.split(/\r?\n/)) {
-        const match = line.match(/^\s*([A-Za-z]+(?:Enable|Proxy|Port))\s*:\s*(.+?)\s*$/);
-        if (match)
-            values[match[1]] = match[2];
-    }
-    return values;
-}
-function formatMacProxy(enabled, host, port) {
-    if (enabled !== "1" || !host || !port)
+function nodeProxyForUrl(input, env) {
+    const url = urlFromInput(input);
+    if (!url || shouldBypassProxy(url, env))
         return undefined;
-    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(host))
-        return host;
-    const normalizedHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-    return `http://${normalizedHost}:${port}`;
-}
-function macProxyExceptionMatches(output, hostname, port) {
-    const exceptions = parseMacProxyExceptions(output);
-    return exceptions.some((entry) => noProxyEntryMatches(entry.toLowerCase(), hostname.toLowerCase(), port));
-}
-function parseMacProxyExceptions(output) {
-    const exceptions = [];
-    let inExceptions = false;
-    for (const line of output.split(/\r?\n/)) {
-        if (line.includes("ExceptionsList")) {
-            inExceptions = true;
-            continue;
-        }
-        if (!inExceptions)
-            continue;
-        if (/^\s*}\s*$/.test(line))
-            break;
-        const match = line.match(/^\s*\d+\s*:\s*(.+?)\s*$/);
-        if (match)
-            exceptions.push(match[1].trim());
-    }
-    return exceptions;
-}
-let cachedMacSystemProxy;
-function readMacSystemProxy() {
-    const now = Date.now();
-    if (cachedMacSystemProxy && now - cachedMacSystemProxy.checkedAtMs < 5_000) {
-        return cachedMacSystemProxy.output;
-    }
-    let output;
-    try {
-        output = execFileSync("scutil", ["--proxy"], {
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 1_000,
-        });
-    }
-    catch {
-        output = undefined;
-    }
-    cachedMacSystemProxy = { checkedAtMs: now, output };
-    return output;
+    const override = chatGptProxyOverride(env);
+    if (override)
+        return override;
+    if (url.protocol === "https:")
+        return env.HTTPS_PROXY ?? env.https_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? getSystemProxyForUrl(url, env);
+    if (url.protocol === "http:")
+        return env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? getSystemProxyForUrl(url, env);
+    return defaultNodeProxy(env);
 }
-function truthyEnv(value) {
-    return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
+function defaultNodeProxy(env) {
+    return chatGptProxyOverride(env)
+        ?? env.HTTPS_PROXY ?? env.https_proxy ?? env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy
+        ?? getSystemProxyForUrl(new URL("https://system-proxy-default.invalid/"), env);
 }
 function bunExtraCaFiles(env) {
     const bun = globalThis.Bun;
@@ -274,19 +191,21 @@ function extraCaCertificatePaths(env) {
 }
 function networkEnvSignature(env) {
     return [
+        env.BUBBLE_CHATGPT_PROXY,
+        env.bubble_chatgpt_proxy,
         env.HTTP_PROXY,
         env.http_proxy,
         env.HTTPS_PROXY,
         env.https_proxy,
         env.ALL_PROXY,
         env.all_proxy,
-        env.BUBBLE_CHATGPT_PROXY,
-        env.bubble_chatgpt_proxy,
-        env.BUBBLE_DISABLE_SYSTEM_PROXY,
         env.NO_PROXY,
         env.no_proxy,
         env.NODE_EXTRA_CA_CERTS,
         env.BUBBLE_EXTRA_CA_CERTS,
+        // Invalidate the cached fetch when the user toggles the OS proxy
+        // (e.g. turning Clash system proxy on/off mid-session).
+        getSystemProxyForUrl(new URL("https://chatgpt.com/"), env),
     ].join("\0");
 }
 function isChatGptNetworkErrorText(text) {

package/dist/network/provider-transport.d.ts

@@ -0,0 +1,32 @@
+import { type Dispatcher } from "undici";
+export type ProviderFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface ProviderFetchOptions {
+    providerName: string;
+    fetch?: ProviderFetch;
+    env?: NodeJS.ProcessEnv;
+    verboseEnvVar?: string;
+}
+type RequestInitWithProviderOptions = RequestInit & {
+    dispatcher?: Dispatcher;
+    proxy?: string;
+    tls?: {
+        ca?: unknown[];
+    };
+    verbose?: boolean;
+};
+export declare function providerFetch(input: RequestInfo | URL, init: RequestInit | undefined, options: ProviderFetchOptions): Promise<Response>;
+export declare function createProviderFetch(options: ProviderFetchOptions): ProviderFetch;
+export declare function createProviderDispatcher(env?: NodeJS.ProcessEnv, input?: RequestInfo | URL, providerName?: string): Dispatcher | undefined;
+export declare function withProviderNetworkOptions(input: RequestInfo | URL, init: RequestInit | undefined, options?: {
+    env?: NodeJS.ProcessEnv;
+    providerName?: string;
+    verboseEnvVar?: string;
+}): RequestInitWithProviderOptions;
+export declare function normalizeProviderNetworkError(error: unknown, options: {
+    providerName: string;
+    input?: RequestInfo | URL;
+    env?: NodeJS.ProcessEnv;
+}): Error;
+export declare function isProviderTransportError(error: unknown): boolean;
+export declare function shouldEnableFetchVerbose(env?: NodeJS.ProcessEnv, providerVerboseEnvVar?: string): boolean;
+export {};

package/dist/network/provider-transport.js

@@ -0,0 +1,265 @@
+import { readFileSync } from "node:fs";
+import { delimiter } from "node:path";
+import { rootCertificates } from "node:tls";
+import { Agent, ProxyAgent } from "undici";
+import { getSystemProxyForUrl } from "./system-proxy.js";
+export function providerFetch(input, init, options) {
+    return createProviderFetch(options)(input, init);
+}
+export function createProviderFetch(options) {
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    return async (input, init) => {
+        try {
+            const requestInit = withProviderNetworkOptions(input, init, {
+                env,
+                providerName: options.providerName,
+                verboseEnvVar: options.verboseEnvVar,
+            });
+            return await fetchImpl(input, requestInit);
+        }
+        catch (error) {
+            throw normalizeProviderNetworkError(error, {
+                providerName: options.providerName,
+                input,
+                env,
+            });
+        }
+    };
+}
+export function createProviderDispatcher(env = process.env, input, providerName = "provider") {
+    if (isBunRuntime())
+        return undefined;
+    const ca = loadExtraCaCertificates(env, providerName);
+    const proxy = input ? nodeProxyForUrl(input, env) : defaultNodeProxy(env);
+    if (!proxy && ca.length === 0)
+        return undefined;
+    const caOptions = ca.length > 0 ? { ca: [...rootCertificates, ...ca] } : undefined;
+    if (proxy) {
+        return new ProxyAgent({
+            uri: proxy,
+            ...(caOptions ? { requestTls: caOptions, proxyTls: caOptions } : {}),
+        });
+    }
+    return caOptions ? new Agent({ connect: caOptions }) : undefined;
+}
+export function withProviderNetworkOptions(input, init, options = {}) {
+    const env = options.env ?? process.env;
+    const providerName = options.providerName ?? "provider";
+    const next = { ...(init ?? {}) };
+    if (isBunRuntime()) {
+        const proxy = bunProxyForUrl(input, env);
+        if (proxy)
+            next.proxy = proxy;
+        const ca = bunExtraCaFiles(env);
+        if (ca.length > 0)
+            next.tls = { ...(next.tls ?? {}), ca };
+    }
+    else {
+        const dispatcher = createProviderDispatcher(env, input, providerName);
+        if (dispatcher)
+            next.dispatcher = dispatcher;
+    }
+    if (shouldEnableFetchVerbose(env, options.verboseEnvVar)) {
+        next.verbose = true;
+    }
+    return next;
+}
+export function normalizeProviderNetworkError(error, options) {
+    const env = options.env ?? process.env;
+    // Already normalized (e.g. by createProviderFetch) — wrapping again would
+    // nest "Original error:" messages.
+    if (error instanceof Error && error.message.includes("connection failed before Bubble received a response")) {
+        return error;
+    }
+    const text = errorMessageChain(error).join("\n");
+    if (!isProviderNetworkErrorText(text)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const origin = originFromInput(options.input);
+    const providerLabel = options.providerName || "provider";
+    const systemProxy = hasProxyEnv(env) ? undefined : getSystemProxyForUrl(options.input ? urlFromInput(options.input) : undefined, env);
+    const message = [
+        `${providerLabel} connection failed before Bubble received a response.`,
+        origin ? `Target origin: ${origin}.` : undefined,
+        isCertificateErrorText(text)
+            ? "TLS certificate verification failed. If you are on a corporate proxy, VPN, or HTTPS inspection network, start Bubble with NODE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem or BUBBLE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem."
+            : "This looks like a proxy or network transport failure.",
+        hasProxyEnv(env)
+            ? "Bubble is using proxy environment variables for provider requests. Make sure NO_PROXY includes localhost,127.0.0.1 and any direct-connect hosts."
+            : systemProxy
+                ? `Bubble is routing this request through the OS system proxy at ${systemProxy} (detected automatically). Check that the proxy app is running and healthy, or set BUBBLE_SYSTEM_PROXY=0 to disable system proxy detection.`
+                : "If your network requires a proxy, set HTTPS_PROXY or HTTP_PROXY, and set NO_PROXY=localhost,127.0.0.1.",
+        hasCustomCaEnv(env)
+            ? "A custom CA environment variable is configured."
+            : "No custom CA environment variable is configured.",
+        "Do not disable TLS verification with NODE_TLS_REJECT_UNAUTHORIZED=0.",
+        `Original error: ${firstMeaningfulErrorMessage(error) || "unknown network error"}`,
+    ].filter(Boolean).join(" ");
+    return new Error(message, { cause: error });
+}
+export function isProviderTransportError(error) {
+    return isProviderNetworkErrorText(errorMessageChain(error).join("\n"));
+}
+export function shouldEnableFetchVerbose(env = process.env, providerVerboseEnvVar) {
+    const providerValue = providerVerboseEnvVar ? env[providerVerboseEnvVar] : undefined;
+    return isTruthyEnv(providerValue) || isTruthyEnv(env.BUBBLE_PROVIDER_FETCH_VERBOSE);
+}
+function hasProxyEnv(env) {
+    return Boolean(env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy);
+}
+function hasCustomCaEnv(env) {
+    return Boolean(env.NODE_EXTRA_CA_CERTS?.trim() || env.BUBBLE_EXTRA_CA_CERTS?.trim());
+}
+function isBunRuntime() {
+    return typeof globalThis.Bun !== "undefined";
+}
+function bunProxyForUrl(input, env) {
+    const url = urlFromInput(input);
+    if (!url || shouldBypassProxy(url, env))
+        return undefined;
+    const allProxy = env.ALL_PROXY ?? env.all_proxy;
+    if (url.protocol === "https:")
+        return env.HTTPS_PROXY ?? env.https_proxy ?? allProxy ?? getSystemProxyForUrl(url, env);
+    if (url.protocol === "http:")
+        return env.HTTP_PROXY ?? env.http_proxy ?? allProxy ?? getSystemProxyForUrl(url, env);
+    return undefined;
+}
+function nodeProxyForUrl(input, env) {
+    const url = urlFromInput(input);
+    if (!url || shouldBypassProxy(url, env))
+        return undefined;
+    if (url.protocol === "https:")
+        return env.HTTPS_PROXY ?? env.https_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? getSystemProxyForUrl(url, env);
+    if (url.protocol === "http:")
+        return env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? getSystemProxyForUrl(url, env);
+    return undefined;
+}
+function defaultNodeProxy(env) {
+    return env.HTTPS_PROXY ?? env.https_proxy ?? env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy
+        ?? getSystemProxyForUrl(new URL("https://system-proxy-default.invalid/"), env);
+}
+function bunExtraCaFiles(env) {
+    const bun = globalThis.Bun;
+    if (!bun?.file)
+        return [];
+    return extraCaCertificatePaths(env).map((path) => bun.file(path));
+}
+function urlFromInput(input) {
+    if (input instanceof URL)
+        return input;
+    if (typeof input === "string")
+        return URL.canParse(input) ? new URL(input) : undefined;
+    const url = input.url;
+    return URL.canParse(url) ? new URL(url) : undefined;
+}
+function originFromInput(input) {
+    if (!input)
+        return undefined;
+    return urlFromInput(input)?.origin;
+}
+function shouldBypassProxy(url, env) {
+    const noProxy = (env.NO_PROXY ?? env.no_proxy ?? "").trim();
+    if (!noProxy)
+        return false;
+    if (noProxy === "*")
+        return true;
+    const hostname = url.hostname.toLowerCase();
+    const port = url.port;
+    return noProxy
+        .split(/[,\s]+/)
+        .filter(Boolean)
+        .some((entry) => noProxyEntryMatches(entry.toLowerCase(), hostname, port));
+}
+function noProxyEntryMatches(entry, hostname, port) {
+    const [entryHost, entryPort] = entry.includes(":") ? entry.split(":") : [entry, ""];
+    if (entryPort && entryPort !== port)
+        return false;
+    if (entryHost === hostname)
+        return true;
+    if (entryHost.startsWith("*."))
+        return hostname.endsWith(entryHost.slice(1));
+    if (entryHost.startsWith("."))
+        return hostname.endsWith(entryHost);
+    return false;
+}
+function loadExtraCaCertificates(env, providerName) {
+    const paths = extraCaCertificatePaths(env);
+    return paths.map((path) => {
+        try {
+            return readFileSync(path, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`Failed to read ${providerName} custom CA certificate at ${path}. Check NODE_EXTRA_CA_CERTS or BUBBLE_EXTRA_CA_CERTS.`, {
+                cause: error,
+            });
+        }
+    });
+}
+function extraCaCertificatePaths(env) {
+    const bubbleValue = env.BUBBLE_EXTRA_CA_CERTS?.trim();
+    if (bubbleValue) {
+        return bubbleValue.split(delimiter).map((item) => item.trim()).filter(Boolean);
+    }
+    const nodeValue = env.NODE_EXTRA_CA_CERTS?.trim();
+    return nodeValue ? [nodeValue] : [];
+}
+function isProviderNetworkErrorText(text) {
+    return [
+        /fetch failed/i,
+        /network.*failed/i,
+        /socket connection was closed unexpectedly/i,
+        /\bConnectionClosed\b/i,
+        /\bECONNRESET\b/i,
+        /\bECONNREFUSED\b/i,
+        /\bETIMEDOUT\b/i,
+        /\bEPIPE\b/i,
+        /\bUND_ERR_/i,
+        /socket hang up/i,
+        /Unable to connect\. Is the computer able to access the url\?/i,
+        /certificate/i,
+        /unable to verify/i,
+        /self[- ]signed/i,
+    ].some((pattern) => pattern.test(text));
+}
+function isCertificateErrorText(text) {
+    return [
+        /unknown certificate verification error/i,
+        /certificate (?:verify|verification) (?:failed|error)/i,
+        /unable to verify (?:the )?(?:first )?certificate/i,
+        /UNABLE_TO_(?:VERIFY_LEAF_SIGNATURE|GET_ISSUER_CERT_LOCALLY)/i,
+        /SELF_SIGNED_CERT_IN_CHAIN/i,
+        /DEPTH_ZERO_SELF_SIGNED_CERT/i,
+        /CERT_(?:HAS_EXPIRED|UNTRUSTED|INVALID)/i,
+        /self[- ]signed certificate/i,
+    ].some((pattern) => pattern.test(text));
+}
+function firstMeaningfulErrorMessage(error) {
+    return errorMessageChain(error).find((item) => item && item !== "Error");
+}
+function errorMessageChain(error) {
+    const messages = [];
+    let current = error;
+    for (let depth = 0; current && depth < 8; depth++) {
+        if (current instanceof Error) {
+            messages.push(current.name, current.message);
+            current = current.cause;
+            continue;
+        }
+        if (typeof current === "object") {
+            const record = current;
+            for (const key of ["name", "code", "message"]) {
+                if (typeof record[key] === "string")
+                    messages.push(record[key]);
+            }
+            current = record.cause;
+            continue;
+        }
+        messages.push(String(current));
+        break;
+    }
+    return messages;
+}
+function isTruthyEnv(value) {
+    return /^(1|true|yes)$/i.test(value ?? "");
+}

package/dist/network/retry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared retry policy for provider transports.
+ *
+ * Connection-level failures (nothing received yet) and retryable HTTP
+ * statuses are retried inside the provider with exponential backoff.
+ * Mid-stream interruptions (content already surfaced to the UI) are
+ * signalled with ProviderStreamInterruptedError so the agent loop can
+ * discard the partial assistant message and re-issue the whole request.
+ */
+export declare const MAX_STREAM_INTERRUPTION_RETRIES = 2;
+export declare class ProviderStreamInterruptedError extends Error {
+    readonly isProviderStreamInterruption = true;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function isProviderStreamInterruption(error: unknown): boolean;
+export declare function getProviderMaxRetries(env?: NodeJS.ProcessEnv): number;
+export declare function isRetryableHttpStatus(status: number): boolean;
+/**
+ * Equal-jitter exponential backoff: attempt 1 → 0.5-1s, 2 → 1-2s, 3 → 2-4s,
+ * 4 → 4-8s, capped at 32s. A retry-after hint from the server wins (capped
+ * at 60s) since it reflects actual load shedding.
+ */
+export declare function computeRetryDelayMs(attempt: number, options?: {
+    retryAfterMs?: number;
+}): number;
+export declare function retryAfterMsFromResponse(response: Response): number | undefined;
+export declare function sleepBeforeRetry(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/network/retry.js

@@ -0,0 +1,88 @@
+/**
+ * Shared retry policy for provider transports.
+ *
+ * Connection-level failures (nothing received yet) and retryable HTTP
+ * statuses are retried inside the provider with exponential backoff.
+ * Mid-stream interruptions (content already surfaced to the UI) are
+ * signalled with ProviderStreamInterruptedError so the agent loop can
+ * discard the partial assistant message and re-issue the whole request.
+ */
+const DEFAULT_MAX_RETRIES = 4;
+const MAX_CONFIGURABLE_RETRIES = 10;
+const BASE_DELAY_MS = 1000;
+const MAX_DELAY_MS = 32_000;
+const MAX_RETRY_AFTER_MS = 60_000;
+export const MAX_STREAM_INTERRUPTION_RETRIES = 2;
+const RETRYABLE_HTTP_STATUSES = new Set([408, 429, 500, 502, 503, 504, 529]);
+export class ProviderStreamInterruptedError extends Error {
+    isProviderStreamInterruption = true;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProviderStreamInterruptedError";
+    }
+}
+export function isProviderStreamInterruption(error) {
+    return !!error
+        && typeof error === "object"
+        && error.isProviderStreamInterruption === true;
+}
+export function getProviderMaxRetries(env = process.env) {
+    const raw = env.BUBBLE_PROVIDER_MAX_RETRIES?.trim();
+    if (!raw)
+        return DEFAULT_MAX_RETRIES;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 0)
+        return DEFAULT_MAX_RETRIES;
+    return Math.min(value, MAX_CONFIGURABLE_RETRIES);
+}
+export function isRetryableHttpStatus(status) {
+    return RETRYABLE_HTTP_STATUSES.has(status);
+}
+/**
+ * Equal-jitter exponential backoff: attempt 1 → 0.5-1s, 2 → 1-2s, 3 → 2-4s,
+ * 4 → 4-8s, capped at 32s. A retry-after hint from the server wins (capped
+ * at 60s) since it reflects actual load shedding.
+ */
+export function computeRetryDelayMs(attempt, options) {
+    if (process.env.NODE_ENV === "test")
+        return 0;
+    if (options?.retryAfterMs !== undefined && options.retryAfterMs >= 0) {
+        return Math.min(options.retryAfterMs, MAX_RETRY_AFTER_MS);
+    }
+    const cap = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** Math.max(0, attempt - 1));
+    return Math.floor(cap / 2 + Math.random() * (cap / 2));
+}
+export function retryAfterMsFromResponse(response) {
+    const header = response.headers.get("retry-after")?.trim();
+    if (!header)
+        return undefined;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.round(seconds * 1000);
+    const date = Date.parse(header);
+    if (!Number.isNaN(date))
+        return Math.max(0, date - Date.now());
+    return undefined;
+}
+export function sleepBeforeRetry(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(toAbortError(signal));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(toAbortError(signal));
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function toAbortError(signal) {
+    if (signal?.reason instanceof Error)
+        return signal.reason;
+    const error = new Error(typeof signal?.reason === "string" ? signal.reason : "Request retry aborted.");
+    error.name = "AbortError";
+    return error;
+}

package/dist/network/system-proxy.d.ts

@@ -0,0 +1,18 @@
+export interface SystemProxySettings {
+    httpProxy?: string;
+    httpsProxy?: string;
+    exceptions: string[];
+}
+/**
+ * Resolves the OS-level proxy for a request URL. Used as a fallback when no
+ * proxy environment variables are set, so Bubble follows the same proxy that
+ * browsers and other GUI apps use (e.g. Clash/Surge "system proxy" mode).
+ * Reads `scutil --proxy` on macOS and the Internet Settings registry key on
+ * Windows. Returns undefined on other platforms, when disabled via
+ * BUBBLE_SYSTEM_PROXY=0, or when the URL matches the OS proxy bypass list.
+ */
+export declare function getSystemProxyForUrl(url: URL | undefined, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function systemProxyForUrl(url: URL, settings: SystemProxySettings): string | undefined;
+export declare function parseScutilProxyOutput(output: string): SystemProxySettings | undefined;
+export declare function parseWindowsProxyOutput(output: string): SystemProxySettings | undefined;
+export declare function resetSystemProxyCacheForTests(): void;