@bubblebrain-ai/bubble 0.0.15 → 0.0.17

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";
@@ -19,6 +19,8 @@ import { getSubtaskPolicy } from "./agent/subtask-policy.js";
 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, 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";
@@ -374,6 +376,8 @@ export class Agent {
                     modelId: this.apiModel,
                 };
                 const streamingToolCalls = new Map();
+                const textSanitizer = createStreamingInternalReminderSanitizer();
+                const reasoningSanitizer = createStreamingInternalReminderSanitizer();
                 let turnUsage;
                 let assistantAppended = false;
                 currentAssistantMsg = assistantMsg;
@@ -410,6 +414,8 @@ export class Agent {
                 // budget. If it fails (network error, etc.), the projector's existing
                 // algorithmic fallback still kicks in.
                 await this.maybeCompactWithLLM();
+                const bufferedStreamingToolCallIds = new Set();
+                const discoveryBarrier = hookState.discoveryBarrier;
                 try {
                     const projectedMessages = projectMessages(this.messages, {
                         mode: "budgeted",
@@ -428,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,
@@ -440,28 +447,47 @@ 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":
-                                debugReasoningStream({
-                                    stage: "agent_receive",
-                                    providerId: this._providerId,
-                                    modelId: this.apiModel,
-                                    turnStep: step,
-                                    beforeLength: assistantMsg.reasoning?.length ?? 0,
-                                    delta: summarizeDebugText(chunk.content),
-                                    afterLength: (assistantMsg.reasoning?.length ?? 0) + chunk.content.length,
-                                });
-                                assistantMsg.reasoning = (assistantMsg.reasoning || "") + chunk.content;
-                                streamReasoningChars += chunk.content.length;
-                                yield emit({ type: "reasoning_delta", content: chunk.content });
+                                {
+                                    const sanitizedDelta = reasoningSanitizer.push(chunk.content);
+                                    if (sanitizedDelta) {
+                                        debugReasoningStream({
+                                            stage: "agent_receive",
+                                            providerId: this._providerId,
+                                            modelId: this.apiModel,
+                                            turnStep: step,
+                                            beforeLength: assistantMsg.reasoning?.length ?? 0,
+                                            delta: summarizeDebugText(sanitizedDelta),
+                                            afterLength: (assistantMsg.reasoning?.length ?? 0) + sanitizedDelta.length,
+                                        });
+                                        assistantMsg.reasoning = (assistantMsg.reasoning || "") + sanitizedDelta;
+                                        streamReasoningChars += sanitizedDelta.length;
+                                        yield emit({ type: "reasoning_delta", content: sanitizedDelta });
+                                    }
+                                }
+                                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))) {
+                                    bufferedStreamingToolCallIds.add(chunk.id);
+                                }
                                 if (chunk.isStart) {
                                     streamingToolCalls.set(chunk.id, { id: chunk.id, name: chunk.name, args: "" });
-                                    yield emit({ type: "tool_call_start", id: chunk.id, name: chunk.name });
+                                    if (!bufferedStreamingToolCallIds.has(chunk.id)) {
+                                        yield emit({ type: "tool_call_start", id: chunk.id, name: chunk.name });
+                                    }
                                 }
                                 if (!streamingToolCalls.has(chunk.id)) {
                                     streamingToolCalls.set(chunk.id, { id: chunk.id, name: chunk.name, args: "" });
@@ -478,13 +504,15 @@ export class Agent {
                                     }
                                     if (chunk.arguments) {
                                         streamToolCallDeltas += 1;
-                                        yield emit({
-                                            type: "tool_call_delta",
-                                            id: currentToolCall.id,
-                                            name: currentToolCall.name,
-                                            argumentsDelta: chunk.arguments,
-                                            arguments: currentToolCall.args,
-                                        });
+                                        if (!bufferedStreamingToolCallIds.has(chunk.id)) {
+                                            yield emit({
+                                                type: "tool_call_delta",
+                                                id: currentToolCall.id,
+                                                name: currentToolCall.name,
+                                                argumentsDelta: chunk.arguments,
+                                                arguments: currentToolCall.args,
+                                            });
+                                        }
                                     }
                                 }
                                 if (chunk.isEnd && currentToolCall) {
@@ -494,12 +522,14 @@ export class Agent {
                                         arguments: currentToolCall.args,
                                         ...(currentToolCall.argsCorrupt ? { argsCorrupt: true } : {}),
                                     });
-                                    yield emit({
-                                        type: "tool_call_end",
-                                        id: currentToolCall.id,
-                                        name: currentToolCall.name,
-                                        arguments: currentToolCall.args,
-                                    });
+                                    if (!bufferedStreamingToolCallIds.has(chunk.id)) {
+                                        yield emit({
+                                            type: "tool_call_end",
+                                            id: currentToolCall.id,
+                                            name: currentToolCall.name,
+                                            arguments: currentToolCall.args,
+                                        });
+                                    }
                                     streamingToolCalls.delete(chunk.id);
                                 }
                                 break;
