@bubblebrain-ai/bubble 0.0.17 → 0.0.19

package/dist/provider-anthropic.d.ts

@@ -1,4 +1,7 @@
-import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, ToolDefinition } from "./types.js";
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, ToolChoiceMode, ToolDefinition } from "./types.js";
+declare const ANTHROPIC_PROMPT_CACHE_CONTROL: {
+    readonly type: "ephemeral";
+};
 export interface AnthropicProviderOptions {
     providerId?: string;
     apiKey: string;
@@ -9,10 +12,10 @@ interface AnthropicRequest {
     model: string;
     max_tokens: number;
     messages: AnthropicMessage[];
-    system?: string;
+    system?: string | AnthropicSystemBlock[];
     tools?: AnthropicTool[];
     tool_choice?: {
-        type: "auto" | "any";
+        type: "auto" | "any" | "none";
     };
     stream?: boolean;
     temperature?: number;
@@ -20,6 +23,12 @@ interface AnthropicRequest {
         type: "adaptive";
     };
 }
+type AnthropicCacheControl = typeof ANTHROPIC_PROMPT_CACHE_CONTROL;
+interface AnthropicSystemBlock {
+    type: "text";
+    text: string;
+    cache_control?: AnthropicCacheControl;
+}
 type AnthropicContentBlock = {
     type: "text";
     text: string;
@@ -59,15 +68,18 @@ interface AnthropicTool {
     name: string;
     description: string;
     input_schema: ToolDefinition["parameters"];
+    cache_control?: AnthropicCacheControl;
 }
 export declare function createAnthropicMessagesProvider(options: AnthropicProviderOptions): Provider;
 export declare function buildAnthropicRequest(options: AnthropicProviderOptions, messages: ProviderMessage[], chatOptions: {
     model: string;
     tools?: ToolDefinition[];
+    toolChoice?: ToolChoiceMode;
     temperature?: number;
     thinkingLevel?: ThinkingLevel;
     stream?: boolean;
 }): AnthropicRequest;
+export declare function supportsAnthropicPromptCache(options: AnthropicProviderOptions, model: string): boolean;
 export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean): {
     system: string;
     messages: AnthropicMessage[];

package/dist/provider-anthropic.js

@@ -1,11 +1,23 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./provider-transform.js";
 const ANTHROPIC_VERSION = "2023-06-01";
 const DEFAULT_MAX_TOKENS = 8192;
+const ANTHROPIC_PROMPT_CACHE_CONTROL = { type: "ephemeral" };
+const MINIMAX_PROMPT_CACHE_MODELS = new Set([
+    "minimax-m2.7",
+    "minimax-m2.7-highspeed",
+    "minimax-m2.5",
+    "minimax-m2.5-highspeed",
+    "minimax-m2.1",
+    "minimax-m2.1-highspeed",
+    "minimax-m2",
+    "m2-her",
+]);
 export function createAnthropicMessagesProvider(options) {
     async function* streamChat(messages, chatOptions) {
         const body = buildAnthropicRequest(options, messages, {
             model: chatOptions.model,
             tools: chatOptions.tools,
+            toolChoice: chatOptions.toolChoice,
             temperature: chatOptions.temperature,
             thinkingLevel: chatOptions.thinkingLevel,
             stream: true,
@@ -41,18 +53,25 @@ export function createAnthropicMessagesProvider(options) {
 }
 export function buildAnthropicRequest(options, messages, chatOptions) {
     const { system, messages: anthropicMessages } = toAnthropicMessages(messages, shouldEchoThinking(options.providerId));
+    const enablePromptCache = supportsAnthropicPromptCache(options, chatOptions.model);
     const tools = chatOptions.tools?.map((tool) => ({
         name: tool.name,
         description: tool.description,
         input_schema: tool.parameters,
     }));
+    if (enablePromptCache && tools && tools.length > 0) {
+        tools[tools.length - 1] = {
+            ...tools[tools.length - 1],
+            cache_control: ANTHROPIC_PROMPT_CACHE_CONTROL,
+        };
+    }
     const body = {
         model: chatOptions.model,
         max_tokens: DEFAULT_MAX_TOKENS,
-        system: system || undefined,
+        system: buildAnthropicSystem(system, enablePromptCache),
         messages: anthropicMessages,
         tools: tools && tools.length > 0 ? tools : undefined,
-        tool_choice: tools && tools.length > 0 ? { type: "auto" } : undefined,
+        tool_choice: tools && tools.length > 0 ? { type: chatOptions.toolChoice ?? "auto" } : undefined,
         stream: chatOptions.stream || undefined,
     };
     if (typeof chatOptions.temperature === "number") {
@@ -64,6 +83,23 @@ export function buildAnthropicRequest(options, messages, chatOptions) {
     }
     return body;
 }
+function buildAnthropicSystem(system, enablePromptCache) {
+    if (!system)
+        return undefined;
+    if (!enablePromptCache)
+        return system;
+    return [{ type: "text", text: system, cache_control: ANTHROPIC_PROMPT_CACHE_CONTROL }];
+}
+export function supportsAnthropicPromptCache(options, model) {
+    const providerId = (options.providerId ?? "").toLowerCase();
+    if (providerId === "anthropic" || isOfficialAnthropicBaseUrl(options.baseURL)) {
+        return true;
+    }
+    if (!isMiniMaxAnthropicEndpoint(options)) {
+        return false;
+    }
+    return MINIMAX_PROMPT_CACHE_MODELS.has(model.toLowerCase());
+}
 export function toAnthropicMessages(messages, echoThinking = false) {
     const system = [];
     const out = [];
@@ -512,6 +548,7 @@ function mergeAnthropicUsage(current, raw) {
     let promptTokens = current?.promptTokens ?? 0;
     let promptCacheHitTokens = current?.promptCacheHitTokens;
     let promptCacheMissTokens = current?.promptCacheMissTokens;
+    let cacheCreationTokens = current?.cacheCreationTokens;
     if (hasPromptUsage) {
         const inputTokens = rawInput ?? promptCacheMissTokens ?? promptTokens;
         const cacheRead = rawCacheRead ?? promptCacheHitTokens ?? 0;
@@ -519,12 +556,14 @@ function mergeAnthropicUsage(current, raw) {
         promptTokens = inputTokens + cacheRead + cacheCreation;
         promptCacheHitTokens = cacheRead;
         promptCacheMissTokens = inputTokens + cacheCreation;
+        cacheCreationTokens = cacheCreation;
     }
     return {
         promptTokens,
         completionTokens: outputTokens,
         promptCacheHitTokens,
         promptCacheMissTokens,
+        cacheCreationTokens,
         totalTokens: promptTokens + outputTokens,
     };
 }
@@ -534,6 +573,20 @@ function shouldEchoThinking(providerId) {
 function shouldSendBearerAuth(options) {
     return !isOfficialAnthropicBaseUrl(options.baseURL) || options.providerId?.startsWith("minimax") === true;
 }
+function isMiniMaxAnthropicEndpoint(options) {
+    const providerId = (options.providerId ?? "").toLowerCase();
+    if (providerId !== "minimax" && providerId !== "minimax-anthropic")
+        return false;
+    try {
+        const url = new URL(options.baseURL);
+        const host = url.hostname.toLowerCase();
+        const path = url.pathname.toLowerCase();
+        return (host === "api.minimax.io" || host === "api.minimaxi.com") && path.includes("/anthropic");
+    }
+    catch {
+        return false;
+    }
+}
 function isOfficialAnthropicBaseUrl(baseURL) {
     try {
         return new URL(baseURL).hostname === "api.anthropic.com";

package/dist/provider-openai-codex.js

@@ -72,6 +72,7 @@ export function createOpenAICodexProvider(options) {
         const body = JSON.stringify(buildRequestBody(messages, {
             model: chatOptions.model,
             tools: chatOptions.tools,
+            toolChoice: chatOptions.toolChoice,
             reasoningEffort: requestConfig.reasoningEffort,
             sessionId,
             providerId: options.providerId,
@@ -314,7 +315,7 @@ function buildRequestBody(messages, options) {
             providerId: options.providerId,
             model: options.model,
         }),
-        tool_choice: "auto",
+        tool_choice: options.tools && options.tools.length > 0 ? options.toolChoice ?? "auto" : undefined,
         parallel_tool_calls: true,
         text: { verbosity: "medium" },
     };
@@ -454,6 +455,7 @@ function isTransientCodexTransportError(error) {
         /\bEPIPE\b/i,
         /socket hang up/i,
         /fetch failed/i,
+        /Unable to connect\. Is the computer able to access the url\?/i,
         /unknown certificate verification error/i,
         /certificate (?:verify|verification) (?:failed|error)/i,
         /unable to verify (?:the )?(?:first )?certificate/i,

package/dist/provider.js

@@ -106,7 +106,7 @@ export function createProviderInstance(options) {
                 reasoningContentEcho: requestConfig.reasoningContentEcho ?? "tool_calls",
             })),
             tools: tools && tools.length > 0 ? tools : undefined,
-            tool_choice: tools && tools.length > 0 ? "auto" : undefined,
+            tool_choice: tools && tools.length > 0 ? chatOptions.toolChoice ?? "auto" : undefined,
             stream: true,
         };
         // DeepSeek and MiniMax only emit final usage in streaming mode when this flag is set.

package/dist/session-title.js

@@ -1,6 +1,5 @@
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
-const LONG_PASTE_CHAR_THRESHOLD = 1000;
-const LONG_PASTE_LINE_THRESHOLD = 20;
+import { createPastedContentMarker, shouldCollapsePastedContent } from "./tui/paste-placeholder.js";
 const TITLE_INPUT_MAX_CHARS = 4000;
 const TITLE_MAX_WIDTH = 80;
 const TITLE_SYSTEM_PROMPT = [
@@ -81,10 +80,8 @@ export function deterministicTitleFromUserContent(content) {
     const text = userContentText(content);
     if (!text)
         return "User message";
-    const charCount = text.length;
-    const lineCount = text.split(/\r?\n/).length;
-    if (charCount > LONG_PASTE_CHAR_THRESHOLD || lineCount > LONG_PASTE_LINE_THRESHOLD) {
-        return `[Pasted Content ${charCount} chars]`;
+    if (shouldCollapsePastedContent(text)) {
+        return createPastedContentMarker(text);
     }
     return truncateVisual(normalizeSingleLine(text), TITLE_MAX_WIDTH) || "User message";
 }

package/dist/slash-commands/commands.js

@@ -61,6 +61,9 @@ function persistSelectedModel(model, ctx) {
 }
 function syncSystemPrompt(ctx, model) {
     const { providerId, modelId } = decodeModel(model);
+    const toolPromptOptions = typeof ctx.agent.getSystemPromptToolOptions === "function"
+        ? ctx.agent.getSystemPromptToolOptions()
+        : {};
     ctx.agent.setSystemPrompt(buildSystemPrompt({
         agentName: "Bubble",
         configuredProvider: providerId,
@@ -68,6 +71,7 @@ function syncSystemPrompt(ctx, model) {
         configuredModelId: model,
         thinkingLevel: ctx.agent.thinking,
         workingDir: ctx.cwd,
+        ...toolPromptOptions,
         memoryPrompt: buildMemoryPrompt(ctx.cwd),
     }));
 }

package/dist/stats/usage.d.ts

@@ -20,6 +20,7 @@ export interface ModelUsageStats {
     completionTokens: number;
     promptCacheHitTokens: number;
     promptCacheMissTokens: number;
+    cacheCreationTokens: number;
     reasoningTokens: number;
     totalTokens: number;
     cost?: number;

package/dist/stats/usage.js

@@ -187,6 +187,7 @@ function addModelUsage(accumulator, model, message, usage) {
         completionTokens: 0,
         promptCacheHitTokens: 0,
         promptCacheMissTokens: 0,
+        cacheCreationTokens: 0,
         reasoningTokens: 0,
         totalTokens: 0,
     };
@@ -195,6 +196,7 @@ function addModelUsage(accumulator, model, message, usage) {
     existing.completionTokens += usage.completionTokens;
     existing.promptCacheHitTokens += usage.promptCacheHitTokens ?? 0;
     existing.promptCacheMissTokens += usage.promptCacheMissTokens ?? 0;
+    existing.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
     existing.reasoningTokens += usage.reasoningTokens ?? 0;
     existing.totalTokens += tokenTotal(usage);
     if (providerId && modelId) {
@@ -284,6 +286,9 @@ function formatSummaryLines(stats, width) {
     if (favorite) {
         lines.push(`  Favorite model ${truncate(favorite, Math.max(12, width - 17))}`);
     }
+    const cacheSummary = formatCacheSummary(stats.models);
+    if (cacheSummary)
+        lines.push(`  ${cacheSummary}`);
     const trackedCostText = formatTrackedCosts(stats);
     if (trackedCostText)
         lines.push(`  Tracked cost ${trackedCostText}`);
@@ -293,6 +298,17 @@ function formatSummaryLines(stats, width) {
     }
     return lines;
 }
+function formatCacheSummary(models) {
+    const read = models.reduce((sum, model) => sum + model.promptCacheHitTokens, 0);
+    const create = models.reduce((sum, model) => sum + model.cacheCreationTokens, 0);
+    const missWithCreate = models.reduce((sum, model) => sum + model.promptCacheMissTokens, 0);
+    const miss = Math.max(0, missWithCreate - create);
+    const observed = read + create + miss;
+    if (observed === 0)
+        return undefined;
+    const hitRate = Math.round((read / observed) * 100);
+    return `Prompt cache ${formatCompactNumber(read)} read · ${formatCompactNumber(create)} create · ${formatCompactNumber(miss)} miss · ${hitRate}% hit`;
+}
 function aggregateCosts(models) {
     const totals = {};
     for (const model of models) {
@@ -355,15 +371,24 @@ function normalizeUsage(raw) {
     if (!raw || typeof raw !== "object")
         return undefined;
     const value = raw;
-    const promptTokens = numberValue(value.promptTokens) ?? numberValue(value.input_tokens);
+    const rawInputTokens = numberValue(value.input_tokens);
+    const cacheReadTokens = numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens);
+    const cacheCreationTokens = numberValue(value.cacheCreationTokens) ?? numberValue(value.cache_creation_input_tokens);
+    const promptTokens = numberValue(value.promptTokens)
+        ?? (rawInputTokens !== undefined
+            ? rawInputTokens + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0)
+            : undefined);
     const completionTokens = numberValue(value.completionTokens) ?? numberValue(value.output_tokens);
     if (promptTokens === undefined || completionTokens === undefined)
         return undefined;
     return {
         promptTokens,
         completionTokens,
-        promptCacheHitTokens: numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens),
-        promptCacheMissTokens: numberValue(value.promptCacheMissTokens) ?? numberValue(value.cache_creation_input_tokens),
+        promptCacheHitTokens: cacheReadTokens,
+        promptCacheMissTokens: numberValue(value.promptCacheMissTokens)
+            ?? numberValue(value.cache_miss_input_tokens)
+            ?? (rawInputTokens !== undefined ? rawInputTokens + (cacheCreationTokens ?? 0) : undefined),
+        cacheCreationTokens,
         reasoningTokens: numberValue(value.reasoningTokens),
         totalTokens: numberValue(value.totalTokens) ?? numberValue(value.total_tokens),
     };

package/dist/tools/edit.js

@@ -13,12 +13,66 @@ import { applyEditsToContent, EditApplyError, formatEditMatchNotes } from "./edi
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { isWithinWorkspace } from "./file-state.js";
 import { resolveToolPath } from "./path-utils.js";
+function prepareEditArguments(input) {
+    if (!input || typeof input !== "object")
+        return input;
+    const args = { ...input };
+    if (typeof args.file_path === "string" && typeof args.path !== "string") {
+        args.path = args.file_path;
+    }
+    if (typeof args.edits === "string") {
+        try {
+            const parsed = JSON.parse(args.edits);
+            if (Array.isArray(parsed))
+                args.edits = parsed;
+        }
+        catch {
+            // Keep the original value so validation surfaces the problem.
+        }
+    }
+    if (Array.isArray(args.edits)) {
+        args.edits = args.edits.map((edit) => {
+            if (!edit || typeof edit !== "object")
+                return edit;
+            const normalized = { ...edit };
+            if (typeof normalized.oldText !== "string") {
+                normalized.oldText = firstString(edit.old_text, edit.oldString, edit.old_string);
+            }
+            if (typeof normalized.newText !== "string") {
+                normalized.newText = firstString(edit.new_text, edit.newString, edit.new_string);
+            }
+            return normalized;
+        });
+    }
+    if (!Array.isArray(args.edits)) {
+        const oldText = firstString(args.oldText, args.old_text, args.oldString, args.old_string);
+        const newText = firstString(args.newText, args.new_text, args.newString, args.new_string);
+        if (typeof oldText === "string" && typeof newText === "string") {
+            args.edits = [{ oldText, newText }];
+        }
+    }
+    return args;
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
 export function createEditTool(cwd, approval, lsp, fileState) {
     return {
         name: "edit",
         effect: "write_direct",
         requiresApproval: true,
-        description: "Apply targeted string replacements to a file. Prefer exact oldText copied from a recent read. The tool can tolerate common AI formatting mistakes such as extra leading/trailing whitespace, over-escaped sequences, line ending differences, indentation differences, trailing whitespace, Unicode punctuation/space, and blank-line differences when the target is unique.",
+        description: "Edit a single file using targeted text replacements. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+        promptGuidelines: [
+            "Use edit for precise changes; edits[].oldText should be copied from a recent read and must identify a unique target.",
+            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls.",
+            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+            "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
+        ],
         parameters: {
             type: "object",
             properties: {
@@ -38,7 +92,27 @@ export function createEditTool(cwd, approval, lsp, fileState) {
             },
             required: ["path", "edits"],
         },
+        prepareArguments: prepareEditArguments,
         async execute(args) {
+            if (!Array.isArray(args.edits)) {
+                return {
+                    content: "Error: edit requires edits to be an array of { oldText, newText } replacements.",
+                    isError: true,
+                    status: "blocked",
+                    metadata: { kind: "edit", reason: "invalid_args" },
+                };
+            }
+            for (let index = 0; index < args.edits.length; index++) {
+                const edit = args.edits[index];
+                if (!edit || typeof edit !== "object" || typeof edit.oldText !== "string" || typeof edit.newText !== "string") {
+                    return {
+                        content: `Error: edit requires edits[${index}] to contain string oldText and newText fields.`,
+                        isError: true,
+                        status: "blocked",
+                        metadata: { kind: "edit", reason: "invalid_args", index },
+                    };
+                }
+            }
             const filePath = resolveToolPath(cwd, args.path);
             if (!isWithinWorkspace(cwd, filePath)) {
                 return {

package/dist/tools/glob.js

@@ -2,10 +2,10 @@
  * Glob tool - discover files by path pattern without shell access.
  */
 import { readdir, stat } from "node:fs/promises";
-import { relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import picomatch from "picomatch";
 import { isSensitivePath } from "./sensitive-paths.js";
-import { resolveToolPath } from "./path-utils.js";
+import { expandHomePath, resolveToolPath } from "./path-utils.js";
 const MAX_RESULTS = 100;
 const DEFAULT_IGNORES = new Set([
     ".git",
@@ -32,11 +32,16 @@ export function createGlobTool(cwd) {
             required: ["pattern"],
         },
         async execute(args, ctx) {
-            const root = resolveToolPath(cwd, typeof args.path === "string" && args.path.trim() ? args.path : ".");
-            const pattern = String(args.pattern || "").trim();
-            if (!pattern) {
+            const requestedRoot = resolveToolPath(cwd, typeof args.path === "string" && args.path.trim() ? args.path : ".");
+            const originalPattern = String(args.pattern || "").trim();
+            if (!originalPattern) {
                 return { content: "Error: glob pattern is required", isError: true, status: "command_error" };
             }
+            const normalized = normalizeGlobSearch(requestedRoot, originalPattern);
+            if (normalized.error) {
+                return normalized.error;
+            }
+            const { root, pattern, normalizedPattern } = normalized;
             if (isSensitivePath(root)) {
                 return {
                     content: `Error: Glob blocked for sensitive credential storage: ${root}`,
@@ -45,7 +50,9 @@ export function createGlobTool(cwd) {
                     metadata: {
                         kind: "security",
                         path: root,
-                        pattern,
+                        pattern: normalizedPattern,
+                        originalPattern,
+                        normalizedPattern,
                         reason: "Sensitive credential storage is not searchable from general-purpose tasks.",
                     },
                 };
@@ -74,11 +81,13 @@ export function createGlobTool(cwd) {
                     metadata: {
                         kind: "search",
                         path: root,
-                        pattern,
+                        pattern: normalizedPattern,
+                        originalPattern,
+                        normalizedPattern,
                         matches: 0,
                         truncated: false,
-                        searchSignature: `glob:${root}:${pattern}`,
-                        searchFamily: `glob:${pattern}`,
+                        searchSignature: `glob:${root}:${normalizedPattern}`,
+                        searchFamily: `glob:${normalizedPattern}`,
                         paths: [],
                     },
                 };
@@ -89,17 +98,70 @@ export function createGlobTool(cwd) {
                 metadata: {
                     kind: "search",
                     path: root,
-                    pattern,
+                    pattern: normalizedPattern,
+                    originalPattern,
+                    normalizedPattern,
                     matches: matches.length,
                     truncated: wasTruncated,
-                    searchSignature: `glob:${root}:${pattern}`,
-                    searchFamily: `glob:${pattern}`,
+                    searchSignature: `glob:${root}:${normalizedPattern}`,
+                    searchFamily: `glob:${normalizedPattern}`,
                     paths: absoluteMatches,
                 },
             };
         },
     };
 }
+function normalizeGlobSearch(requestedRoot, originalPattern) {
+    const expandedPattern = expandGlobPatternHome(originalPattern);
+    const scan = picomatch.scan(expandedPattern);
+    const prefix = scan.prefix ?? "";
+    if (!isAbsolute(scan.base)) {
+        if (escapesSearchRoot(scan.base)) {
+            return {
+                error: {
+                    content: `Error: Glob pattern must stay within the search path: ${originalPattern}`,
+                    isError: true,
+                    status: "command_error",
+                    metadata: {
+                        kind: "search",
+                        path: requestedRoot,
+                        pattern: originalPattern,
+                        originalPattern,
+                        normalizedPattern: originalPattern,
+                        reason: "pattern_outside_search_path",
+                    },
+                },
+            };
+        }
+        return { root: requestedRoot, pattern: originalPattern, normalizedPattern: originalPattern };
+    }
+    const absoluteBase = resolve(scan.base);
+    const patternRoot = scan.isGlob ? absoluteBase : dirname(absoluteBase);
+    const patternBody = scan.isGlob ? scan.glob : basename(absoluteBase);
+    const normalizedRoot = isWithinSearchRoot(requestedRoot, patternRoot) ? requestedRoot : patternRoot;
+    const relativeBase = toPosix(relative(normalizedRoot, patternRoot));
+    const normalizedBody = [relativeBase, patternBody].filter(Boolean).join("/");
+    const normalizedPattern = `${prefix}${normalizedBody}`;
+    return {
+        root: normalizedRoot,
+        pattern: normalizedPattern,
+        normalizedPattern,
+    };
+}
+function expandGlobPatternHome(pattern) {
+    if (pattern.startsWith("!")) {
+        return `!${expandHomePath(pattern.slice(1))}`;
+    }
+    return expandHomePath(pattern);
+}
+function escapesSearchRoot(base) {
+    const normalized = toPosix(base);
+    return normalized === ".." || normalized.startsWith("../");
+}
+function isWithinSearchRoot(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
 async function walk(root, dir, matcher, files, truncated, abortSignal) {
     if (abortSignal?.aborted || files.length >= MAX_RESULTS) {
         truncated.value = true;
@@ -115,6 +177,9 @@ async function walk(root, dir, matcher, files, truncated, abortSignal) {
             continue;
         }
         const absolute = resolve(dir, entry.name);
+        if (isSensitivePath(absolute)) {
+            continue;
+        }
         const rel = toPosix(relative(root, absolute));
         if (entry.isDirectory()) {
             await walk(root, absolute, matcher, files, truncated, abortSignal);

package/dist/tools/index.d.ts

@@ -6,7 +6,7 @@ export { createBashTool } from "./bash.js";
 export { createManagedServerTools } from "./server.js";
 export { createWriteTool } from "./write.js";
 export { createEditTool } from "./edit.js";
-export { createApplyPatchTool } from "./apply-patch.js";
+export { buildToolPromptOptions } from "./prompt-metadata.js";
 export { createGlobTool } from "./glob.js";
 export { createGrepTool } from "./grep.js";
 export { createLspTool } from "./lsp.js";

package/dist/tools/index.js

@@ -6,7 +6,7 @@ export { createBashTool } from "./bash.js";
 export { createManagedServerTools } from "./server.js";
 export { createWriteTool } from "./write.js";
 export { createEditTool } from "./edit.js";
-export { createApplyPatchTool } from "./apply-patch.js";
+export { buildToolPromptOptions } from "./prompt-metadata.js";
 export { createGlobTool } from "./glob.js";
 export { createGrepTool } from "./grep.js";
 export { createLspTool } from "./lsp.js";
@@ -23,7 +23,6 @@ export { createMemoryReadSummaryTool, createMemorySearchTool } from "./memory.js
 import { createBashTool } from "./bash.js";
 import { createManagedServerTools } from "./server.js";
 import { createEditTool } from "./edit.js";
-import { createApplyPatchTool } from "./apply-patch.js";
 import { createExitPlanModeTool } from "./exit-plan-mode.js";
 import { createGlobTool } from "./glob.js";
 import { createGrepTool } from "./grep.js";
@@ -51,7 +50,6 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
         ...createManagedServerTools(cwd, approval),
         createWriteTool(cwd, {}, approval, lsp, fileState),
         createEditTool(cwd, approval, lsp, fileState),
-        createApplyPatchTool(cwd, approval, lsp, fileState),
         createGlobTool(cwd),
         createGrepTool(cwd),
         createLspTool(cwd, lsp, approval),

package/dist/tools/prompt-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { SystemPromptOptions } from "../system-prompt.js";
+import type { ToolRegistryEntry } from "../types.js";
+export declare function buildToolPromptOptions(tools: ToolRegistryEntry[]): Pick<SystemPromptOptions, "tools" | "toolSnippets" | "guidelines">;

package/dist/tools/prompt-metadata.js

@@ -0,0 +1,17 @@
+export function buildToolPromptOptions(tools) {
+    const toolSnippets = {};
+    const guidelines = [];
+    for (const tool of tools) {
+        if (tool.promptSnippet) {
+            toolSnippets[tool.name] = tool.promptSnippet;
+        }
+        for (const guideline of tool.promptGuidelines ?? []) {
+            guidelines.push(guideline);
+        }
+    }
+    return {
+        tools: tools.map((tool) => tool.name),
+        toolSnippets,
+        guidelines,
+    };
+}

package/dist/tools/write.js

@@ -9,12 +9,25 @@ import { formatDiagnosticBlocks } from "../lsp/index.js";
 import { isWithinWorkspace } from "./file-state.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToolPath } from "./path-utils.js";
+function prepareWriteArguments(input) {
+    if (!input || typeof input !== "object")
+        return input;
+    const args = { ...input };
+    if (typeof args.file_path === "string" && typeof args.path !== "string") {
+        args.path = args.file_path;
+    }
+    return args;
+}
 export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
     return {
         name: "write",
         effect: "write_direct",
         requiresApproval: true,
         description: "Write content to a file. Creates parent directories as needed. If the file already exists, this replaces the full file; use edit for small targeted changes.",
+        promptSnippet: "Create new files or intentionally rewrite complete files",
+        promptGuidelines: [
+            "Use write only for new files, generated files, or intentional complete rewrites. Use edit for targeted changes to existing files.",
+        ],
         parameters: {
             type: "object",
             properties: {
@@ -23,6 +36,7 @@ export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
             },
             required: ["path", "content"],
         },
+        prepareArguments: prepareWriteArguments,
         async execute(args) {
             const filePath = resolveToolPath(cwd, args.path);
             if (!isWithinWorkspace(cwd, filePath)) {