@bubblebrain-ai/bubble 0.0.17 → 0.0.19

package/dist/agent/tool-intent.js

@@ -55,7 +55,6 @@ export function analyzeToolIntent(toolCall) {
         case "write":
             return { family: "write" };
         case "edit":
-        case "apply_patch":
             return { family: "edit" };
         case "web_search":
         case "web_fetch":

package/dist/agent.d.ts

@@ -87,6 +87,7 @@ export declare class Agent {
     unlockDeferredTools(names: string[]): void;
     /** All deferred tools in this session (for tool_search to inspect). */
     listDeferredTools(): ToolRegistryEntry[];
+    getSystemPromptToolOptions(): Pick<import("./system-prompt.js").SystemPromptOptions, "tools" | "toolSnippets" | "guidelines">;
     getContextUsageSnapshot(): ContextUsageSnapshot;
     resetContextUsageAnchor(): void;
     /** Whether a given tool is deferred and not yet unlocked. */

package/dist/agent.js

@@ -9,9 +9,9 @@ import { estimateContextTokens, getContextBudget } from "./context/budget.js";
 import { buildContextUsageSnapshot } from "./context/usage.js";
 import { isContextOverflowError } from "./context/overflow.js";
 import { projectMessages } from "./context/projector.js";
-import { aggressivePruneMessages } from "./context/prune.js";
+import { aggressivePruneMessages, markStableCurrentToolResultsForCache } from "./context/prune.js";
 import { truncateToolOutputForModel } from "./context/tool-output-truncate.js";
-import { buildDeferredToolsReminder, buildToolFreezeReminder, isPermissionModeReminder, reminderForMode } from "./prompt/reminders.js";
+import { buildDeferredToolsReminder, buildToolFreezeReminder, reminderForMode } from "./prompt/reminders.js";
 import { HookBus } from "./orchestrator/hooks.js";
 import { createDefaultHooks } from "./orchestrator/default-hooks.js";
 import { resolveModelRoute, resolveSubagentRoute } from "./agent/categories.js";
@@ -24,6 +24,7 @@ import { createStreamingInternalReminderSanitizer, sanitizeAssistantProviderMeta
 import { buildSystemPrompt } from "./system-prompt.js";
 import { isOnlyProviderProtocolArtifacts, stripProviderProtocolArtifacts } from "./provider-artifacts.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
+import { buildToolPromptOptions } from "./tools/prompt-metadata.js";
 import { stopAutoServersForSession } from "./tools/server-manager.js";
 import { summarizeAgentEventForTrace, summarizeTraceError, summarizeTraceMessage, summarizeTraceToolResult, summarizeTraceValue, traceEvent, } from "./debug-trace.js";
 const MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 3;
@@ -31,7 +32,6 @@ const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
 const RESIDENT_HISTORY_MESSAGE_LIMIT = 160;
 const RESIDENT_HISTORY_CHAR_SOFT_LIMIT = 256 * 1024;
 const RESIDENT_HISTORY_CHAR_HARD_LIMIT = 512 * 1024;
-const RESIDENT_HISTORY_HEAP_SOFT_LIMIT = 512 * 1024 * 1024;
 const RESIDENT_HISTORY_HEAP_HARD_LIMIT = 768 * 1024 * 1024;
 const MAX_EMPTY_ASSISTANT_RECOVERIES = 1;
 const EMPTY_ASSISTANT_RECOVERY_REMINDER = "The previous model response contained no user-visible assistant content and no tool calls. " +
@@ -131,6 +131,9 @@ export class Agent {
     listDeferredTools() {
         return [...this.tools.values()].filter((t) => t.deferred);
     }
+    getSystemPromptToolOptions() {
+        return buildToolPromptOptions(this.getActiveToolEntries());
+    }
     getContextUsageSnapshot() {
         return buildContextUsageSnapshot({
             providerId: this.providerId,
@@ -153,17 +156,20 @@ export class Agent {
     }
     getActiveToolEntries() {
         return [...this.tools.values()]
-            .filter((tool) => !tool.deferred || this.unlockedDeferred.has(tool.name))
-            .filter((tool) => this._mode === "plan" || tool.name !== "exit_plan_mode");
+            .filter((tool) => !tool.deferred || this.unlockedDeferred.has(tool.name));
     }
     injectSystemReminder(content) {
         this.appendMessage({ role: "meta", kind: "system-reminder", content });
     }
     injectModeReminder() {
-        this.messages = this.messages.filter((message) => !(message.role === "meta"
-            && message.kind === "system-reminder"
-            && isPermissionModeReminder(message.content)));
-        this.injectSystemReminder(reminderForMode(this._mode));
+        const reminder = reminderForMode(this._mode);
+        const last = this.messages.at(-1);
+        if (last?.role === "meta"
+            && last.kind === "system-reminder"
+            && last.content === reminder) {
+            return;
+        }
+        this.injectSystemReminder(reminder);
     }
     get model() {
         return this._model;
@@ -398,11 +404,9 @@ export class Agent {
                 };
                 await hookBus.runBeforeModelCall(beforeModelCallCtx);
                 toolEntries = beforeModelCallCtx.toolEntries;
-                if (this._mode !== "plan") {
-                    toolEntries = toolEntries.filter((t) => t.name !== "exit_plan_mode");
-                }
                 flushGovernorReminders();
-                const toolDefinitions = ((hookState.forceTextOnlyReason ? [] : toolEntries))
+                const textOnly = !!hookState.forceTextOnlyReason;
+                const toolDefinitions = toolEntries
                     .map((t) => ({
                     name: t.name,
                     description: t.description,
@@ -417,6 +421,7 @@ export class Agent {
                 const bufferedStreamingToolCallIds = new Set();
                 const discoveryBarrier = hookState.discoveryBarrier;
                 try {
+                    markStableCurrentToolResultsForCache(this.messages);
                     const projectedMessages = projectMessages(this.messages, {
                         mode: "budgeted",
                         providerId: this.providerId,
@@ -434,11 +439,12 @@ export class Agent {
                         toolCount: toolDefinitions.length,
                         thinkingLevel: this.thinkingLevel,
                         mode: this._mode,
-                        requestFingerprint: buildProviderRequestFingerprint(projectedMessages, toolDefinitions, this.providerId),
+                        requestFingerprint: buildProviderRequestFingerprint(projectedMessages, toolDefinitions, this.providerId, toolDefinitions.length > 0 ? (textOnly ? "none" : "auto") : undefined),
                     }, traceContext);
                     const stream = this.provider.streamChat(projectedMessages, {
                         model: this.apiModel,
                         tools: toolDefinitions,
+                        toolChoice: toolDefinitions.length > 0 ? (textOnly ? "none" : "auto") : undefined,
                         temperature: this.temperature,
                         thinkingLevel: this.thinkingLevel,
                         abortSignal,
@@ -1366,7 +1372,7 @@ export class Agent {
             thinkingLevel: route.thinkingLevel,
             mode: "plan",
             workingDir: cwd,
-            tools: childToolNames,
+            ...buildToolPromptOptions(tools),
             memoryPrompt: childToolNames.some((name) => name === "memory_search" || name === "memory_read_summary")
                 ? this.memoryPrompt
                 : undefined,
@@ -1518,8 +1524,7 @@ export class Agent {
             || heapUsed >= RESIDENT_HISTORY_HEAP_HARD_LIMIT;
         const shouldCompact = !!budget?.shouldCompact
             || candidate.length >= RESIDENT_HISTORY_MESSAGE_LIMIT
-            || residentChars >= RESIDENT_HISTORY_CHAR_SOFT_LIMIT
-            || heapUsed >= RESIDENT_HISTORY_HEAP_SOFT_LIMIT;
+            || residentChars >= RESIDENT_HISTORY_CHAR_SOFT_LIMIT;
         if (shouldAggressivelyPrune) {
             candidate = aggressivePruneMessages(candidate);
         }
@@ -1627,7 +1632,22 @@ export class Agent {
                 metadata: { kind: "security", reason: "args_corrupt" },
             };
         }
-        const missingRequired = findMissingRequiredArgs(tool.parameters, toolCall.parsedArgs);
+        let preparedArgs = toolCall.parsedArgs;
+        if (tool.prepareArguments) {
+            try {
+                preparedArgs = tool.prepareArguments(preparedArgs);
+            }
+            catch (err) {
+                return {
+                    content: `Error: Tool "${toolCall.name}" arguments could not be normalized before execution: ` +
+                        `${err instanceof Error ? err.message : String(err)}. Re-issue the call with valid arguments.`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: { kind: "security", reason: "args_prepare_failed" },
+                };
+            }
+        }
+        const missingRequired = findMissingRequiredArgs(tool.parameters, preparedArgs);
         if (missingRequired.length > 0) {
             return {
                 content: `Error: Tool "${toolCall.name}" was called without required argument${missingRequired.length === 1 ? "" : "s"}: ${missingRequired.map((name) => `"${name}"`).join(", ")}. ` +
@@ -1638,7 +1658,7 @@ export class Agent {
             };
         }
         try {
-            return await tool.execute(toolCall.parsedArgs, {
+            return await tool.execute(preparedArgs, {
                 cwd,
                 sessionID: this.sessionID,
                 abortSignal,
@@ -1716,7 +1736,7 @@ function appendProviderContentBlock(message, provider, block) {
         },
     };
 }
-function buildProviderRequestFingerprint(messages, tools, providerId) {
+function buildProviderRequestFingerprint(messages, tools, providerId, toolChoice) {
     const roleCounts = {};
     let contentChars = 0;
     let reasoningChars = 0;
@@ -1756,11 +1776,24 @@ function buildProviderRequestFingerprint(messages, tools, providerId) {
             contentChars += message.content.length;
         }
     }
+    const systemMessages = messages.filter((message) => message.role === "system");
+    const bodyMessages = messages.filter((message) => message.role !== "system");
+    const systemJsonBytes = Buffer.byteLength(JSON.stringify(systemMessages), "utf8");
+    const bodyJsonBytes = Buffer.byteLength(JSON.stringify(bodyMessages), "utf8");
+    const toolSchemaJsonBytes = Buffer.byteLength(JSON.stringify(tools), "utf8");
     return {
         roleCounts,
         estimatedTokens: estimateContextTokens(messages, providerId),
         projectedJsonBytes: Buffer.byteLength(JSON.stringify(messages), "utf8"),
-        toolSchemaJsonBytes: Buffer.byteLength(JSON.stringify(tools), "utf8"),
+        systemJsonBytes,
+        bodyJsonBytes,
+        toolSchemaJsonBytes,
+        staticPrefixJsonBytes: Buffer.byteLength(JSON.stringify({
+            system: systemMessages,
+            tools,
+            tool_choice: toolChoice,
+        }), "utf8"),
+        toolChoice,
         contentChars,
         reasoningChars,
         toolResultChars,

package/dist/context/prune.d.ts

@@ -1,5 +1,6 @@
 import type { Message } from "../types.js";
 export declare function pruneMessages<T extends Message>(messages: T[]): T[];
+export declare function markStableCurrentToolResultsForCache(messages: Message[]): void;
 /**
  * Aggressive variant of pruneMessages: drops the content of every prunable
  * tool output except the latest unresolved tool turn that the model still

package/dist/context/prune.js

@@ -3,6 +3,8 @@ const PRUNEABLE_TOOLS = new Set([
 ]);
 const TOOL_RESULT_KEEP_COUNT = 2;
 const MIN_PRUNE_LENGTH = 240;
+const CACHE_STABLE_PROJECTION_KEY = "cacheStableProjection";
+const CACHE_STABLE_FULL_PROJECTION = "full";
 export function pruneMessages(messages) {
     const toolNameByCallId = new Map();
     const pruneCandidates = [];
@@ -19,6 +21,9 @@ export function pruneMessages(messages) {
         if (message.role !== "tool") {
             continue;
         }
+        if (isCacheStableFullToolResult(message)) {
+            continue;
+        }
         if (protectedToolCallIds.has(message.toolCallId)) {
             const toolName = toolNameByCallId.get(message.toolCallId);
             if (toolName && shouldPruneToolResult(toolName, message.content)) {
@@ -49,6 +54,30 @@ export function pruneMessages(messages) {
         };
     });
 }
+export function markStableCurrentToolResultsForCache(messages) {
+    const protectedToolCallIds = collectProtectedToolCallIds(messages);
+    if (protectedToolCallIds.size === 0)
+        return;
+    const toolNameByCallId = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant" || !message.toolCalls)
+            continue;
+        for (const toolCall of message.toolCalls) {
+            toolNameByCallId.set(toolCall.id, toolCall.name);
+        }
+    }
+    for (const message of messages) {
+        if (message.role !== "tool" || !protectedToolCallIds.has(message.toolCallId))
+            continue;
+        const toolName = toolNameByCallId.get(message.toolCallId);
+        if (!toolName || !shouldPruneToolResult(toolName, message.content))
+            continue;
+        message.metadata = {
+            ...message.metadata,
+            [CACHE_STABLE_PROJECTION_KEY]: CACHE_STABLE_FULL_PROJECTION,
+        };
+    }
+}
 function shouldPruneToolResult(toolName, content) {
     if (!PRUNEABLE_TOOLS.has(toolName)) {
         return false;
@@ -64,6 +93,9 @@ function shouldPruneToolResult(toolName, content) {
 function summarizePrunedToolResult(toolName, content) {
     return `[${toolName} output omitted to control context size; original length ${content.length} chars]`;
 }
+function isCacheStableFullToolResult(message) {
+    return message.metadata?.[CACHE_STABLE_PROJECTION_KEY] === CACHE_STABLE_FULL_PROJECTION;
+}
 /**
  * Aggressive variant of pruneMessages: drops the content of every prunable
  * tool output except the latest unresolved tool turn that the model still

package/dist/feishu/agent-host/run-driver.js

@@ -19,7 +19,7 @@ import { BashAllowlist } from "../../approval/session-cache.js";
 import { getLspService } from "../../lsp/index.js";
 import { buildSystemPrompt } from "../../system-prompt.js";
 import { FileStateTracker } from "../../tools/file-state.js";
-import { createAllTools } from "../../tools/index.js";
+import { buildToolPromptOptions, createAllTools } from "../../tools/index.js";
 import { displayModel, encodeModel, decodeModel } from "../../provider-registry.js";
 import { buildMemoryPrompt, recordMemoryCitations } from "../../memory/index.js";
 import { getDefaultThinkingLevel } from "../../provider-transform.js";
@@ -94,7 +94,7 @@ export class RunDriver {
             thinkingLevel,
             mode: initialMode,
             workingDir: session.cwd,
-            tools: tools.map((t) => t.name),
+            ...buildToolPromptOptions(tools.filter((tool) => !tool.deferred)),
             memoryPrompt,
         });
         const budgetLedger = new BudgetLedger();

package/dist/feishu/card/run-state.js

@@ -211,6 +211,7 @@ function mergeUsage(prev, next) {
         completionTokens: prev.completionTokens + (next.completionTokens ?? 0),
         promptCacheHitTokens: (prev.promptCacheHitTokens ?? 0) + (next.promptCacheHitTokens ?? 0),
         promptCacheMissTokens: (prev.promptCacheMissTokens ?? 0) + (next.promptCacheMissTokens ?? 0),
+        cacheCreationTokens: (prev.cacheCreationTokens ?? 0) + (next.cacheCreationTokens ?? 0),
         reasoningTokens: (prev.reasoningTokens ?? 0) + (next.reasoningTokens ?? 0),
         totalTokens: (prev.totalTokens ?? 0) + (next.totalTokens ?? 0),
     };

package/dist/main.js

@@ -8,13 +8,14 @@ import { BudgetLedger } from "./agent/budget-ledger.js";
 import { parseArgs, printHelp } from "./cli.js";
 import { UserConfig } from "./config.js";
 import { createProviderInstance, createUnavailableProvider } from "./provider.js";
+import { resolveConfiguredModel } from "./model-selection.js";
 import { getDefaultThinkingLevel } from "./provider-transform.js";
 import { ProviderRegistry, displayModel, encodeModel, decodeModel } from "./provider-registry.js";
 import { SessionManager } from "./session.js";
 import { createSessionTitleUpdater } from "./session-title.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { SkillRegistry } from "./skills/registry.js";
-import { createAllTools } from "./tools/index.js";
+import { buildToolPromptOptions, createAllTools } from "./tools/index.js";
 import { FileStateTracker } from "./tools/file-state.js";
 import { PermissionAwareApprovalController } from "./approval/controller.js";
 import { BashAllowlist } from "./approval/session-cache.js";
@@ -244,18 +245,19 @@ async function main() {
     }
     sessionPromptCacheKey = sessionManager.getOrCreatePromptCacheKey();
     // Model resolution:
-    // 1. Session metadata  2. User-configured default model  3. CLI flag
+    // 1. CLI flag  2. Session metadata  3. User-configured default model
     // No implicit built-in model fallback.
     const fallbackProviderId = defaultProvider?.id || "";
     const sessionModel = sessionManager?.getMetadata().model;
-    const configuredModel = sessionModel ?? userConfig.getDefaultModel() ?? args.model;
+    const defaultModel = userConfig.getDefaultModel();
     const sessionThinkingLevel = sessionManager?.getMetadata().thinkingLevel;
     const configuredThinkingLevel = userConfig.getDefaultThinkingLevel();
-    const normalizedConfiguredModel = configuredModel
-        ? (configuredModel.includes(":")
-            ? configuredModel
-            : (fallbackProviderId ? encodeModel(fallbackProviderId, configuredModel) : ""))
-        : "";
+    const normalizedConfiguredModel = resolveConfiguredModel({
+        cliModel: args.model,
+        sessionModel,
+        defaultModel,
+        fallbackProviderId,
+    });
     const { providerId: effectiveProviderId, modelId: effectiveModelId } = normalizedConfiguredModel
         ? decodeModel(normalizedConfiguredModel)
         : { providerId: undefined, modelId: "" };
@@ -288,7 +290,7 @@ async function main() {
         thinkingLevel: initialThinkingLevel,
         mode: initialMode,
         workingDir: args.cwd,
-        tools: tools.map((tool) => tool.name),
+        ...buildToolPromptOptions(tools.filter((tool) => !tool.deferred)),
         memoryPrompt,
     });
     const traceInfo = configureDebugTrace({

package/dist/model-pricing.js

@@ -38,7 +38,8 @@ export function calculateUsageCost(providerId, modelId, usage) {
     if (!pricing)
         return undefined;
     const hasCacheBreakdown = typeof usage.promptCacheHitTokens === "number"
-        || typeof usage.promptCacheMissTokens === "number";
+        || typeof usage.promptCacheMissTokens === "number"
+        || typeof usage.cacheCreationTokens === "number";
     const hit = usage.promptCacheHitTokens ?? 0;
     const miss = hasCacheBreakdown
         ? usage.promptCacheMissTokens ?? Math.max(0, usage.promptTokens - hit)

package/dist/model-selection.d.ts

@@ -0,0 +1,7 @@
+export interface ResolveConfiguredModelInput {
+    cliModel?: string;
+    sessionModel?: string;
+    defaultModel?: string;
+    fallbackProviderId?: string;
+}
+export declare function resolveConfiguredModel(input: ResolveConfiguredModelInput): string;

package/dist/model-selection.js

@@ -0,0 +1,9 @@
+import { encodeModel } from "./provider-registry.js";
+export function resolveConfiguredModel(input) {
+    const selected = input.cliModel ?? input.sessionModel ?? input.defaultModel;
+    if (!selected)
+        return "";
+    if (selected.includes(":"))
+        return selected;
+    return input.fallbackProviderId ? encodeModel(input.fallbackProviderId, selected) : "";
+}

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

@@ -13,4 +13,5 @@ export declare function createChatGptFetch(options?: ChatGptFetchOptions): ChatG
 export declare function createChatGptDispatcher(env?: NodeJS.ProcessEnv, input?: RequestInfo | URL): Dispatcher | undefined;
 export declare function withChatGptNetworkOptions(input: RequestInfo | URL, init: RequestInit | undefined, env?: NodeJS.ProcessEnv, dispatcher?: Dispatcher | undefined): RequestInitWithDispatcher;
 export declare function normalizeChatGptNetworkError(error: unknown, env?: NodeJS.ProcessEnv): Error;
+export declare function parseMacSystemProxyForUrl(output: string, url: URL): string | undefined;
 export {};

package/dist/network/chatgpt-transport.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { delimiter } from "node:path";
 import { rootCertificates } from "node:tls";
@@ -19,9 +20,8 @@ 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, dispatcher);
+        const requestInit = withChatGptNetworkOptions(input, init, env);
         try {
             return await fetchImpl(input, requestInit);
         }
@@ -34,9 +34,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({
@@ -73,41 +73,144 @@ 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.",
+            : 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."
+                : "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 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 allProxy = env.ALL_PROXY ?? env.all_proxy;
     if (url.protocol === "https:")
         return env.HTTPS_PROXY ?? env.https_proxy ?? allProxy;
     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 undefined;
 }
-function nodeProxyForUrl(input, env) {
-    const url = urlFromInput(input);
-    if (!url || shouldBypassProxy(url, env))
+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)
         return undefined;
-    if (url.protocol === "https:")
-        return env.HTTPS_PROXY ?? env.https_proxy ?? env.ALL_PROXY ?? env.all_proxy;
-    if (url.protocol === "http:")
-        return env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy;
-    return defaultNodeProxy(env);
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(host))
+        return host;
+    const normalizedHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+    return `http://${normalizedHost}:${port}`;
 }
-function defaultNodeProxy(env) {
-    return env.HTTPS_PROXY ?? env.https_proxy ?? env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy;
+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;
+}
+function truthyEnv(value) {
+    return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
 }
 function bunExtraCaFiles(env) {
     const bun = globalThis.Bun;
@@ -177,6 +280,9 @@ function networkEnvSignature(env) {
         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,
@@ -195,6 +301,7 @@ function isChatGptNetworkErrorText(text) {
         /\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,

package/dist/orchestrator/default-hooks.js

@@ -176,7 +176,7 @@ function isCodeWriteResult(_toolCall, result) {
     return result.metadata?.kind === "write" || result.metadata?.kind === "edit" || result.metadata?.kind === "patch";
 }
 function isMutationTool(name) {
-    return name === "edit" || name === "write" || name === "apply_patch";
+    return name === "edit" || name === "write";
 }
 function hasSubagentLifecycleActivity(toolCalls, toolResults) {
     return toolCalls.some((toolCall) => isSubagentLifecycleTool(toolCall.name))

package/dist/prompt/environment.js

@@ -3,7 +3,6 @@ export const defaultToolSnippets = {
     read: "Read the contents of a file",
     bash: "Execute a bash command",
     edit: "Apply targeted string replacements to a file",
-    apply_patch: "Apply a structured patch for multi-file or larger code changes",
     write: "Write a new file or overwrite an existing one",
     glob: "Find files by glob pattern without using bash",
     grep: "Search file contents using regex",
@@ -24,7 +23,6 @@ export const defaultToolNames = [
     "glob",
     "bash",
     "edit",
-    "apply_patch",
     "write",
     "grep",
     "lsp",
@@ -46,7 +44,7 @@ export function buildEnvironmentPrompt(options = {}) {
     const workingDir = options.workingDir ?? cwd().replace(/\\/g, "/");
     const currentDate = options.currentDate ?? new Date().toISOString().slice(0, 10);
     const tools = options.tools ?? defaultToolNames;
-    const snippets = options.toolSnippets ?? defaultToolSnippets;
+    const snippets = { ...defaultToolSnippets, ...(options.toolSnippets ?? {}) };
     const visibleTools = tools.filter((name) => snippets[name]);
     const toolList = visibleTools.length > 0
         ? visibleTools.map((name) => `- ${name}: ${snippets[name]}`).join("\n")

package/dist/prompt/runtime.js

@@ -7,7 +7,7 @@ const defaultGuidelines = [
     "Ground decisions in the codebase: inspect relevant files, command output, or runtime state before making claims about behavior. Separate confirmed facts from inference when evidence is incomplete.",
     "Choose the smallest coherent change. Edit only the files required for the requested change; do not refactor or improve adjacent code unprompted.",
     "Runtime meta instructions are private control state. Use them only to adjust behavior; do not quote, mention, or paraphrase them in user-facing text.",
-    "For modifications to existing code, read the file first. For brand-new files whose target path is known and does not exist, write directly without exploratory reading. Use edit for small targeted changes, apply_patch for related multi-file or larger structured changes, and write for intentional full-file replacement of an existing file. Never delete and recreate a file just to overwrite it.",
+    "For modifications to existing code, read the file first. For brand-new files whose target path is known and does not exist, write directly without exploratory reading. Use edit for targeted changes and write for intentional full-file replacement of an existing file. Never delete and recreate a file just to overwrite it.",
     "Prefer structured tools (glob, grep, lsp, read) over bash for search and inspection. Do not repeat a near-identical search or re-read the same file unless new evidence changes the question.",
     "If a tool fails, diagnose the error before switching tactics. Do not retry the identical call with identical arguments. After two equivalent failures, switch approach — re-read the file, use a different tool, rewrite the whole file with write, or ask the user.",
     "Before reporting a task complete, verify it works when verification is meaningful and cheap — run the existing test, execute the script, check the output. If no test exists, the change is purely declarative (static HTML/markdown/config), or running the code is not practical, state that explicitly rather than inventing a verification step. Do not write throwaway validation scripts to prove correctness; if there is no real check to run, report the change and stop.",