@bubblebrain-ai/bubble 0.0.13 → 0.0.14

package/dist/approval/controller.d.ts

@@ -45,4 +45,5 @@ export declare class PermissionAwareApprovalController implements ApprovalContro
     checkRules(query: PermissionQuery): PermissionCheckResult;
     request(req: ApprovalRequest): Promise<ApprovalDecision>;
     private requestToQuery;
+    private checkRequestRules;
 }

package/dist/approval/controller.js

@@ -26,8 +26,7 @@ export class PermissionAwareApprovalController {
         return checkPermission(ruleSet, query);
     }
     async request(req) {
-        const query = this.requestToQuery(req);
-        const ruleResult = this.checkRules(query);
+        const ruleResult = this.checkRequestRules(req);
         if (ruleResult.decision === "deny") {
             return {
                 action: "reject",
@@ -38,7 +37,7 @@ export class PermissionAwareApprovalController {
         if (mode === "bypassPermissions") {
             return { action: "approve" };
         }
-        if (mode === "default" && (req.type === "edit" || req.type === "write")) {
+        if (mode === "default" && (req.type === "edit" || req.type === "write" || req.type === "patch")) {
             return { action: "approve" };
         }
         if (mode === "plan") {
@@ -71,8 +70,26 @@ export class PermissionAwareApprovalController {
                 return { tool: "Write", path: req.path, cwd: this.options.cwd };
             case "edit":
                 return { tool: "Edit", path: req.path, cwd: this.options.cwd };
+            case "patch":
+                return { tool: "Edit", path: req.path, cwd: this.options.cwd };
             case "lsp":
                 return { tool: "Lsp", path: req.path, cwd: this.options.cwd };
         }
     }
+    checkRequestRules(req) {
+        if (req.type !== "patch")
+            return this.checkRules(this.requestToQuery(req));
+        const perFile = req.files.map((file) => this.checkRules({
+            tool: file.kind === "add" ? "Write" : "Edit",
+            path: file.path,
+            cwd: this.options.cwd,
+        }));
+        const denied = perFile.find((result) => result.decision === "deny");
+        if (denied)
+            return denied;
+        if (perFile.length > 0 && perFile.every((result) => result.decision === "allow")) {
+            return { decision: "allow", rule: perFile[0].rule };
+        }
+        return { decision: "ask" };
+    }
 }

package/dist/approval/tool-helper.js

@@ -24,6 +24,8 @@ function approvalRequestLabel(req) {
             return `Edit to ${req.path}`;
         case "write":
             return `${req.fileExists ? "Overwrite" : "Write"} to ${req.path}`;
+        case "patch":
+            return `Patch to ${req.path}`;
         case "bash":
             return `Bash command \`${req.command}\``;
         case "lsp":

package/dist/approval/types.d.ts

@@ -22,6 +22,19 @@ export interface WriteApprovalRequest {
     diff?: string;
     fileExists: boolean;
 }
+export interface PatchApprovalRequest {
+    type: "patch";
+    /** Human-readable path summary for compact UIs. */
+    path: string;
+    /** All absolute paths touched by the patch. */
+    paths: string[];
+    files: Array<{
+        path: string;
+        kind: "add" | "update" | "delete";
+    }>;
+    /** Combined unified diff for all file changes. */
+    diff: string;
+}
 export interface BashApprovalRequest {
     type: "bash";
     command: string;
@@ -32,7 +45,7 @@ export interface LspApprovalRequest {
     path: string;
     operation: string;
 }
-export type ApprovalRequest = EditApprovalRequest | WriteApprovalRequest | BashApprovalRequest | LspApprovalRequest;
+export type ApprovalRequest = EditApprovalRequest | WriteApprovalRequest | PatchApprovalRequest | BashApprovalRequest | LspApprovalRequest;
 export type ApprovalDecision = {
     action: "approve";
     feedback?: string;

package/dist/context/compact.js

@@ -255,9 +255,8 @@ function entriesToMessages(entries) {
                 break;
             case "assistant_message":
                 messages.push({
+                    ...entry.message,
                     role: "assistant",
-                    content: entry.message.content,
-                    reasoning: entry.message.reasoning,
                 });
                 break;
             case "tool_call": {
@@ -358,7 +357,14 @@ function findLatestSummaryIndex(entries) {
     return -1;
 }
 function nextSummaryId(entries) {
-    return `${entries.length + 1}`;
+    let max = 0;
+    for (const entry of entries) {
+        const match = /^(\d+)/.exec(entry.id);
+        if (!match)
+            continue;
+        max = Math.max(max, Number(match[1]));
+    }
+    return `${max + 1}`;
 }
 function cloneMessage(message) {
     if (message.role === "assistant") {

package/dist/context/projector.js

@@ -1,29 +1,38 @@
 import { getContextBudget } from "./budget.js";
 import { compactCurrentTurnToolGroups, compactMessages } from "./compact.js";
 import { pruneMessages } from "./prune.js";
-// Prefix-cache invariant: every projected output starts with the concatenation
-// of (in order) system + meta messages from the input, followed by the
-// conversational body. Compactors (compactMessages, compactCurrentTurnToolGroups,
-// compactMessagesWithLLM, compactWithLLM) MUST preserve every existing
-// system/meta message in its original position so the cacheable prefix
-// stays byte-identical across turns where compaction didn't fire. Inserting
-// new dynamic content (summaries, etc.) AFTER system+meta is safe; inserting
-// it within or before them is not.
+// Prefix-cache invariant: only the leading static system prompt is promoted to
+// the first provider message. Runtime meta reminders stay in the conversational
+// body at their original relative position, so a new per-turn reminder does not
+// rewrite the cacheable prefix before the existing history.
 export function projectMessages(messages, options = {}) {
     const mode = options.mode ?? "full";
     const projectedBody = [];
     const systemContext = [];
+    let inLeadingSystemPrefix = true;
     for (const message of messages) {
-        if (message.role === "system") {
+        if (message.role === "system" && inLeadingSystemPrefix) {
             systemContext.push(message.content);
             continue;
         }
         if (message.role === "meta") {
+            inLeadingSystemPrefix = false;
             if (message.includeInLlm !== false) {
-                systemContext.push(formatMetaMessage(message));
+                projectedBody.push({
+                    role: "user",
+                    content: formatMetaMessage(message),
+                });
             }
             continue;
         }
+        inLeadingSystemPrefix = false;
+        if (message.role === "system") {
+            projectedBody.push({
+                role: "user",
+                content: formatRuntimeSystemMessage(message),
+            });
+            continue;
+        }
         if (message.role === "assistant" && isEmptyAssistantMessage(message)) {
             continue;
         }
@@ -147,9 +156,12 @@ export function repairToolCallChains(messages) {
 }
 function isEmptyAssistantMessage(message) {
     const hasContent = message.content.trim().length > 0;
-    const hasReasoning = (message.reasoning ?? "").trim().length > 0;
     const hasToolCalls = !!message.toolCalls && message.toolCalls.length > 0;
-    return !hasContent && !hasReasoning && !hasToolCalls;
+    // Reasoning-only assistant messages are not valid ChatCompletions history:
+    // providers require assistant history to contain user-visible content or
+    // tool_calls. Keep reasoning attached to real assistant/tool-call messages,
+    // but drop standalone thinking-only turns before provider projection.
+    return !hasContent && !hasToolCalls;
 }
 function formatMetaMessage(message) {
     switch (message.kind) {
@@ -160,6 +172,9 @@ function formatMetaMessage(message) {
             return `Runtime context:\n${message.content}`;
     }
 }
+function formatRuntimeSystemMessage(message) {
+    return `Runtime context:\n${message.content}`;
+}
 function cloneMessage(message) {
     if (message.role === "assistant") {
         return {

package/dist/debug-trace.d.ts

@@ -0,0 +1,27 @@
+import type { AgentEvent, Message, ToolResult } from "./types.js";
+export interface DebugTraceContext {
+    cwd?: string;
+    sessionFile?: string;
+    provider?: string;
+    model?: string;
+    renderer?: string;
+    surface?: string;
+}
+export interface DebugTraceInfo {
+    enabled: boolean;
+    path?: string;
+    runId?: string;
+    rawEnabled: boolean;
+}
+export declare function isDebugTraceEnabled(): boolean;
+export declare function isDebugTraceRawEnabled(): boolean;
+export declare function configureDebugTrace(context: DebugTraceContext): DebugTraceInfo;
+export declare function getDebugTraceInfo(): DebugTraceInfo;
+export declare function traceEvent(phase: string, detail?: Record<string, unknown>, context?: DebugTraceContext): void;
+export declare function summarizeTraceText(value: unknown): Record<string, unknown> | undefined;
+export declare function summarizeTraceValue(value: unknown): Record<string, unknown> | undefined;
+export declare function summarizeTraceMessage(message: Message): Record<string, unknown>;
+export declare function summarizeTraceToolResult(result: ToolResult): Record<string, unknown>;
+export declare function summarizeTraceError(error: unknown): Record<string, unknown>;
+export declare function summarizeAgentEventForTrace(event: AgentEvent): Record<string, unknown>;
+export declare function resetDebugTraceForTests(): void;

package/dist/debug-trace.js

@@ -0,0 +1,385 @@
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { getBubbleHome } from "./bubble-home.js";
+const TRACE_VERSION = 1;
+const TRUE_VALUES = new Set(["1", "true", "yes", "on"]);
+const FALSE_VALUES = new Set(["0", "false", "no", "off"]);
+const DEFAULT_MAX_AGE_DAYS = 7;
+const DEFAULT_RAW_MAX_BYTES = 256 * 1024;
+let initialized = false;
+let tracePath;
+let runId;
+let sequence = 0;
+let startedAt = performance.now();
+let baseContext = {};
+let defaultPruneDone = false;
+export function isDebugTraceEnabled() {
+    const value = process.env.BUBBLE_TRACE?.trim();
+    if (!value)
+        return false;
+    return !FALSE_VALUES.has(value.toLowerCase());
+}
+export function isDebugTraceRawEnabled() {
+    const value = process.env.BUBBLE_TRACE_RAW?.trim().toLowerCase();
+    return !!value && !FALSE_VALUES.has(value);
+}
+export function configureDebugTrace(context) {
+    baseContext = { ...baseContext, ...dropUndefined(context) };
+    const path = ensureTracePath();
+    if (!path)
+        return { enabled: false, rawEnabled: isDebugTraceRawEnabled() };
+    return {
+        enabled: true,
+        path,
+        runId,
+        rawEnabled: isDebugTraceRawEnabled(),
+    };
+}
+export function getDebugTraceInfo() {
+    const path = ensureTracePath();
+    if (!path)
+        return { enabled: false, rawEnabled: isDebugTraceRawEnabled() };
+    return {
+        enabled: true,
+        path,
+        runId,
+        rawEnabled: isDebugTraceRawEnabled(),
+    };
+}
+export function traceEvent(phase, detail, context) {
+    const path = ensureTracePath();
+    if (!path)
+        return;
+    const eventContext = {
+        ...baseContext,
+        ...dropUndefined(context ?? {}),
+    };
+    const line = {
+        traceVersion: TRACE_VERSION,
+        ts: new Date().toISOString(),
+        elapsedMs: Math.round(performance.now() - startedAt),
+        seq: ++sequence,
+        runId,
+        pid: process.pid,
+        phase,
+        ...eventContext,
+        ...(detail ? { detail: sanitizeTraceValue(detail) } : {}),
+    };
+    try {
+        appendFileSync(path, JSON.stringify(line) + "\n", "utf-8");
+    }
+    catch {
+        // Debug tracing must never affect normal agent execution.
+    }
+}
+export function summarizeTraceText(value) {
+    if (typeof value !== "string")
+        return summarizeTraceValue(value);
+    return summarizeString(value);
+}
+export function summarizeTraceValue(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return { type: "null" };
+    if (typeof value === "string")
+        return summarizeString(value);
+    if (typeof value === "number" || typeof value === "boolean") {
+        return { type: typeof value, value };
+    }
+    if (Array.isArray(value)) {
+        return {
+            type: "array",
+            count: value.length,
+            json: summarizeJson(value),
+        };
+    }
+    if (typeof value === "object") {
+        return {
+            type: "object",
+            keys: Object.keys(value).slice(0, 32),
+            json: summarizeJson(value),
+        };
+    }
+    return { type: typeof value, value: String(value) };
+}
+export function summarizeTraceMessage(message) {
+    if (message.role === "assistant") {
+        return {
+            role: message.role,
+            content: summarizeTraceText(message.content),
+            reasoning: summarizeTraceText(message.reasoning ?? ""),
+            error: message.error,
+            toolCalls: message.toolCalls?.map((call) => ({
+                id: call.id,
+                name: call.name,
+                args: summarizeTraceText(call.arguments),
+                argsCorrupt: call.argsCorrupt,
+            })),
+        };
+    }
+    if (message.role === "tool") {
+        return {
+            role: message.role,
+            toolCallId: message.toolCallId,
+            content: summarizeTraceText(message.content),
+            isError: message.isError,
+            metadata: message.metadata,
+        };
+    }
+    if (message.role === "user") {
+        return {
+            role: message.role,
+            content: summarizeTraceValue(message.content),
+        };
+    }
+    return {
+        role: message.role,
+        kind: "kind" in message ? message.kind : undefined,
+        content: summarizeTraceText(message.content),
+    };
+}
+export function summarizeTraceToolResult(result) {
+    return {
+        content: summarizeTraceText(result.content),
+        isError: result.isError,
+        status: result.status,
+        metadata: result.metadata,
+    };
+}
+export function summarizeTraceError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: truncateString(error.stack ?? "", 4000),
+        };
+    }
+    return {
+        name: "Error",
+        message: String(error),
+    };
+}
+export function summarizeAgentEventForTrace(event) {
+    switch (event.type) {
+        case "text_delta":
+        case "reasoning_delta":
+            return { type: event.type, content: summarizeTraceText(event.content) };
+        case "tool_call_start":
+            return { type: event.type, id: event.id, name: event.name };
+        case "tool_call_delta":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                argumentsDelta: summarizeTraceText(event.argumentsDelta),
+                arguments: summarizeTraceText(event.arguments),
+            };
+        case "tool_call_end":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                arguments: summarizeTraceText(event.arguments),
+            };
+        case "tool_start":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                args: summarizeTraceValue(event.args),
+            };
+        case "tool_update":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                update: summarizeTraceValue(event.update),
+            };
+        case "tool_end":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                result: summarizeTraceToolResult(event.result),
+            };
+        case "turn_end":
+            return {
+                type: event.type,
+                usage: event.usage,
+                willContinue: event.willContinue,
+            };
+        case "input_applied":
+        case "input_rejected":
+            return {
+                ...event,
+                content: summarizeTraceText(event.content),
+            };
+        case "todos_updated":
+            return { type: event.type, count: event.todos.length };
+        default:
+            return { ...event };
+    }
+}
+export function resetDebugTraceForTests() {
+    initialized = false;
+    tracePath = undefined;
+    runId = undefined;
+    sequence = 0;
+    startedAt = performance.now();
+    baseContext = {};
+    defaultPruneDone = false;
+}
+function ensureTracePath() {
+    if (!isDebugTraceEnabled())
+        return undefined;
+    if (initialized)
+        return tracePath;
+    initialized = true;
+    startedAt = performance.now();
+    runId = resolveRunId();
+    tracePath = resolveTracePath(runId);
+    try {
+        mkdirSync(dirname(tracePath), { recursive: true });
+        pruneDefaultTraceDirs();
+    }
+    catch {
+        // The write path may still fail later; tracing remains best-effort.
+    }
+    return tracePath;
+}
+function resolveRunId() {
+    const explicit = process.env.BUBBLE_TRACE_RUN_ID?.trim();
+    if (explicit)
+        return sanitizeFileSegment(explicit);
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `trace-${stamp}-${process.pid}-${randomUUID().slice(0, 8)}`;
+}
+function resolveTracePath(id) {
+    const explicitPath = process.env.BUBBLE_TRACE_PATH?.trim();
+    if (explicitPath)
+        return isAbsolute(explicitPath) ? explicitPath : join(process.cwd(), explicitPath);
+    const value = process.env.BUBBLE_TRACE?.trim();
+    if (value && !TRUE_VALUES.has(value.toLowerCase()) && !FALSE_VALUES.has(value.toLowerCase())) {
+        return isAbsolute(value) ? value : join(process.cwd(), value);
+    }
+    const dateKey = new Date().toISOString().slice(0, 10);
+    return join(getBubbleHome(), "debug-runs", dateKey, `${id}.jsonl`);
+}
+function pruneDefaultTraceDirs() {
+    if (defaultPruneDone || process.env.BUBBLE_TRACE_PATH?.trim())
+        return;
+    defaultPruneDone = true;
+    const maxAgeDays = Number(process.env.BUBBLE_TRACE_MAX_AGE_DAYS ?? DEFAULT_MAX_AGE_DAYS);
+    if (!Number.isFinite(maxAgeDays) || maxAgeDays <= 0)
+        return;
+    const root = join(getBubbleHome(), "debug-runs");
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(root, entry);
+        try {
+            const stat = statSync(path);
+            if (stat.mtimeMs < cutoff)
+                rmSync(path, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup failures.
+        }
+    }
+}
+function summarizeString(value) {
+    const byteLength = Buffer.byteLength(value, "utf8");
+    const summary = {
+        type: "string",
+        chars: value.length,
+        bytes: byteLength,
+        hash: hashString(value),
+    };
+    if (isDebugTraceRawEnabled()) {
+        summary.raw = truncateRaw(value, byteLength);
+    }
+    return summary;
+}
+function summarizeJson(value) {
+    const json = safeJsonStringify(value);
+    if (json === undefined)
+        return { serializable: false };
+    const byteLength = Buffer.byteLength(json, "utf8");
+    const summary = {
+        serializable: true,
+        chars: json.length,
+        bytes: byteLength,
+        hash: hashString(json),
+    };
+    if (isDebugTraceRawEnabled()) {
+        summary.raw = truncateRaw(json, byteLength);
+    }
+    return summary;
+}
+function sanitizeTraceValue(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => sanitizeTraceValue(item));
+    if (typeof value === "object") {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (item !== undefined)
+                out[key] = sanitizeTraceValue(item);
+        }
+        return out;
+    }
+    return String(value);
+}
+function truncateRaw(value, byteLength) {
+    const limit = Number(process.env.BUBBLE_TRACE_RAW_MAX_BYTES ?? DEFAULT_RAW_MAX_BYTES);
+    if (!Number.isFinite(limit) || limit <= 0 || byteLength <= limit)
+        return value;
+    return {
+        value: value.slice(0, Math.max(0, limit)),
+        truncated: true,
+        bytes: byteLength,
+    };
+}
+function truncateString(value, maxChars) {
+    if (!value)
+        return undefined;
+    return value.length > maxChars ? `${value.slice(0, maxChars)}...` : value;
+}
+function hashString(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function dropUndefined(value) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item !== undefined)
+            out[key] = item;
+    }
+    return out;
+}
+function sanitizeFileSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "trace";
+}

package/dist/feishu/agent-host/approval-card.js

@@ -32,6 +32,15 @@ export function formatApprovalRequest(req) {
                     `\n**diff:**\n\`\`\`diff\n${truncate(req.diff, DIFF_PREVIEW_MAX)}\n\`\`\``,
                 ].join("\n"),
             };
+        case "patch":
+            return {
+                title: "应用补丁",
+                body: [
+                    `**files:** ${req.paths.length}`,
+                    `**path:** \`${truncate(req.path, PATH_PREVIEW_MAX)}\``,
+                    `\n**diff:**\n\`\`\`diff\n${truncate(req.diff, DIFF_PREVIEW_MAX)}\n\`\`\``,
+                ].join("\n"),
+            };
         case "lsp":
             return {
                 title: `LSP 操作 (${req.operation})`,

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) {