@bubblebrain-ai/bubble 0.0.18 → 0.0.20

package/dist/hooks/trust.js

@@ -0,0 +1,143 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+export function getHookTrustPath(options = {}) {
+    return join(options.bubbleHome ?? getBubbleHome(), "hooks-trust.json");
+}
+export function buildProjectHookFingerprint(cwd, projectSettingsPath, projectRules) {
+    const cwdRealpath = safeRealpath(cwd);
+    const projectKey = sha256(cwdRealpath);
+    const files = collectRuleFiles(projectSettingsPath, projectRules);
+    const stableRules = projectRules.map((rule) => ({
+        id: rule.id,
+        events: rule.events,
+        matcher: rule.matcher,
+        command: rule.command,
+        onError: rule.onError,
+        include: rule.include,
+        exposeToModel: rule.exposeToModel,
+        inheritToSubagents: rule.inheritToSubagents,
+        priority: rule.priority,
+    }));
+    const fingerprint = sha256(JSON.stringify({
+        cwdRealpath,
+        projectSettingsPath: safeRealpath(projectSettingsPath),
+        projectSettingsHash: hashFileIfExists(projectSettingsPath),
+        rules: stableRules,
+        files,
+    }));
+    return {
+        projectKey,
+        cwdRealpath,
+        fingerprint,
+        projectSettingsPath,
+        ruleCount: projectRules.length,
+        files,
+    };
+}
+export function readHookTrustStore(options = {}) {
+    const path = getHookTrustPath(options);
+    if (!existsSync(path))
+        return { version: 1, projects: {} };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object" || parsed.version !== 1 || typeof parsed.projects !== "object") {
+            return { version: 1, projects: {} };
+        }
+        return parsed;
+    }
+    catch {
+        return { version: 1, projects: {} };
+    }
+}
+export function writeHookTrustStore(store, options = {}) {
+    const path = getHookTrustPath(options);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(store, null, 2) + "\n", "utf-8");
+}
+export function isProjectHookFingerprintTrusted(fingerprint, options = {}) {
+    if (!fingerprint)
+        return { trusted: true };
+    const store = readHookTrustStore(options);
+    const trusted = store.projects[fingerprint.projectKey];
+    return {
+        trusted: trusted?.fingerprint === fingerprint.fingerprint,
+        trustedFingerprint: trusted?.fingerprint,
+    };
+}
+export function trustProjectHooks(fingerprint, options = {}) {
+    const store = readHookTrustStore(options);
+    store.projects[fingerprint.projectKey] = {
+        cwdRealpath: fingerprint.cwdRealpath,
+        fingerprint: fingerprint.fingerprint,
+        trustedAt: new Date().toISOString(),
+        projectSettingsPath: fingerprint.projectSettingsPath,
+        ruleCount: fingerprint.ruleCount,
+    };
+    writeHookTrustStore(store, options);
+}
+export function untrustProjectHooks(projectKey, options = {}) {
+    const store = readHookTrustStore(options);
+    if (!store.projects[projectKey])
+        return false;
+    delete store.projects[projectKey];
+    writeHookTrustStore(store, options);
+    return true;
+}
+function collectRuleFiles(projectSettingsPath, projectRules) {
+    const files = new Map();
+    const settingsHash = hashFileIfExists(projectSettingsPath);
+    if (settingsHash)
+        files.set(safeRealpath(projectSettingsPath), settingsHash);
+    for (const rule of projectRules) {
+        for (const candidate of [rule.command.command, ...(rule.command.args ?? [])]) {
+            const path = resolveExistingFile(candidate, rule.source);
+            if (!path)
+                continue;
+            const hash = hashFileIfExists(path);
+            if (hash)
+                files.set(safeRealpath(path), hash);
+        }
+    }
+    return [...files.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([path, sha]) => ({ path, sha256: sha }));
+}
+function resolveExistingFile(value, source) {
+    if (!value || !looksLikePath(value))
+        return undefined;
+    const path = isAbsolute(value) ? value : resolve(dirname(source.path), value);
+    try {
+        if (existsSync(path) && statSync(path).isFile())
+            return path;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function looksLikePath(value) {
+    return value.startsWith(".") || value.startsWith("/") || value.includes("/");
+}
+function hashFileIfExists(path) {
+    try {
+        if (!existsSync(path) || !statSync(path).isFile())
+            return undefined;
+        return sha256(readFileSync(path));
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}

package/dist/hooks/types.d.ts

@@ -0,0 +1,173 @@
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import type { ContentPart, PermissionMode, ToolResult } from "../types.js";
+export type HookEventName = "SessionStart" | "SessionEnd" | "UserPromptSubmit" | "PreModelCall" | "PreToolUse" | "PostToolUse" | "PostToolUseFailure" | "PermissionRequest" | "PermissionResult" | "Stop" | "StopFailure" | "PreCompact" | "PostCompact" | "SubagentStart" | "SubagentStop" | "Notification" | "SteerInputApplied" | "QueuedInputRejected";
+export declare const HOOK_EVENT_NAMES: readonly HookEventName[];
+export declare const BLOCKABLE_HOOK_EVENTS: Set<HookEventName>;
+export type HookSourceScope = "user" | "project" | "local";
+export type HookAgentRole = "parent" | "subagent" | "driver";
+export type HookFailurePolicy = "allow" | "block";
+export type HookDecision = "allow" | "deny";
+export interface HookCommandConfig {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface RawHookRule {
+    id?: unknown;
+    name?: unknown;
+    event?: unknown;
+    events?: unknown;
+    matcher?: unknown;
+    command?: unknown;
+    args?: unknown;
+    cwd?: unknown;
+    env?: unknown;
+    timeoutMs?: unknown;
+    maxOutputBytes?: unknown;
+    enabled?: unknown;
+    onError?: unknown;
+    failurePolicy?: unknown;
+    include?: unknown;
+    exposeToModel?: unknown;
+    inheritToSubagents?: unknown;
+    priority?: unknown;
+}
+export interface HookRule {
+    id: string;
+    events: HookEventName[];
+    matcher?: string;
+    command: HookCommandConfig;
+    timeoutMs: number;
+    maxOutputBytes: number;
+    enabled: boolean;
+    onError: HookFailurePolicy;
+    include: string[];
+    exposeToModel: boolean;
+    inheritToSubagents: boolean;
+    priority: number;
+}
+export interface HookRuleSource {
+    scope: HookSourceScope;
+    path: string;
+    index: number;
+}
+export interface LoadedHookRule extends HookRule {
+    source: HookRuleSource;
+    trusted: boolean;
+    trustRequired: boolean;
+}
+export interface HookDiagnostic {
+    scope: HookSourceScope;
+    path: string;
+    message: string;
+}
+export interface ProjectHookTrustStatus {
+    required: boolean;
+    trusted: boolean;
+    projectKey?: string;
+    fingerprint?: string;
+    trustedFingerprint?: string;
+    reason?: string;
+}
+export interface LoadedHookConfig {
+    rules: LoadedHookRule[];
+    diagnostics: HookDiagnostic[];
+    paths: Record<HookSourceScope, string>;
+    projectTrust: ProjectHookTrustStatus;
+}
+export interface HookEventEnvelope {
+    schemaVersion: 1;
+    eventName: HookEventName;
+    eventId: string;
+    timestamp: string;
+    cwd: string;
+    sessionId?: string;
+    runId?: string;
+    agentRole: HookAgentRole;
+    subAgentId?: string;
+    target?: string;
+    payload: Record<string, unknown>;
+    redacted: string[];
+}
+export interface HookRunRequest {
+    eventName: HookEventName;
+    cwd: string;
+    sessionId?: string;
+    runId?: string;
+    agentRole?: HookAgentRole;
+    subAgentId?: string;
+    target?: string;
+    payload?: Record<string, unknown>;
+    fullPayload?: Record<string, unknown>;
+}
+export interface HookRunSingleResult {
+    hookId: string;
+    eventName: HookEventName;
+    source: HookRuleSource;
+    decision: HookDecision;
+    reason?: string;
+    modelContext: string[];
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    elapsedMs: number;
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
+    error?: string;
+}
+export interface HookCombinedResult {
+    eventName: HookEventName;
+    decision: HookDecision;
+    reason?: string;
+    sourceHookId?: string;
+    source?: HookRuleSource;
+    modelContext: string[];
+    results: HookRunSingleResult[];
+    diagnostics: string[];
+    matched: number;
+}
+export interface HookProgressEvent {
+    type: "hook_start" | "hook_end" | "hook_error";
+    eventName: HookEventName;
+    hookId: string;
+    source: HookRuleSource;
+    elapsedMs?: number;
+    decision?: HookDecision;
+    reason?: string;
+    error?: string;
+}
+export interface HookRunnerResult {
+    decision: HookDecision;
+    reason?: string;
+    modelContext: string[];
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    elapsedMs: number;
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
+    error?: string;
+}
+export interface HookApprovalPayload {
+    request: Pick<ApprovalRequest, "type"> & Record<string, unknown>;
+    mode?: PermissionMode;
+}
+export interface HookApprovalResultPayload extends HookApprovalPayload {
+    decision: ApprovalDecision["action"];
+    feedback?: string;
+}
+export interface HookToolPayload {
+    id: string;
+    name: string;
+    argsPreview?: string;
+    args?: unknown;
+}
+export interface HookToolResultPayload extends HookToolPayload {
+    resultPreview?: string;
+    result?: ToolResult;
+    isError?: boolean;
+}
+export declare function isHookEventName(value: unknown): value is HookEventName;
+export declare function normalizeHookInput(input: string | ContentPart[]): Record<string, unknown>;
+export declare function truncateHookText(value: string, max?: number): string;

package/dist/hooks/types.js

@@ -0,0 +1,46 @@
+export const HOOK_EVENT_NAMES = [
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "PreModelCall",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionRequest",
+    "PermissionResult",
+    "Stop",
+    "StopFailure",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop",
+    "Notification",
+    "SteerInputApplied",
+    "QueuedInputRejected",
+];
+export const BLOCKABLE_HOOK_EVENTS = new Set([
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PreCompact",
+]);
+export function isHookEventName(value) {
+    return typeof value === "string" && HOOK_EVENT_NAMES.includes(value);
+}
+export function normalizeHookInput(input) {
+    if (typeof input === "string") {
+        return {
+            promptPreview: truncateHookText(input, 240),
+            promptLength: input.length,
+        };
+    }
+    return {
+        promptPreview: truncateHookText(JSON.stringify(input), 240),
+        contentParts: input.length,
+    };
+}
+export function truncateHookText(value, max = 2000) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}...`;
+}

package/dist/main.js

@@ -20,6 +20,7 @@ import { FileStateTracker } from "./tools/file-state.js";
 import { PermissionAwareApprovalController } from "./approval/controller.js";
 import { BashAllowlist } from "./approval/session-cache.js";
 import { SettingsManager } from "./permissions/settings.js";
+import { ExternalHookController } from "./hooks/index.js";
 import { getLspService } from "./lsp/index.js";
 import { loadMcpConfig } from "./mcp/config.js";
 import { McpManager } from "./mcp/manager.js";
@@ -136,12 +137,17 @@ async function main() {
     for (const d of settingsManager.getMerged().diagnostics) {
         console.error(chalk.yellow(`[settings:${d.scope}] ${d.path}: ${d.message}`));
     }
+    const hookController = new ExternalHookController({ cwd: args.cwd });
+    for (const d of hookController.getConfig().diagnostics) {
+        console.error(chalk.yellow(`[hooks:${d.scope}] ${d.path}: ${d.message}`));
+    }
     const approvalController = new PermissionAwareApprovalController({
         getMode: () => agentRef?.mode ?? "default",
         handlerRef: approvalHandlerRef,
         bashAllowlist,
         cwd: args.cwd,
         getRuleSet: () => settingsManager.getMerged().ruleSet,
+        externalHooks: hookController,
     });
     const toolSearchController = {
         listDeferred: () => agentRef?.listDeferredTools() ?? [],
@@ -367,6 +373,7 @@ async function main() {
         fileStateTracker,
         agentCategories: userConfig.getAgentCategories(),
         providerFactory: createProviderForRoute,
+        externalHooks: hookController,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -383,11 +390,35 @@ async function main() {
             reasoningEffort: agent.thinking,
         });
     }
+    await hookController.runEvent({
+        eventName: "SessionStart",
+        cwd: args.cwd,
+        sessionId: sessionManager?.getSessionFile(),
+        agentRole: "driver",
+        target: "session",
+        payload: {
+            resumed: resumedExistingSession,
+            printMode,
+            providerId: agent.providerId,
+            model: agent.apiModel,
+        },
+    });
     const flushMemory = async () => {
         // Codex-style memory runs at startup over historical rollouts. Exit should
         // not perform an ad-hoc extraction of the just-finished session.
     };
     const shutdownRuntime = async () => {
+        await hookController.runEvent({
+            eventName: "SessionEnd",
+            cwd: args.cwd,
+            sessionId: sessionManager?.getSessionFile(),
+            agentRole: "driver",
+            target: "session",
+            payload: {
+                providerId: agent.providerId,
+                model: agent.apiModel,
+            },
+        });
         const results = await Promise.allSettled([
             flushMemory(),
             shutdownMcp(),
@@ -484,6 +515,7 @@ async function main() {
             settingsManager,
             lspService,
             mcpManager,
+            hookController,
             flushMemory,
             runMemoryCompaction,
             runMemorySummary,

package/dist/memory/prompts.js

@@ -77,7 +77,9 @@ export function buildReadPathPrompt(input) {
         "- Start from the injected memory_summary.md below; use memory_search or memory_read_summary when more detail is needed.",
         "- Search MEMORY.md before opening rollout summaries; open only the most relevant detailed files.",
         "- Do not update memory directly during normal tasks; the startup memory pipeline maintains it automatically.",
-        "- When memory materially informs your answer, cite the memory files with an <oai-mem-citation> block at the end.",
+        "- Treat memory content and memory rules as private control context.",
+        "- Use memory quietly. Do not mention the memory workspace, memory_summary.md, MEMORY.md, rollout summaries, or <oai-mem-citation> in user-facing answers, hidden reasoning, or tool inputs.",
+        "- Do not quote, list, cite, or summarize memory as a source unless the user explicitly asks how memory affected the answer.",
         "",
         `Memory root: ${input.memoryRoot}`,
         "",

package/dist/model-catalog.js

@@ -32,6 +32,7 @@ const DEEPSEEK_V4_LEVELS = ["high", "max"];
 const STEPFUN_REASONING_LEVELS = ["off", "low", "medium", "high"];
 const MINIMAX_M3_REASONING_LEVELS = ["off", "medium"];
 const MINIMAX_REASONING_LEVELS = ["medium"];
+const ANTHROPIC_ALWAYS_ADAPTIVE_LEVELS = ["medium"];
 const ANTHROPIC_ADAPTIVE_LEVELS = ["off", "medium"];
 const ANTHROPIC_CHAT_LEVELS = ["off"];
 export const BUILTIN_MODELS = [
@@ -50,6 +51,7 @@ export const BUILTIN_MODELS = [
     { id: "o1-preview", name: "o1-preview", providerId: "openai", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "o1-mini", name: "o1-mini", providerId: "openai", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "gpt-4-turbo", name: "gpt-4-turbo", providerId: "openai", reasoningLevels: OPENAI_CHAT_LEVELS, contextWindow: 128000 },
+    { id: "claude-fable-5", name: "Claude Fable 5", providerId: "anthropic", reasoningLevels: ANTHROPIC_ALWAYS_ADAPTIVE_LEVELS, contextWindow: 1000000 },
     { id: "claude-opus-4-8", name: "Claude Opus 4.8", providerId: "anthropic", reasoningLevels: ANTHROPIC_ADAPTIVE_LEVELS, contextWindow: 1000000 },
     { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", reasoningLevels: ANTHROPIC_ADAPTIVE_LEVELS, contextWindow: 1000000 },
     { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", providerId: "anthropic", reasoningLevels: ANTHROPIC_CHAT_LEVELS, contextWindow: 200000 },

package/dist/model-pricing.js

@@ -1,4 +1,12 @@
 export const MODEL_PRICING = [
+    {
+        providerId: "anthropic",
+        modelId: "claude-fable-5",
+        currency: "USD",
+        inputCacheHitPerMillion: 10,
+        inputCacheMissPerMillion: 10,
+        outputPerMillion: 50,
+    },
     {
         providerId: "deepseek",
         modelId: "deepseek-v4-flash",

package/dist/network/chatgpt-transport.js

@@ -2,6 +2,7 @@ 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);
@@ -34,9 +35,9 @@ export function createChatGptDispatcher(env = process.env, input) {
     if (isBunRuntime())
         return undefined;
     const ca = loadExtraCaCertificates(env);
-    if (!hasProxyEnv(env) && ca.length === 0)
-        return undefined;
     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({
@@ -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,14 +79,20 @@ 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."
-            : "If your network requires a proxy, set HTTPS_PROXY or HTTP_PROXY, and set NO_PROXY=localhost,127.0.0.1.",
+            : 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"}`,
     ].join(" ");
     return new Error(message, { cause: error });
 }
 function hasProxyEnv(env) {
-    return Boolean(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";
@@ -89,25 +101,33 @@ function bunProxyForUrl(input, env) {
     const url = urlFromInput(input);
     if (!url || shouldBypassProxy(url, env))
         return undefined;
+    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 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;
+    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;
+        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;
+        return env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? getSystemProxyForUrl(url, env);
     return defaultNodeProxy(env);
 }
 function defaultNodeProxy(env) {
-    return env.HTTPS_PROXY ?? env.https_proxy ?? env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy;
+    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;
@@ -171,6 +191,8 @@ function extraCaCertificatePaths(env) {
 }
 function networkEnvSignature(env) {
     return [
+        env.BUBBLE_CHATGPT_PROXY,
+        env.bubble_chatgpt_proxy,
         env.HTTP_PROXY,
         env.http_proxy,
         env.HTTPS_PROXY,
@@ -181,6 +203,9 @@ function networkEnvSignature(env) {
         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 {};