@bubblebrain-ai/bubble 0.0.16 → 0.0.18

package/dist/agent/internal-reminder-sanitizer.d.ts

@@ -1,6 +1,8 @@
+import type { AssistantProviderMetadata } from "../types.js";
 export declare function formatInternalReminderBlock(kind: string, content: string): string;
 export declare function formatInternalContextBlock(kind: string, content: string): string;
 export declare function sanitizeInternalReminderBlocks(text: string): string;
+export declare function sanitizeAssistantProviderMetadata(metadata: AssistantProviderMetadata | undefined): AssistantProviderMetadata | undefined;
 export declare function createStreamingInternalReminderSanitizer(): {
     push(delta: string): string;
     flush(): string;

package/dist/agent/internal-reminder-sanitizer.js

@@ -37,6 +37,33 @@ export function sanitizeInternalReminderBlocks(text) {
     const sanitizer = createStreamingInternalReminderSanitizer();
     return sanitizer.push(text) + sanitizer.flush();
 }
+export function sanitizeAssistantProviderMetadata(metadata) {
+    const anthropic = metadata?.anthropic;
+    const blocks = anthropic?.contentBlocks;
+    if (!metadata || !anthropic || !blocks?.length)
+        return metadata;
+    let changed = false;
+    const sanitizedBlocks = blocks.map((block) => {
+        if (block.type !== "text" || typeof block.text !== "string") {
+            return block;
+        }
+        const sanitizedText = sanitizeInternalReminderBlocks(block.text);
+        if (sanitizedText === block.text) {
+            return block;
+        }
+        changed = true;
+        return { ...block, text: sanitizedText };
+    });
+    if (!changed)
+        return metadata;
+    return {
+        ...metadata,
+        anthropic: {
+            ...anthropic,
+            contentBlocks: sanitizedBlocks,
+        },
+    };
+}
 export function createStreamingInternalReminderSanitizer() {
     let pending = "";
     const drain = (final) => {

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

@@ -5,13 +5,13 @@
 import { compactMessages } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { compactMessagesWithLLM } from "./context/compact-llm.js";
-import { getContextBudget } from "./context/budget.js";
+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";
@@ -20,10 +20,11 @@ import { composeAbortSignals } from "./agent/budget-ledger.js";
 import { assignAgentNickname, builtinAgentProfiles, mergeUsage, selectToolsForAgentProfile, validateAgentProfileTools } from "./agent/profiles.js";
 import { snapshotSubagentThread, subagentResultFromThread } from "./agent/subagent-control.js";
 import { isHiddenToolResult } from "./agent/discovery-barrier.js";
-import { createStreamingInternalReminderSanitizer, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
+import { createStreamingInternalReminderSanitizer, sanitizeAssistantProviderMetadata, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
 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;
@@ -376,6 +382,7 @@ export class Agent {
                     modelId: this.apiModel,
                 };
                 const streamingToolCalls = new Map();
+                const textSanitizer = createStreamingInternalReminderSanitizer();
                 const reasoningSanitizer = createStreamingInternalReminderSanitizer();
                 let turnUsage;
                 let assistantAppended = false;
@@ -397,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,
@@ -416,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,
@@ -433,10 +439,12 @@ export class Agent {
                         toolCount: toolDefinitions.length,
                         thinkingLevel: this.thinkingLevel,
                         mode: this._mode,
+                        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,
@@ -445,9 +453,14 @@ export class Agent {
                         throwIfAborted(abortSignal);
                         switch (chunk.type) {
                             case "text":
-                                assistantMsg.content += chunk.content;
-                                streamTextChars += chunk.content.length;
-                                yield emit({ type: "text_delta", content: chunk.content });
+                                {
+                                    const sanitizedDelta = textSanitizer.push(chunk.content);
+                                    if (sanitizedDelta) {
+                                        assistantMsg.content += sanitizedDelta;
+                                        streamTextChars += sanitizedDelta.length;
+                                        yield emit({ type: "text_delta", content: sanitizedDelta });
+                                    }
+                                }
                                 break;
                             case "reasoning_delta":
                                 {
@@ -468,6 +481,9 @@ export class Agent {
                                     }
                                 }
                                 break;
+                            case "provider_content_block":
+                                appendProviderContentBlock(assistantMsg, chunk.provider, chunk.block);
+                                break;
                             case "tool_call":
                                 if (discoveryBarrier?.isEnabled()
                                     && (bufferedStreamingToolCallIds.has(chunk.id) || discoveryBarrier.shouldBufferStreamingToolCall(chunk.name))) {
@@ -540,6 +556,12 @@ export class Agent {
                         for (const update of this.drainSubagentToolUpdates())
                             yield emit(update);
                     }
+                    const flushedText = textSanitizer.flush();
+                    if (flushedText) {
+                        assistantMsg.content += flushedText;
+                        streamTextChars += flushedText.length;
+                        yield emit({ type: "text_delta", content: flushedText });
+                    }
                     const flushedReasoning = reasoningSanitizer.flush();
                     if (flushedReasoning) {
                         debugReasoningStream({
@@ -1350,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,
@@ -1502,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);
         }
@@ -1525,9 +1546,15 @@ export class Agent {
         }
     }
     appendMessage(message) {
+        if (message.role === "assistant" && message.content) {
+            message.content = sanitizeInternalReminderBlocks(message.content);
+        }
         if (message.role === "assistant" && message.reasoning) {
             message.reasoning = sanitizeInternalReminderBlocks(message.reasoning);
         }
+        if (message.role === "assistant" && message.providerMetadata) {
+            message.providerMetadata = sanitizeAssistantProviderMetadata(message.providerMetadata);
+        }
         this.messages.push(message);
         traceEvent("agent_message_append", {
             message: summarizeTraceMessage(message),
@@ -1605,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(", ")}. ` +
@@ -1616,7 +1658,7 @@ export class Agent {
             };
         }
         try {
-            return await tool.execute(toolCall.parsedArgs, {
+            return await tool.execute(preparedArgs, {
                 cwd,
                 sessionID: this.sessionID,
                 abortSignal,
@@ -1682,6 +1724,89 @@ function estimateResidentChars(messages) {
     }
     return total;
 }
+function appendProviderContentBlock(message, provider, block) {
+    if (provider !== "anthropic")
+        return;
+    const current = message.providerMetadata?.anthropic?.contentBlocks ?? [];
+    message.providerMetadata = {
+        ...message.providerMetadata,
+        anthropic: {
+            ...message.providerMetadata?.anthropic,
+            contentBlocks: [...current, cloneProviderRawContentBlock(block)],
+        },
+    };
+}
+function buildProviderRequestFingerprint(messages, tools, providerId, toolChoice) {
+    const roleCounts = {};
+    let contentChars = 0;
+    let reasoningChars = 0;
+    let toolResultChars = 0;
+    let maxToolResultChars = 0;
+    let assistantToolCalls = 0;
+    let rawAnthropicBlocks = 0;
+    let rawAnthropicThinkingBlocks = 0;
+    let rawAnthropicSignatureChars = 0;
+    for (const message of messages) {
+        roleCounts[message.role] = (roleCounts[message.role] ?? 0) + 1;
+        if (message.role === "assistant") {
+            contentChars += message.content.length;
+            reasoningChars += message.reasoning?.length ?? 0;
+            assistantToolCalls += message.toolCalls?.length ?? 0;
+            const blocks = message.providerMetadata?.anthropic?.contentBlocks ?? [];
+            rawAnthropicBlocks += blocks.length;
+            for (const block of blocks) {
+                if (block.type === "thinking" || block.type === "redacted_thinking") {
+                    rawAnthropicThinkingBlocks += 1;
+                }
+                if (typeof block.signature === "string") {
+                    rawAnthropicSignatureChars += block.signature.length;
+                }
+            }
+        }
+        else if (message.role === "tool") {
+            toolResultChars += message.content.length;
+            maxToolResultChars = Math.max(maxToolResultChars, message.content.length);
+        }
+        else if (message.role === "user") {
+            contentChars += typeof message.content === "string"
+                ? message.content.length
+                : message.content.reduce((sum, part) => sum + (part.type === "text" ? part.text.length : part.image_url.url.length), 0);
+        }
+        else {
+            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"),
+        systemJsonBytes,
+        bodyJsonBytes,
+        toolSchemaJsonBytes,
+        staticPrefixJsonBytes: Buffer.byteLength(JSON.stringify({
+            system: systemMessages,
+            tools,
+            tool_choice: toolChoice,
+        }), "utf8"),
+        toolChoice,
+        contentChars,
+        reasoningChars,
+        toolResultChars,
+        maxToolResultChars,
+        assistantToolCalls,
+        rawAnthropicBlocks,
+        rawAnthropicThinkingBlocks,
+        rawAnthropicSignatureChars,
+    };
+}
+function cloneProviderRawContentBlock(block) {
+    return JSON.parse(JSON.stringify(block));
+}
 function throwIfAborted(signal) {
     if (!signal?.aborted)
         return;

package/dist/context/budget.js

@@ -20,6 +20,7 @@ export function estimateMessageTokens(message, providerId) {
         case "assistant":
             return estimate(message.content)
                 + estimate(message.reasoning ?? "")
+                + estimateProviderMetadataOverhead(message.providerMetadata, providerId)
                 + (message.toolCalls?.reduce((sum, toolCall) => sum + estimate(toolCall.arguments) + 12, 0) ?? 0)
                 + 8;
         case "user":
@@ -34,6 +35,20 @@ export function estimateMessageTokens(message, providerId) {
             }, 8);
     }
 }
+function estimateProviderMetadataOverhead(metadata, providerId) {
+    const blocks = metadata?.anthropic?.contentBlocks;
+    if (!blocks || blocks.length === 0)
+        return 0;
+    const estimate = (text) => estimateTextTokens(text, providerId);
+    return blocks.reduce((sum, block) => {
+        let overhead = 0;
+        if (typeof block.signature === "string")
+            overhead += estimate(block.signature);
+        if (block.type === "redacted_thinking" && typeof block.data === "string")
+            overhead += estimate(block.data);
+        return sum + overhead;
+    }, 0);
+}
 export function estimateContextTokens(messages, providerId) {
     return messages.reduce((sum, message) => sum + estimateMessageTokens(message, providerId), 0);
 }

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/debug-trace.js

@@ -112,6 +112,7 @@ export function summarizeTraceMessage(message) {
             content: summarizeTraceText(message.content),
             reasoning: summarizeTraceText(message.reasoning ?? ""),
             error: message.error,
+            providerMetadata: summarizeAssistantProviderMetadata(message),
             toolCalls: message.toolCalls?.map((call) => ({
                 id: call.id,
                 name: call.name,
@@ -141,6 +142,19 @@ export function summarizeTraceMessage(message) {
         content: summarizeTraceText(message.content),
     };
 }
+function summarizeAssistantProviderMetadata(message) {
+    const blocks = message.providerMetadata?.anthropic?.contentBlocks;
+    if (!blocks || blocks.length === 0)
+        return undefined;
+    return {
+        anthropic: {
+            contentBlocks: blocks.length,
+            thinkingBlocks: blocks.filter((block) => block.type === "thinking" || block.type === "redacted_thinking").length,
+            signatureChars: blocks.reduce((sum, block) => sum + (typeof block.signature === "string" ? block.signature.length : 0), 0),
+            types: blocks.map((block) => block.type).slice(0, 32),
+        },
+    };
+}
 export function summarizeTraceToolResult(result) {
     return {
         content: summarizeTraceText(result.content),

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/feishu/serve.js

@@ -96,6 +96,7 @@ export async function serveFeishu(opts = {}) {
         apiKey,
         baseURL,
         promptCacheKey,
+        protocol: providerRegistry.getConfigured().find((provider) => provider.id === providerId)?.protocol,
         openAICodexAuth: providerRegistry.createOpenAICodexAuthAdapter(providerId),
     });
     const createProviderForRoute = async (route, promptCacheKey) => {

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";
@@ -83,6 +84,7 @@ async function main() {
             baseURL: defaultProvider.baseURL,
             thinkingLevel: args.thinkingLevel,
             promptCacheKey: sessionPromptCacheKey,
+            protocol: defaultProvider.protocol,
             openAICodexAuth: registry.createOpenAICodexAuthAdapter(defaultProvider.id),
         })
         : createUnavailableProvider(unavailableProviderMessage);
@@ -92,6 +94,7 @@ async function main() {
         baseURL,
         thinkingLevel: args.thinkingLevel,
         promptCacheKey: sessionPromptCacheKey,
+        protocol: registry.getConfigured().find((provider) => provider.id === providerId)?.protocol,
         openAICodexAuth: registry.createOpenAICodexAuthAdapter(providerId),
     });
     const createProviderForRoute = async (route) => {
@@ -242,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: "" };
@@ -286,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-catalog.d.ts

@@ -1,8 +1,11 @@
 import type { ReasoningEffort } from "./types.js";
+export type ProviderProtocol = "openai-chat" | "anthropic-messages";
 export interface BuiltinProviderDefinition {
     id: string;
     name: string;
     baseURL: string;
+    protocol?: ProviderProtocol;
+    hidden?: boolean;
     supportsOAuth?: boolean;
 }
 export interface BuiltinModelDefinition {