@bubblebrain-ai/bubble 0.0.16 → 0.0.17

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.js

@@ -5,7 +5,7 @@
 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";
@@ -20,7 +20,7 @@ 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";
@@ -376,6 +376,7 @@ export class Agent {
                     modelId: this.apiModel,
                 };
                 const streamingToolCalls = new Map();
+                const textSanitizer = createStreamingInternalReminderSanitizer();
                 const reasoningSanitizer = createStreamingInternalReminderSanitizer();
                 let turnUsage;
                 let assistantAppended = false;
@@ -433,6 +434,7 @@ export class Agent {
                         toolCount: toolDefinitions.length,
                         thinkingLevel: this.thinkingLevel,
                         mode: this._mode,
+                        requestFingerprint: buildProviderRequestFingerprint(projectedMessages, toolDefinitions, this.providerId),
                     }, traceContext);
                     const stream = this.provider.streamChat(projectedMessages, {
                         model: this.apiModel,
@@ -445,9 +447,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 +475,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 +550,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({
@@ -1525,9 +1541,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),
@@ -1682,6 +1704,76 @@ 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) {
+    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;
+        }
+    }
+    return {
+        roleCounts,
+        estimatedTokens: estimateContextTokens(messages, providerId),
+        projectedJsonBytes: Buffer.byteLength(JSON.stringify(messages), "utf8"),
+        toolSchemaJsonBytes: Buffer.byteLength(JSON.stringify(tools), "utf8"),
+        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/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/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

@@ -83,6 +83,7 @@ async function main() {
             baseURL: defaultProvider.baseURL,
             thinkingLevel: args.thinkingLevel,
             promptCacheKey: sessionPromptCacheKey,
+            protocol: defaultProvider.protocol,
             openAICodexAuth: registry.createOpenAICodexAuthAdapter(defaultProvider.id),
         })
         : createUnavailableProvider(unavailableProviderMessage);
@@ -92,6 +93,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) => {

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 {

package/dist/model-catalog.js

@@ -2,6 +2,7 @@ export const BUILTIN_PROVIDERS = [
     { id: "openrouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1" },
     { id: "openai", name: "OpenAI", baseURL: "https://api.openai.com/v1", supportsOAuth: true },
     { id: "openai-codex", name: "OpenAI Codex (ChatGPT)", baseURL: "https://chatgpt.com/backend-api" },
+    { id: "anthropic", name: "Anthropic", baseURL: "https://api.anthropic.com", protocol: "anthropic-messages" },
     { id: "deepseek", name: "DeepSeek", baseURL: "https://api.deepseek.com" },
     { id: "google", name: "Google", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai" },
     { id: "zhipuai", name: "Zhipu AI", baseURL: "https://open.bigmodel.cn/api/paas/v4" },
@@ -9,6 +10,9 @@ export const BUILTIN_PROVIDERS = [
     { id: "zai", name: "Z.AI", baseURL: "https://api.z.ai/api/paas/v4" },
     { id: "zai-coding-plan", name: "Z.AI Coding Plan", baseURL: "https://api.z.ai/api/coding/paas/v4" },
     { id: "alibaba", name: "Alibaba DashScope", baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
+    { id: "minimax", name: "MiniMax Token Plan", baseURL: "https://api.minimaxi.com/anthropic", protocol: "anthropic-messages" },
+    { id: "minimax-openai", name: "MiniMax (OpenAI Compatible)", baseURL: "https://api.minimaxi.com/v1" },
+    { id: "minimax-anthropic", name: "MiniMax (Anthropic Compatible)", baseURL: "https://api.minimaxi.com/anthropic", protocol: "anthropic-messages", hidden: true },
     { id: "stepfun", name: "StepFun Step Plan", baseURL: "https://api.stepfun.com/step_plan/v1" },
     { id: "moonshot-cn", name: "Moonshot (国内 platform.moonshot.cn)", baseURL: "https://api.moonshot.cn/v1" },
     { id: "moonshot-intl", name: "Moonshot (海外 platform.moonshot.ai)", baseURL: "https://api.moonshot.ai/v1" },
@@ -26,6 +30,10 @@ const OPENAI_CHAT_LEVELS = ["off"];
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
 const DEEPSEEK_V4_LEVELS = ["high", "max"];
 const STEPFUN_REASONING_LEVELS = ["off", "low", "medium", "high"];
+const MINIMAX_M3_REASONING_LEVELS = ["off", "medium"];
+const MINIMAX_REASONING_LEVELS = ["medium"];
+const ANTHROPIC_ADAPTIVE_LEVELS = ["off", "medium"];
+const ANTHROPIC_CHAT_LEVELS = ["off"];
 export const BUILTIN_MODELS = [
     { id: "gpt-5.5", name: "gpt-5.5", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000, toolOutputTokenLimit: 10000 },
     { id: "gpt-5.4", name: "gpt-5.4", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000 },
@@ -42,6 +50,9 @@ export const BUILTIN_MODELS = [
     { id: "o1-preview", name: "o1-preview", providerId: "openai", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "o1-mini", name: "o1-mini", providerId: "openai", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "gpt-4-turbo", name: "gpt-4-turbo", providerId: "openai", reasoningLevels: OPENAI_CHAT_LEVELS, contextWindow: 128000 },
+    { id: "claude-opus-4-8", name: "Claude Opus 4.8", providerId: "anthropic", reasoningLevels: ANTHROPIC_ADAPTIVE_LEVELS, contextWindow: 1000000 },
+    { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", reasoningLevels: ANTHROPIC_ADAPTIVE_LEVELS, contextWindow: 1000000 },
+    { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", providerId: "anthropic", reasoningLevels: ANTHROPIC_CHAT_LEVELS, contextWindow: 200000 },
     { id: "deepseek-v4-flash", name: "deepseek-v4-flash", providerId: "deepseek", reasoningLevels: DEEPSEEK_V4_LEVELS, contextWindow: 1048576 },
     { id: "deepseek-v4-pro", name: "deepseek-v4-pro", providerId: "deepseek", reasoningLevels: DEEPSEEK_V4_LEVELS, contextWindow: 1048576 },
     { id: "gemini-2.5-pro-preview-03-25", name: "gemini-2.5-pro-preview-03-25", providerId: "google", reasoningLevels: ["off", "low", "high"], contextWindow: 128000 },
@@ -61,6 +72,33 @@ export const BUILTIN_MODELS = [
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "qwen3.6-plus", name: "Qwen3.6 Plus", providerId: "alibaba", reasoningLevels: ["off"], contextWindow: 1048576 },
     { id: "qwen3.7-max", name: "Qwen3.7 Max", providerId: "alibaba", reasoningLevels: ["off"], contextWindow: 1048576 },
+    { id: "MiniMax-M3", name: "MiniMax M3", providerId: "minimax", reasoningLevels: MINIMAX_M3_REASONING_LEVELS, contextWindow: 1000000 },
+    { id: "MiniMax-M2.7", name: "MiniMax M2.7", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.7-highspeed", name: "MiniMax M2.7 Highspeed", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.5", name: "MiniMax M2.5", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.5-highspeed", name: "MiniMax M2.5 Highspeed", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.1", name: "MiniMax M2.1", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.1-highspeed", name: "MiniMax M2.1 Highspeed", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2", name: "MiniMax M2", providerId: "minimax", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "M2-her", name: "M2-her", providerId: "minimax", reasoningLevels: ["off"], contextWindow: 64000 },
+    { id: "MiniMax-M3", name: "MiniMax M3", providerId: "minimax-openai", reasoningLevels: MINIMAX_M3_REASONING_LEVELS, contextWindow: 1000000 },
+    { id: "MiniMax-M2.7", name: "MiniMax M2.7", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.7-highspeed", name: "MiniMax M2.7 Highspeed", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.5", name: "MiniMax M2.5", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.5-highspeed", name: "MiniMax M2.5 Highspeed", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.1", name: "MiniMax M2.1", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.1-highspeed", name: "MiniMax M2.1 Highspeed", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2", name: "MiniMax M2", providerId: "minimax-openai", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "M2-her", name: "M2-her", providerId: "minimax-openai", reasoningLevels: ["off"], contextWindow: 64000 },
+    { id: "MiniMax-M3", name: "MiniMax M3", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_M3_REASONING_LEVELS, contextWindow: 1000000 },
+    { id: "MiniMax-M2.7", name: "MiniMax M2.7", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.7-highspeed", name: "MiniMax M2.7 Highspeed", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.5", name: "MiniMax M2.5", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.5-highspeed", name: "MiniMax M2.5 Highspeed", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.1", name: "MiniMax M2.1", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2.1-highspeed", name: "MiniMax M2.1 Highspeed", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "MiniMax-M2", name: "MiniMax M2", providerId: "minimax-anthropic", reasoningLevels: MINIMAX_REASONING_LEVELS, contextWindow: 204800 },
+    { id: "M2-her", name: "M2-her", providerId: "minimax-anthropic", reasoningLevels: ["off"], contextWindow: 64000 },
     { id: "step-3.7-flash", name: "Step 3.7 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS, contextWindow: 256000 },
     { id: "step-3.5-flash-2603", name: "Step 3.5 Flash 2603", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-3.5-flash", name: "Step 3.5 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },

package/dist/model-config.d.ts

@@ -4,10 +4,12 @@
  * Users can define providers, API keys, base URLs, and custom models
  * in ~/.bubble/models.json.
  */
+import type { ProviderProtocol } from "./model-catalog.js";
 import type { ModelInfo } from "./provider-registry.js";
 export interface ProviderModelConfig {
     baseURL?: string;
     apiKey?: string;
+    protocol?: ProviderProtocol;
     models?: Array<{
         id: string;
         name?: string;
@@ -29,4 +31,5 @@ export declare class ModelConfig {
     getCustomModels(providerId: string): ModelInfo[];
     getApiKey(providerId: string): string | undefined;
     getBaseURL(providerId: string): string | undefined;
+    getProtocol(providerId: string): ProviderProtocol | undefined;
 }

package/dist/model-config.js

@@ -56,4 +56,7 @@ export class ModelConfig {
     getBaseURL(providerId) {
         return this.data?.providers?.[providerId]?.baseURL;
     }
+    getProtocol(providerId) {
+        return this.data?.providers?.[providerId]?.protocol;
+    }
 }

package/dist/prompt/compose.js

@@ -38,7 +38,7 @@ function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     const rawModel = modelId ?? modelName ?? "";
     const model = rawModel.includes(":") ? rawModel.split(":").slice(1).join(":") : rawModel;
     const lowerModel = model.toLowerCase();
-    if (provider === "anthropic" || model.startsWith("claude")) {
+    if (provider === "anthropic" || provider === "minimax" || provider.endsWith("-anthropic") || model.startsWith("claude")) {
         return buildAnthropicProviderPrompt(agentName);
     }
     if (provider === "google" || model.startsWith("gemini")) {

package/dist/prompt/reminders.js

@@ -88,12 +88,12 @@ Stop once these categories are covered. Do not keep repeating near-identical sea
 }
 export function buildLoopWarningReminder(reason) {
     return wrapInSystemReminder(`
-Tool loop warning.
+Further broad exploration is low value unless there is a concrete remaining evidence gap.
 
 ${reason}
 
-Do not repeat near-identical reads or searches unless you are changing the path or testing a genuinely new hypothesis.
-If current evidence is sufficient, summarize your findings now.
+Do not repeat near-identical reads or searches unless the path or hypothesis is materially different.
+If current evidence is sufficient, answer with the findings.
 `);
 }
 export function buildSearchFreezeReminder(reason) {

package/dist/prompt/runtime.js

@@ -6,6 +6,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.",
     "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.",

package/dist/provider-anthropic.d.ts

@@ -0,0 +1,77 @@
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, ToolDefinition } from "./types.js";
+export interface AnthropicProviderOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL: string;
+    thinkingLevel?: ThinkingLevel;
+}
+interface AnthropicRequest {
+    model: string;
+    max_tokens: number;
+    messages: AnthropicMessage[];
+    system?: string;
+    tools?: AnthropicTool[];
+    tool_choice?: {
+        type: "auto" | "any";
+    };
+    stream?: boolean;
+    temperature?: number;
+    thinking?: {
+        type: "adaptive";
+    };
+}
+type AnthropicContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: {
+        type: "url";
+        url: string;
+    } | {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+} | {
+    type: "redacted_thinking";
+    data: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+};
+interface AnthropicMessage {
+    role: "user" | "assistant";
+    content: string | AnthropicContentBlock[];
+}
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: ToolDefinition["parameters"];
+}
+export declare function createAnthropicMessagesProvider(options: AnthropicProviderOptions): Provider;
+export declare function buildAnthropicRequest(options: AnthropicProviderOptions, messages: ProviderMessage[], chatOptions: {
+    model: string;
+    tools?: ToolDefinition[];
+    temperature?: number;
+    thinkingLevel?: ThinkingLevel;
+    stream?: boolean;
+}): AnthropicRequest;
+export declare function toAnthropicMessages(messages: ProviderMessage[], echoThinking?: boolean): {
+    system: string;
+    messages: AnthropicMessage[];
+};
+export declare function translateAnthropicStream(events: AsyncIterable<Record<string, unknown>>): AsyncIterable<StreamChunk>;
+export declare function readSseEvents(response: Response): AsyncIterable<Record<string, unknown>>;
+export {};