@bubblebrain-ai/bubble 0.0.13 → 0.0.15

package/dist/feishu/serve.js

@@ -91,7 +91,13 @@ export async function serveFeishu(opts = {}) {
     if (mcpLoaded.servers.length > 0) {
         await mcpManager.start();
     }
-    const createProvider = (providerId, apiKey, baseURL, promptCacheKey) => createProviderInstance({ providerId, apiKey, baseURL, promptCacheKey });
+    const createProvider = (providerId, apiKey, baseURL, promptCacheKey) => createProviderInstance({
+        providerId,
+        apiKey,
+        baseURL,
+        promptCacheKey,
+        openAICodexAuth: providerRegistry.createOpenAICodexAuthAdapter(providerId),
+    });
     const createProviderForRoute = async (route, promptCacheKey) => {
         const target = providerRegistry.getConfigured().find((p) => p.id === route.providerId);
         if (!target?.apiKey) {

package/dist/main.js

@@ -27,12 +27,23 @@ import { buildMemoryPrompt, formatMemoryStartupResult, recordMemoryCitations, ru
 import { basename } from "node:path";
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
 import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
+import { configureDebugTrace, summarizeAgentEventForTrace, summarizeTraceMessage, traceEvent, } from "./debug-trace.js";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
         printHelp();
         process.exit(0);
     }
+    if (process.argv.includes("-v") || process.argv.includes("--version")) {
+        const { getCurrentVersion } = await import("./update/index.js");
+        console.log(`v${getCurrentVersion()}`);
+        process.exit(0);
+    }
+    if (args.command === "update") {
+        const { runUpdateCommand } = await import("./update/index.js");
+        const code = await runUpdateCommand({ checkOnly: args.checkOnly });
+        process.exit(code);
+    }
     if (args.command === "serve") {
         if (args.serveHost !== "feishu") {
             console.error(chalk.red("Usage: bubble serve --feishu [--setup | --kill-old | --dry-run]"));
@@ -72,6 +83,7 @@ async function main() {
             baseURL: defaultProvider.baseURL,
             thinkingLevel: args.thinkingLevel,
             promptCacheKey: sessionPromptCacheKey,
+            openAICodexAuth: registry.createOpenAICodexAuthAdapter(defaultProvider.id),
         })
         : createUnavailableProvider(unavailableProviderMessage);
     const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({
@@ -80,6 +92,7 @@ async function main() {
         baseURL,
         thinkingLevel: args.thinkingLevel,
         promptCacheKey: sessionPromptCacheKey,
+        openAICodexAuth: registry.createOpenAICodexAuthAdapter(providerId),
     });
     const createProviderForRoute = async (route) => {
         const providerId = route.providerId;
@@ -276,6 +289,25 @@ async function main() {
         tools: tools.map((tool) => tool.name),
         memoryPrompt,
     });
+    const traceInfo = configureDebugTrace({
+        cwd: args.cwd,
+        sessionFile: sessionManager?.getSessionFile(),
+        provider: activeProviderId || "none",
+        model: activeModel || "none",
+        renderer: printMode ? "print" : "opentui-core",
+    });
+    if (traceInfo.enabled) {
+        traceEvent("run_start", {
+            tracePath: traceInfo.path,
+            rawEnabled: traceInfo.rawEnabled,
+            resumed: resumedExistingSession,
+            printMode,
+            mode: initialMode,
+            thinkingLevel: initialThinkingLevel,
+            tools: tools.length,
+            cwd: args.cwd,
+        });
+    }
     const budgetLedger = new BudgetLedger();
     let sessionTitleUpdater;
     const agent = new Agent({
@@ -301,6 +333,9 @@ async function main() {
             if (message.role === "meta")
                 return;
             sessionManager.appendMessage(message);
+            traceEvent("session_message_persisted", {
+                message: summarizeTraceMessage(message),
+            });
             sessionTitleUpdater?.handlePersistedMessage(message);
             if (message.role === "assistant") {
                 recordMemoryCitations(args.cwd, message.content);
@@ -404,6 +439,7 @@ async function main() {
                 process.exit(1);
             }
             for await (const event of agent.run(prompt, args.cwd)) {
+                traceEvent("print_agent_event", summarizeAgentEventForTrace(event));
                 if (event.type === "text_delta") {
                     process.stdout.write(event.content);
                 }
@@ -449,6 +485,8 @@ async function main() {
             runMemorySummary,
             runMemoryRefresh,
         };
+        const { getStartupUpdateNotice } = await import("./update/index.js");
+        const updateNotice = await getStartupUpdateNotice();
         const { runTui } = await import("./tui/run.js");
         await runTui(agent, args, {
             ...commonOptions,
@@ -456,6 +494,7 @@ async function main() {
             themeOverrides: themeConfig.overrides,
             detectedTheme,
             onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+            updateNotice: updateNotice ?? undefined,
         });
         if (sessionManager) {
             printOpenTuiExitSummary(sessionManager, {
@@ -465,7 +504,9 @@ async function main() {
         }
     }
     finally {
+        traceEvent("run_shutdown_start");
         await shutdownRuntime();
+        traceEvent("run_shutdown_end");
     }
 }
 function printOpenTuiExitSummary(sessionManager, options) {

package/dist/model-catalog.js

@@ -25,6 +25,7 @@ const OPENAI_CHAT_LEVELS = ["off"];
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
 const DEEPSEEK_V4_LEVELS = ["high", "max"];
 export const BUILTIN_MODELS = [
+    { id: "gpt-5.5", name: "gpt-5.5", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000, toolOutputTokenLimit: 10000 },
     { id: "gpt-5.4", name: "gpt-5.4", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000 },
     { id: "gpt-5.4-mini", name: "gpt-5.4-mini", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000 },
     { id: "gpt-5.3-codex", name: "gpt-5.3-codex", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000 },

package/dist/orchestrator/default-hooks.js

@@ -78,11 +78,18 @@ export function createDefaultHooks() {
                 }
                 ctx.state.evidenceTracker?.observe(ctx.toolCall, ctx.result);
                 ctx.state.governor?.afterToolResult(ctx.toolCall, ctx.result);
-                // Edit/write retry-escalation: if the same tool with the same args
-                // failed twice in a row, models — especially thinking-heavy ones —
-                // can spiral on "identical content" / "not found" errors. Nudge them
-                // to change strategy.
-                if ((ctx.toolCall.name === "edit" || ctx.toolCall.name === "write") && ctx.result.isError) {
+                // 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) {
+                    if (ctx.toolCall.name === "edit" && ctx.result.status === "no_match" && ctx.result.metadata?.kind === "edit") {
+                        const path = typeof ctx.result.metadata.path === "string" ? ctx.result.metadata.path : "";
+                        const reminded = ctx.state.editNoMatchReminderPaths ?? (ctx.state.editNoMatchReminderPaths = []);
+                        if (path && !reminded.includes(path)) {
+                            reminded.push(path);
+                            const summary = ctx.result.content.split("\n")[0] || "";
+                            ctx.queueReminder(buildEditRetryEscalationReminder(`Edit oldText did not match ${path}. ${summary}`));
+                        }
+                    }
                     const hash = hashEditCall(ctx.toolCall);
                     const history = ctx.state.recentEditFailures ?? (ctx.state.recentEditFailures = []);
                     history.push(hash);
@@ -96,10 +103,11 @@ export function createDefaultHooks() {
                         ctx.queueReminder(buildEditRetryEscalationReminder(`Last failure: ${ctx.toolCall.name} on the same target with identical arguments. ${summary}`));
                     }
                 }
-                else if ((ctx.toolCall.name === "edit" || ctx.toolCall.name === "write") && !ctx.result.isError) {
+                else if (isMutationTool(ctx.toolCall.name) && !ctx.result.isError) {
                     // Successful mutation resets the dedup state so a later, unrelated
                     // failure won't fire the reminder spuriously.
                     ctx.state.recentEditFailures = [];
+                    ctx.state.editNoMatchReminderPaths = [];
                     ctx.state.editRetryReminderSent = false;
                 }
                 // Redundant-Read detection moved into the read tool itself: it now
@@ -151,10 +159,13 @@ function markCodeChanged(state) {
     state.codeChanged = true;
 }
 function isCodeWriteResult(_toolCall, result) {
-    if (result.isError || result.status === "blocked" || result.status === "command_error") {
+    if (result.isError || result.status === "blocked" || result.status === "cancelled" || result.status === "command_error") {
         return false;
     }
-    return result.metadata?.kind === "write" || result.metadata?.kind === "edit";
+    return result.metadata?.kind === "write" || result.metadata?.kind === "edit" || result.metadata?.kind === "patch";
+}
+function isMutationTool(name) {
+    return name === "edit" || name === "write" || name === "apply_patch";
 }
 function hasSubagentLifecycleActivity(toolCalls, toolResults) {
     return toolCalls.some((toolCall) => isSubagentLifecycleTool(toolCall.name))

package/dist/orchestrator/hooks.d.ts

@@ -16,6 +16,7 @@ export interface TurnHookState {
     codeChanged?: boolean;
     smallTaskHintSent?: boolean;
     recentEditFailures?: string[];
+    editNoMatchReminderPaths?: string[];
     editRetryReminderSent?: boolean;
     recentReadPaths?: string[];
     redundantReadReminded?: Set<string>;

package/dist/prompt/environment.js

@@ -3,6 +3,7 @@ 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",
@@ -23,6 +24,7 @@ export const defaultToolNames = [
     "glob",
     "bash",
     "edit",
+    "apply_patch",
     "write",
     "grep",
     "lsp",

package/dist/prompt/reminders.d.ts

@@ -31,12 +31,11 @@ export declare function buildWorkflowPhaseReminder(input: {
 }): string;
 export declare function buildTaskSummaryReminder(): string;
 /**
- * Fired when the same edit/write tool call (identical tool name + args) has
- * just failed for the second time in a row. Models — especially thinking-heavy
- * ones — can otherwise spiral on `No changes made: identical content` or
- * `oldText not found` because their internal reasoning convinces them they
- * are typing the change correctly even though the JSON args arrive identical.
- * This nudge forces a strategy change.
+ * Fired when a file mutation failure suggests the model may be relying on stale
+ * local memory instead of the current file bytes. Models — especially
+ * thinking-heavy ones — can otherwise spiral on `No changes made: identical
+ * content` or `oldText not found` because their internal reasoning convinces
+ * them they are typing the change correctly.
  */
 export declare function buildEditRetryEscalationReminder(reason: string): string;
 /**

package/dist/prompt/reminders.js

@@ -178,23 +178,22 @@ Treat the task output as a bounded subtask result:
 // validation scripts that found the bug but could never fix it. CC trusts the
 // model to decide when verification is meaningful; we follow that.
 /**
- * Fired when the same edit/write tool call (identical tool name + args) has
- * just failed for the second time in a row. Models — especially thinking-heavy
- * ones — can otherwise spiral on `No changes made: identical content` or
- * `oldText not found` because their internal reasoning convinces them they
- * are typing the change correctly even though the JSON args arrive identical.
- * This nudge forces a strategy change.
+ * Fired when a file mutation failure suggests the model may be relying on stale
+ * local memory instead of the current file bytes. Models — especially
+ * thinking-heavy ones — can otherwise spiral on `No changes made: identical
+ * content` or `oldText not found` because their internal reasoning convinces
+ * them they are typing the change correctly.
  */
 export function buildEditRetryEscalationReminder(reason) {
     return wrapInSystemReminder(`
-The same edit/write call has failed twice with identical arguments.
+A file mutation just failed in a way that usually means your local view of the file is stale or the edit anchor is wrong.
 
 ${reason}
 
-Stop retrying the same call. Pick one of:
+Stop retrying from memory. Pick one of:
 - Re-read the target file and compare the actual bytes to your intended oldText / newText. Trailing whitespace, unicode lookalikes, or off-by-one boundaries are common causes.
 - If you intended to add a single character (e.g. fixing a 5-digit hex color to 6 digits), confirm that your newText string actually contains the added character before sending again.
-- Use the write tool with overwrite=true and the full new content instead of edit — useful when the change spans many lines or the diff anchor is ambiguous. Existing files must be read or modified in this session before full-file replacement.
+- Use the write tool with the full new content instead of edit — useful when the change spans many lines or the diff anchor is ambiguous.
 - If you cannot determine the cause, ask the user for clarification.
 `);
 }

package/dist/prompt/runtime.js

@@ -6,9 +6,9 @@
 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.",
-    "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; use write with overwrite=true 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 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 overwrite=true, or ask the user.",
+    "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.",
 ];
 export function buildRuntimePrompt(options = {}) {

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

@@ -1,4 +1,5 @@
 import type { Provider, ReasoningEffort, ThinkingLevel, TokenUsage } from "./types.js";
+import type { OAuthCredentials } from "./oauth/types.js";
 export interface CodexModelDescriptor {
     id: string;
     displayName?: string;
@@ -11,6 +12,11 @@ export interface CodexModelDescriptor {
 }
 export declare function isOpenAICodexBaseUrl(baseURL: string): boolean;
 export declare function getOpenAICodexFallbackModels(): string[];
+export interface OpenAICodexAuthAdapter {
+    getCredentials: () => OAuthCredentials | undefined | Promise<OAuthCredentials | undefined>;
+    refreshCredentials: (current?: OAuthCredentials) => Promise<OAuthCredentials>;
+    isExpired?: (credentials: OAuthCredentials, graceMs: number) => boolean;
+}
 export declare function extractChatGptAccountId(accessToken: string): string | undefined;
 export declare function createOpenAICodexProvider(options: {
     providerId?: string;
@@ -18,6 +24,7 @@ export declare function createOpenAICodexProvider(options: {
     baseURL: string;
     thinkingLevel?: ThinkingLevel;
     promptCacheKey?: string;
+    auth?: OpenAICodexAuthAdapter;
 }): Provider;
 export declare function normalizeOpenAICodexUsage(usage: any): TokenUsage;
 export declare function buildOpenAICodexPromptCacheKey(input: {