@bubblebrain-ai/bubble 0.0.17 → 0.0.18

package/dist/agent/tool-intent.js

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

package/dist/agent.d.ts

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

package/dist/agent.js

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

package/dist/context/prune.d.ts

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

package/dist/context/prune.js

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

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

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

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

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

package/dist/main.js

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

package/dist/model-pricing.js

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

package/dist/model-selection.d.ts

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

package/dist/model-selection.js

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

package/dist/network/chatgpt-transport.js

@@ -195,6 +195,7 @@ function isChatGptNetworkErrorText(text) {
         /\bEPIPE\b/i,
         /\bUND_ERR_/i,
         /socket hang up/i,
+        /Unable to connect\. Is the computer able to access the url\?/i,
         /certificate/i,
         /unable to verify/i,
         /self[- ]signed/i,

package/dist/orchestrator/default-hooks.js

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

package/dist/prompt/environment.js

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

package/dist/prompt/runtime.js

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

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.