@bubblebrain-ai/bubble 0.0.15 → 0.0.17

package/dist/network/chatgpt-transport.js

@@ -0,0 +1,240 @@
+import { readFileSync } from "node:fs";
+import { delimiter } from "node:path";
+import { rootCertificates } from "node:tls";
+import { Agent, ProxyAgent } from "undici";
+let cachedDefaultFetch;
+export function chatGptFetch(input, init) {
+    return getChatGptFetch()(input, init);
+}
+export function getChatGptFetch(env = process.env) {
+    const signature = networkEnvSignature(env);
+    if (!cachedDefaultFetch || cachedDefaultFetch.signature !== signature) {
+        cachedDefaultFetch = {
+            signature,
+            fetch: createChatGptFetch({ env }),
+        };
+    }
+    return cachedDefaultFetch.fetch;
+}
+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);
+        try {
+            return await fetchImpl(input, requestInit);
+        }
+        catch (error) {
+            throw normalizeChatGptNetworkError(error, env);
+        }
+    };
+}
+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);
+    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 withChatGptNetworkOptions(input, init, env = process.env, dispatcher = createChatGptDispatcher(env, input)) {
+    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 };
+        return next;
+    }
+    if (dispatcher)
+        next.dispatcher = dispatcher;
+    return next;
+}
+export function normalizeChatGptNetworkError(error, env = process.env) {
+    const text = errorMessageChain(error).join("\n");
+    if (!isChatGptNetworkErrorText(text)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const message = [
+        "ChatGPT connection failed before Bubble received a response.",
+        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 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.",
+        "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);
+}
+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;
+    if (url.protocol === "http:")
+        return env.HTTP_PROXY ?? env.http_proxy ?? allProxy;
+    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;
+    if (url.protocol === "http:")
+        return env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy;
+    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;
+}
+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 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) {
+    const paths = extraCaCertificatePaths(env);
+    return paths.map((path) => {
+        try {
+            return readFileSync(path, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`Failed to read ChatGPT 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 networkEnvSignature(env) {
+    return [
+        env.HTTP_PROXY,
+        env.http_proxy,
+        env.HTTPS_PROXY,
+        env.https_proxy,
+        env.ALL_PROXY,
+        env.all_proxy,
+        env.NO_PROXY,
+        env.no_proxy,
+        env.NODE_EXTRA_CA_CERTS,
+        env.BUBBLE_EXTRA_CA_CERTS,
+    ].join("\0");
+}
+function isChatGptNetworkErrorText(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,
+        /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;
+}

package/dist/oauth/openai-codex.d.ts

@@ -2,8 +2,13 @@
  * OpenAI Codex OAuth login (PKCE + local callback).
  */
 import type { OAuthTokens } from "./types.js";
+import { type ChatGptFetch } from "../network/chatgpt-transport.js";
 export interface OpenAICodexLoginCallbacks {
     onStatus: (message: string) => void;
 }
-export declare function loginOpenAICodex(callbacks?: OpenAICodexLoginCallbacks): Promise<OAuthTokens>;
-export declare function refreshOpenAICodex(refreshToken: string): Promise<OAuthTokens>;
+export declare function loginOpenAICodex(callbacks?: OpenAICodexLoginCallbacks, options?: {
+    fetch?: ChatGptFetch;
+}): Promise<OAuthTokens>;
+export declare function refreshOpenAICodex(refreshToken: string, options?: {
+    fetch?: ChatGptFetch;
+}): Promise<OAuthTokens>;

package/dist/oauth/openai-codex.js

@@ -4,6 +4,7 @@
 import { createServer } from "node:http";
 import { exec } from "node:child_process";
 import { randomBytes, createHash } from "node:crypto";
+import { chatGptFetch } from "../network/chatgpt-transport.js";
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const AUTH_URL = "https://auth.openai.com/oauth/authorize";
 const TOKEN_URL = "https://auth.openai.com/oauth/token";
@@ -92,7 +93,8 @@ function extractAccountId(idToken) {
     const auth = claims?.["https://api.openai.com/auth"];
     return auth?.chatgpt_account_id || auth?.account_id || claims?.sub;
 }
-export async function loginOpenAICodex(callbacks) {
+export async function loginOpenAICodex(callbacks, options = {}) {
+    const fetchImpl = options.fetch ?? chatGptFetch;
     callbacks?.onStatus("Starting OpenAI Codex OAuth login...");
     const pkce = generatePKCE();
     const state = generateState();
@@ -119,7 +121,7 @@ export async function loginOpenAICodex(callbacks) {
         throw new Error("OAuth state mismatch. Possible CSRF attack.");
     }
     callbacks?.onStatus("Exchanging authorization code for tokens...");
-    const response = await fetch(TOKEN_URL, {
+    const response = await fetchImpl(TOKEN_URL, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded" },
         body: new URLSearchParams({
@@ -146,8 +148,9 @@ export async function loginOpenAICodex(callbacks) {
         accountId,
     };
 }
-export async function refreshOpenAICodex(refreshToken) {
-    const response = await fetch(TOKEN_URL, {
+export async function refreshOpenAICodex(refreshToken, options = {}) {
+    const fetchImpl = options.fetch ?? chatGptFetch;
+    const response = await fetchImpl(TOKEN_URL, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded" },
         body: new URLSearchParams({

package/dist/orchestrator/default-hooks.js

@@ -2,6 +2,7 @@ import { classifyTask } from "../agent/task-classifier.js";
 import { classifyTaskSize } from "../agent/task-size.js";
 import { EvidenceTracker } from "../agent/evidence-tracker.js";
 import { ExecutionGovernor } from "../agent/execution-governor.js";
+import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
 import { buildEditRetryEscalationReminder, buildSmallTaskHint, buildTaskSummaryReminder, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { reminderForTaskType } from "../prompt/task-reminders.js";
@@ -14,6 +15,11 @@ export function createDefaultHooks() {
                 const taskType = classifyTask(ctx.input);
                 ctx.state.taskType = taskType;
                 ctx.state.governor = new ExecutionGovernor(taskType);
+                ctx.state.discoveryBarrier = new DiscoveryBarrier({
+                    cwd: ctx.cwd,
+                    input: ctx.input,
+                    enabled: taskType === "repo_orientation",
+                });
                 const taskReminder = reminderForTaskType(taskType);
                 if (taskReminder) {
                     ctx.queueReminder(taskReminder);
@@ -63,8 +69,12 @@ export function createDefaultHooks() {
         {
             beforeToolCall(ctx) {
                 const arbitration = arbitrateToolCall(ctx.toolCall);
-                ctx.replaceToolCall({ ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) });
-                ctx.state.governor?.beforeToolCall(ctx.toolCall);
+                const toolCall = { ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) };
+                ctx.replaceToolCall(toolCall);
+                ctx.state.governor?.beforeToolCall(toolCall);
+                const blockedResult = ctx.state.discoveryBarrier?.beforeToolCall(toolCall);
+                if (blockedResult)
+                    ctx.blockToolCall(blockedResult);
             },
             afterToolCall(ctx) {
                 if (ctx.toolCall.arbiterNote) {
@@ -78,6 +88,7 @@ export function createDefaultHooks() {
                 }
                 ctx.state.evidenceTracker?.observe(ctx.toolCall, ctx.result);
                 ctx.state.governor?.afterToolResult(ctx.toolCall, ctx.result);
+                ctx.state.discoveryBarrier?.afterToolCall(ctx.toolCall, ctx.result);
                 // Edit/write retry-escalation: models can spiral on "identical content"
                 // or "not found" errors. Nudge them to re-ground or switch strategy.
                 if (isMutationTool(ctx.toolCall.name) && ctx.result.isError) {

package/dist/orchestrator/hooks.d.ts

@@ -3,10 +3,12 @@ import type { ContentPart, ParsedToolCall, ToolRegistryEntry, ToolResult } from
 import type { TaskType } from "../agent/task-classifier.js";
 import type { ExecutionGovernor } from "../agent/execution-governor.js";
 import type { EvidenceTracker } from "../agent/evidence-tracker.js";
+import type { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import type { WorkflowPhase } from "./workflow.js";
 export interface TurnHookState {
     taskType?: TaskType;
     governor?: ExecutionGovernor;
+    discoveryBarrier?: DiscoveryBarrier;
     evidenceTracker?: EvidenceTracker;
     workflowPhase?: WorkflowPhase;
     workflowKey?: string;

package/dist/prompt/compose.js

@@ -38,7 +38,7 @@ function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     const rawModel = modelId ?? modelName ?? "";
     const model = rawModel.includes(":") ? rawModel.split(":").slice(1).join(":") : rawModel;
     const lowerModel = model.toLowerCase();
-    if (provider === "anthropic" || model.startsWith("claude")) {
+    if (provider === "anthropic" || provider === "minimax" || provider.endsWith("-anthropic") || model.startsWith("claude")) {
         return buildAnthropicProviderPrompt(agentName);
     }
     if (provider === "google" || model.startsWith("gemini")) {

package/dist/prompt/reminders.js

@@ -88,12 +88,12 @@ Stop once these categories are covered. Do not keep repeating near-identical sea
 }
 export function buildLoopWarningReminder(reason) {
     return wrapInSystemReminder(`
-Tool loop warning.
+Further broad exploration is low value unless there is a concrete remaining evidence gap.
 
 ${reason}
 
-Do not repeat near-identical reads or searches unless you are changing the path or testing a genuinely new hypothesis.
-If current evidence is sufficient, summarize your findings now.
+Do not repeat near-identical reads or searches unless the path or hypothesis is materially different.
+If current evidence is sufficient, answer with the findings.
 `);
 }
 export function buildSearchFreezeReminder(reason) {

package/dist/prompt/runtime.js

@@ -6,6 +6,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.",
     "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.",

package/dist/provider-anthropic.d.ts

@@ -0,0 +1,77 @@
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, ToolDefinition } from "./types.js";
+export interface AnthropicProviderOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL: string;
+    thinkingLevel?: ThinkingLevel;
+}
+interface AnthropicRequest {
+    model: string;
+    max_tokens: number;
+    messages: AnthropicMessage[];
+    system?: string;
+    tools?: AnthropicTool[];
+    tool_choice?: {
+        type: "auto" | "any";
+    };
+    stream?: boolean;
+    temperature?: number;
+    thinking?: {
+        type: "adaptive";
+    };
+}
+type AnthropicContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: {
+        type: "url";
+        url: string;
+    } | {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+} | {
+    type: "redacted_thinking";
+    data: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+};
+interface AnthropicMessage {
+    role: "user" | "assistant";
+    content: string | AnthropicContentBlock[];
+}
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: ToolDefinition["parameters"];
+}
+export declare function createAnthropicMessagesProvider(options: AnthropicProviderOptions): Provider;
+export declare function buildAnthropicRequest(options: AnthropicProviderOptions, messages: ProviderMessage[], chatOptions: {
+    model: string;
+    tools?: ToolDefinition[];
+    temperature?: number;
+    thinkingLevel?: ThinkingLevel;
+    stream?: boolean;
+}): AnthropicRequest;
+export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean): {
+    system: string;
+    messages: AnthropicMessage[];
+};
+export declare function translateAnthropicStream(events: AsyncIterable<Record<string, unknown>>): AsyncIterable<StreamChunk>;
+export declare function readSseEvents(response: Response): AsyncIterable<Record<string, unknown>>;
+export {};