@bubblebrain-ai/bubble 0.0.18 → 0.0.20

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;

package/dist/network/system-proxy.js

@@ -0,0 +1,175 @@
+import { execFileSync } from "node:child_process";
+const CACHE_TTL_MS = 30_000;
+const FALSE_VALUES = new Set(["0", "false", "no", "off"]);
+let cache;
+/**
+ * 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 function getSystemProxyForUrl(url, env = process.env) {
+    if (!url || isSystemProxyDisabled(env))
+        return undefined;
+    const settings = readSystemProxySettings();
+    if (!settings)
+        return undefined;
+    return systemProxyForUrl(url, settings);
+}
+export function systemProxyForUrl(url, settings) {
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        return undefined;
+    const hostname = url.hostname.toLowerCase();
+    if (isLoopbackHostname(hostname))
+        return undefined;
+    if (settings.exceptions.some((entry) => systemExceptionMatches(entry, hostname)))
+        return undefined;
+    if (url.protocol === "https:")
+        return settings.httpsProxy ?? settings.httpProxy;
+    return settings.httpProxy ?? settings.httpsProxy;
+}
+export function parseScutilProxyOutput(output) {
+    const settings = {
+        httpProxy: proxyUrlFromKeys(output, "HTTP"),
+        httpsProxy: proxyUrlFromKeys(output, "HTTPS"),
+        exceptions: parseExceptionsList(output),
+    };
+    if (!settings.httpProxy && !settings.httpsProxy)
+        return undefined;
+    return settings;
+}
+export function parseWindowsProxyOutput(output) {
+    const enable = readRegistryValue(output, "ProxyEnable", "REG_DWORD");
+    if (!enable || Number.parseInt(enable, 16) !== 1)
+        return undefined;
+    const server = readRegistryValue(output, "ProxyServer", "REG_SZ");
+    if (!server)
+        return undefined;
+    const { httpProxy, httpsProxy } = parseWindowsProxyServer(server);
+    if (!httpProxy && !httpsProxy)
+        return undefined;
+    const override = readRegistryValue(output, "ProxyOverride", "REG_SZ") ?? "";
+    const exceptions = override
+        .split(";")
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean);
+    return { httpProxy, httpsProxy, exceptions };
+}
+// ProxyServer is either "host:port" (all protocols) or per-protocol
+// "http=host:port;https=host:port;ftp=...;socks=..." — ftp/socks are ignored.
+function parseWindowsProxyServer(value) {
+    if (!value.includes("=")) {
+        const url = normalizeProxyHostPort(value);
+        return { httpProxy: url, httpsProxy: url };
+    }
+    const result = {};
+    for (const part of value.split(";")) {
+        const [protocol, hostPort] = part.split("=").map((item) => item.trim());
+        if (!protocol || !hostPort)
+            continue;
+        const url = normalizeProxyHostPort(hostPort);
+        if (!url)
+            continue;
+        if (protocol.toLowerCase() === "http")
+            result.httpProxy = url;
+        if (protocol.toLowerCase() === "https")
+            result.httpsProxy = url;
+    }
+    return result;
+}
+function normalizeProxyHostPort(value) {
+    const trimmed = value.trim().replace(/^https?:\/\//i, "");
+    const match = trimmed.match(/^([^\s:]+):(\d+)$/);
+    if (!match)
+        return undefined;
+    const port = Number(match[2]);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        return undefined;
+    return `http://${match[1]}:${port}`;
+}
+function readRegistryValue(output, key, type) {
+    const match = output.match(new RegExp(`^\\s*${key}\\s+${type}\\s+(.+?)\\s*$`, "m"));
+    return match?.[1];
+}
+export function resetSystemProxyCacheForTests() {
+    cache = undefined;
+}
+function isSystemProxyDisabled(env) {
+    const value = env.BUBBLE_SYSTEM_PROXY?.trim().toLowerCase();
+    return !!value && FALSE_VALUES.has(value);
+}
+function readSystemProxySettings() {
+    if (process.platform !== "darwin" && process.platform !== "win32")
+        return undefined;
+    const now = Date.now();
+    if (cache && now - cache.at < CACHE_TTL_MS)
+        return cache.settings;
+    let settings;
+    try {
+        settings = process.platform === "darwin" ? readMacProxySettings() : readWindowsProxySettings();
+    }
+    catch {
+        settings = undefined;
+    }
+    cache = { at: now, settings };
+    return settings;
+}
+function readMacProxySettings() {
+    const output = execFileSync("scutil", ["--proxy"], { encoding: "utf-8", timeout: 2000 });
+    return parseScutilProxyOutput(output);
+}
+function readWindowsProxySettings() {
+    const output = execFileSync("reg", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"], { encoding: "utf-8", timeout: 2000, windowsHide: true });
+    return parseWindowsProxyOutput(output);
+}
+function proxyUrlFromKeys(output, prefix) {
+    if (readScalar(output, `${prefix}Enable`) !== "1")
+        return undefined;
+    const host = readScalar(output, `${prefix}Proxy`);
+    const port = Number(readScalar(output, `${prefix}Port`));
+    if (!host || !Number.isInteger(port) || port <= 0 || port > 65535)
+        return undefined;
+    return `http://${host}:${port}`;
+}
+function readScalar(output, key) {
+    const match = output.match(new RegExp(`^\\s*${key}\\s*:\\s*(\\S+)`, "m"));
+    return match?.[1];
+}
+function parseExceptionsList(output) {
+    const match = output.match(/ExceptionsList\s*:\s*<array>\s*\{([\s\S]*?)\}/);
+    if (!match)
+        return [];
+    return [...match[1].matchAll(/^\s*\d+\s*:\s*(\S+)/gm)].map((item) => item[1].toLowerCase());
+}
+function systemExceptionMatches(entry, hostname) {
+    if (entry === "<local>")
+        return !hostname.includes(".");
+    // CIDR entries (e.g. 192.168.0.0/16) would need the resolved IP to match;
+    // skip them so we never wrongly bypass the proxy for public hostnames.
+    if (entry.includes("/"))
+        return false;
+    if (entry.startsWith("*."))
+        return hostname === entry.slice(2) || hostname.endsWith(entry.slice(1));
+    // Windows ProxyOverride allows wildcards anywhere, e.g. 127.* or 192.168.*
+    if (entry.includes("*"))
+        return wildcardMatches(entry, hostname);
+    if (entry.startsWith("."))
+        return hostname.endsWith(entry);
+    return entry === hostname;
+}
+function wildcardMatches(pattern, hostname) {
+    const regex = new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*")}$`);
+    return regex.test(hostname);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isLoopbackHostname(hostname) {
+    return hostname === "localhost"
+        || hostname === "::1"
+        || hostname === "[::1]"
+        || hostname.startsWith("127.")
+        || hostname.endsWith(".localhost");
+}

package/dist/provider-anthropic.d.ts

@@ -79,6 +79,7 @@ export declare function buildAnthropicRequest(options: AnthropicProviderOptions,
     thinkingLevel?: ThinkingLevel;
     stream?: boolean;
 }): AnthropicRequest;
+export declare function resolveAnthropicMaxTokens(options: AnthropicProviderOptions, model: string): number;
 export declare function supportsAnthropicPromptCache(options: AnthropicProviderOptions, model: string): boolean;
 export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean): {
     system: string;