@@ -520,6 +550,27 @@ 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({
+                            stage: "agent_receive_flush",
+                            providerId: this._providerId,
+                            modelId: this.apiModel,
+                            turnStep: step,
+                            beforeLength: assistantMsg.reasoning?.length ?? 0,
+                            delta: summarizeDebugText(flushedReasoning),
+                            afterLength: (assistantMsg.reasoning?.length ?? 0) + flushedReasoning.length,
+                        });
+                        assistantMsg.reasoning = (assistantMsg.reasoning || "") + flushedReasoning;
+                        streamReasoningChars += flushedReasoning.length;
+                        yield emit({ type: "reasoning_delta", content: flushedReasoning });
+                    }
                     traceEvent("provider_stream_end", {
                         elapsedMs: Date.now() - providerStartedAt,
                         textChars: streamTextChars,
@@ -590,6 +641,16 @@ export class Agent {
                             parsedCalls.push({ ...tc, parsedArgs: {}, argsCorrupt: true });
                         }
                     }
+                    const orderedCalls = hookState.discoveryBarrier?.orderToolCalls(parsedCalls) ?? parsedCalls;
+                    if (orderedCalls !== parsedCalls) {
+                        parsedCalls.splice(0, parsedCalls.length, ...orderedCalls);
+                        assistantMsg.toolCalls = parsedCalls.map((tc) => ({
+                            id: tc.id,
+                            name: tc.name,
+                            arguments: tc.arguments,
+                            ...(tc.argsCorrupt ? { argsCorrupt: true } : {}),
+                        }));
+                    }
                     const executedResults = [];
                     const appendCancelledToolMessages = (startIndex) => {
                         for (let pendingIndex = startIndex; pendingIndex < parsedCalls.length; pendingIndex++) {
@@ -634,6 +695,51 @@ export class Agent {
                             arguments: tc.arguments,
                         };
                         flushGovernorReminders();
+                        if (bufferedStreamingToolCallIds.has(tc.id) && !isHiddenToolResult(blockedResult)) {
+                            yield emit({ type: "tool_call_start", id: tc.id, name: tc.name });
+                            if (tc.arguments) {
+                                yield emit({
+                                    type: "tool_call_delta",
+                                    id: tc.id,
+                                    name: tc.name,
+                                    argumentsDelta: tc.arguments,
+                                    arguments: tc.arguments,
+                                });
+                            }
+                            yield emit({ type: "tool_call_end", id: tc.id, name: tc.name, arguments: tc.arguments });
+                        }
+                        if (isHiddenToolResult(blockedResult)) {
+                            let result = blockedResult;
+                            await hookBus.runAfterToolCall({
+                                agent: this,
+                                cwd,
+                                input: userInput,
+                                state: hookState,
+                                queueReminder,
+                                flushReminders: flushGovernorReminders,
+                                toolCall: tc,
+                                result,
+                                replaceResult: (next) => {
+                                    result = next;
+                                },
+                            });
+                            traceEvent("speculative_read_blocked", {
+                                id: tc.id,
+                                name: tc.name,
+                                args: summarizeTraceValue(tc.parsedArgs),
+                                result: summarizeTraceToolResult(result),
+                            }, traceContext);
+                            this.appendMessage({
+                                role: "tool",
+                                toolCallId: tc.id,
+                                content: result.content,
+                                metadata: result.metadata,
+                                isError: result.isError,
+                            });
+                            executedResults.push(result);
+                            flushGovernorReminders();
+                            continue;
+                        }
                         const toolStartedAt = Date.now();
                         traceEvent("tool_execute_start", {
                             id: tc.id,
@@ -1435,6 +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),
@@ -1589,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/context/projector.js

@@ -1,6 +1,7 @@
 import { getContextBudget } from "./budget.js";
 import { compactCurrentTurnToolGroups, compactMessages } from "./compact.js";
 import { pruneMessages } from "./prune.js";
+import { formatInternalContextBlock, formatInternalReminderBlock } from "../agent/internal-reminder-sanitizer.js";
 // Prefix-cache invariant: only the leading static system prompt is promoted to
 // the first provider message. Runtime meta reminders stay in the conversational
 // body at their original relative position, so a new per-turn reminder does not
@@ -166,14 +167,14 @@ function isEmptyAssistantMessage(message) {
 function formatMetaMessage(message) {
     switch (message.kind) {
         case "system-reminder":
-            return `Runtime reminder:\n${message.content}`;
+            return formatInternalReminderBlock(message.kind, message.content);
         case "runtime-context":
         default:
-            return `Runtime context:\n${message.content}`;
+            return formatInternalContextBlock(message.kind, message.content);
     }
 }
 function formatRuntimeSystemMessage(message) {
-    return `Runtime context:\n${message.content}`;
+    return formatInternalContextBlock("runtime-system", message.content);
 }
 function cloneMessage(message) {
     if (message.role === "assistant") {

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,10 @@ 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" },
     { id: "kimi-for-coding", name: "Kimi for Coding", baseURL: "https://api.kimi.com/coding/v1" },
@@ -24,6 +29,11 @@ const GPT51_CODEX_MINI_LEVELS = ["off", "medium", "high"];
 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 },
@@ -40,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 },
@@ -59,6 +72,37 @@ 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 },
+    { id: "step-router-v1", name: "Step Router V1", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },

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/model-pricing.d.ts

@@ -1,8 +1,9 @@
 import type { TokenUsage } from "./types.js";
+export type PricingCurrency = "USD" | "CNY";
 export interface ModelPricing {
     providerId: string;
     modelId: string;
-    currency: "USD";
+    currency: PricingCurrency;
     inputCacheHitPerMillion: number;
     inputCacheMissPerMillion: number;
     outputPerMillion: number;
@@ -14,7 +15,7 @@ export interface ModelPricing {
     };
 }
 export interface UsageCost {
-    currency: "USD";
+    currency: PricingCurrency;
     cost: number;
     estimated: boolean;
 }

package/dist/model-pricing.js

@@ -21,6 +21,14 @@ export const MODEL_PRICING = [
             outputPerMillion: 3.48,
         },
     },
+    {
+        providerId: "stepfun",
+        modelId: "step-3.7-flash",
+        currency: "CNY",
+        inputCacheHitPerMillion: 0.27,
+        inputCacheMissPerMillion: 1.35,
+        outputPerMillion: 8.1,
+    },
 ];
 export function getModelPricing(providerId, modelId) {
     return MODEL_PRICING.find((item) => item.providerId === providerId && item.modelId === modelId);

package/dist/network/chatgpt-transport.d.ts

@@ -0,0 +1,16 @@
+import { type Dispatcher } from "undici";
+export type ChatGptFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface ChatGptFetchOptions {
+    fetch?: ChatGptFetch;
+    env?: NodeJS.ProcessEnv;
+}
+type RequestInitWithDispatcher = RequestInit & {
+    dispatcher?: Dispatcher;
+};
+export declare function chatGptFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function getChatGptFetch(env?: NodeJS.ProcessEnv): ChatGptFetch;
+export declare function createChatGptFetch(options?: ChatGptFetchOptions): ChatGptFetch;
+export declare function createChatGptDispatcher(env?: NodeJS.ProcessEnv, input?: RequestInfo | URL): Dispatcher | undefined;
+export declare function withChatGptNetworkOptions(input: RequestInfo | URL, init: RequestInit | undefined, env?: NodeJS.ProcessEnv, dispatcher?: Dispatcher | undefined): RequestInitWithDispatcher;
+export declare function normalizeChatGptNetworkError(error: unknown, env?: NodeJS.ProcessEnv): Error;
+export {};