@bubblebrain-ai/bubble 0.0.16 → 0.0.17

package/dist/provider-anthropic.js

@@ -0,0 +1,544 @@
+import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./provider-transform.js";
+const ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_MAX_TOKENS = 8192;
+export function createAnthropicMessagesProvider(options) {
+    async function* streamChat(messages, chatOptions) {
+        const body = buildAnthropicRequest(options, messages, {
+            model: chatOptions.model,
+            tools: chatOptions.tools,
+            temperature: chatOptions.temperature,
+            thinkingLevel: chatOptions.thinkingLevel,
+            stream: true,
+        });
+        const response = await fetchAnthropicResponseWithRetry(options, {
+            url: resolveAnthropicMessagesUrl(options.baseURL),
+            stream: true,
+            method: "POST",
+            body: JSON.stringify(body),
+            signal: chatOptions.abortSignal,
+        });
+        yield* translateAnthropicStream(readSseEvents(response));
+        yield { type: "done" };
+    }
+    async function complete(messages, chatOptions) {
+        const body = buildAnthropicRequest(options, messages, {
+            model: chatOptions?.model ?? "claude-sonnet-4-6",
+            temperature: chatOptions?.temperature,
+            thinkingLevel: chatOptions?.thinkingLevel,
+            stream: false,
+        });
+        const response = await fetchAnthropicResponseWithRetry(options, {
+            url: resolveAnthropicMessagesUrl(options.baseURL),
+            stream: false,
+            method: "POST",
+            body: JSON.stringify(body),
+            signal: chatOptions?.abortSignal,
+        });
+        const data = await response.json();
+        return extractAnthropicText(data.content).join("");
+    }
+    return { streamChat, complete };
+}
+export function buildAnthropicRequest(options, messages, chatOptions) {
+    const { system, messages: anthropicMessages } = toAnthropicMessages(messages, shouldEchoThinking(options.providerId));
+    const tools = chatOptions.tools?.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters,
+    }));
+    const body = {
+        model: chatOptions.model,
+        max_tokens: DEFAULT_MAX_TOKENS,
+        system: system || undefined,
+        messages: anthropicMessages,
+        tools: tools && tools.length > 0 ? tools : undefined,
+        tool_choice: tools && tools.length > 0 ? { type: "auto" } : undefined,
+        stream: chatOptions.stream || undefined,
+    };
+    if (typeof chatOptions.temperature === "number") {
+        body.temperature = chatOptions.temperature;
+    }
+    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off", getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
+    if (effectiveThinkingLevel !== "off") {
+        body.thinking = { type: "adaptive" };
+    }
+    return body;
+}
+export function toAnthropicMessages(messages, echoThinking = false) {
+    const system = [];
+    const out = [];
+    const thinkingReplayIndexes = getThinkingReplayIndexes(messages, echoThinking);
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role === "system") {
+            system.push(message.content);
+            continue;
+        }
+        if (message.role === "tool") {
+            pushAnthropicMessage(out, {
+                role: "user",
+                content: [{
+                        type: "tool_result",
+                        tool_use_id: message.toolCallId,
+                        content: message.content,
+                        ...(message.isError ? { is_error: true } : {}),
+                    }],
+            });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const content = buildAssistantAnthropicBlocks(message, thinkingReplayIndexes.has(index));
+            if (content.length > 0) {
+                pushAnthropicMessage(out, { role: "assistant", content });
+            }
+            continue;
+        }
+        pushAnthropicMessage(out, {
+            role: "user",
+            content: typeof message.content === "string"
+                ? message.content
+                : contentPartsToAnthropicBlocks(message.content),
+        });
+    }
+    return { system: system.join("\n\n"), messages: out };
+}
+function buildAssistantAnthropicBlocks(message, includeThinking) {
+    const rawBlocks = message.providerMetadata?.anthropic?.contentBlocks;
+    if (rawBlocks && rawBlocks.length > 0) {
+        const blocks = rawBlocks
+            .filter(isReplayableAssistantContentBlock)
+            .filter((block) => includeThinking || !isThinkingContentBlock(block))
+            .map((block) => cloneAnthropicContentBlock(block));
+        if (blocks.length > 0) {
+            return blocks;
+        }
+    }
+    const content = [];
+    if (includeThinking && message.reasoning?.trim()) {
+        content.push({ type: "thinking", thinking: message.reasoning });
+    }
+    if (message.content.trim()) {
+        content.push({ type: "text", text: message.content });
+    }
+    for (const toolCall of message.toolCalls ?? []) {
+        content.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.name,
+            input: parseToolInput(toolCall.arguments),
+        });
+    }
+    return content;
+}
+function getThinkingReplayIndexes(messages, echoThinking) {
+    const indexes = new Set();
+    if (!echoThinking)
+        return indexes;
+    let lastUserIndex = -1;
+    for (let index = 0; index < messages.length; index++) {
+        if (messages[index].role === "user") {
+            lastUserIndex = index;
+        }
+    }
+    for (let index = Math.max(0, lastUserIndex + 1); index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role === "assistant" && assistantHasToolUse(message)) {
+            indexes.add(index);
+        }
+    }
+    return indexes;
+}
+function assistantHasToolUse(message) {
+    if (message.toolCalls && message.toolCalls.length > 0)
+        return true;
+    return message.providerMetadata?.anthropic?.contentBlocks?.some((block) => block.type === "tool_use") ?? false;
+}
+function isThinkingContentBlock(block) {
+    return block.type === "thinking" || block.type === "redacted_thinking";
+}
+function isReplayableAssistantContentBlock(block) {
+    switch (block.type) {
+        case "text":
+            return typeof block.text === "string";
+        case "thinking":
+            return typeof block.thinking === "string";
+        case "redacted_thinking":
+            return typeof block.data === "string";
+        case "tool_use":
+            return typeof block.id === "string" && typeof block.name === "string" && isObjectRecord(block.input);
+        default:
+            return false;
+    }
+}
+function cloneAnthropicContentBlock(block) {
+    return JSON.parse(JSON.stringify(block));
+}
+export async function* translateAnthropicStream(events) {
+    const blocks = new Map();
+    let usage;
+    for await (const event of events) {
+        const type = typeof event.type === "string" ? event.type : "";
+        if (type === "message_start") {
+            usage = mergeAnthropicUsage(usage, event.message?.usage);
+            if (usage)
+                yield { type: "usage", usage };
+            continue;
+        }
+        if (type === "message_delta") {
+            usage = mergeAnthropicUsage(usage, event.usage);
+            if (usage)
+                yield { type: "usage", usage };
+            continue;
+        }
+        if (type === "error") {
+            const err = event.error;
+            throw new Error(`Anthropic stream error: ${String(err?.message || err?.type || "unknown error")}`);
+        }
+        if (type === "content_block_start") {
+            const index = typeof event.index === "number" ? event.index : 0;
+            const block = event.content_block;
+            const blockType = typeof block?.type === "string" ? block.type : "";
+            const raw = cloneProviderBlock(block, blockType);
+            const state = {
+                type: blockType,
+                id: typeof block?.id === "string" ? block.id : undefined,
+                name: typeof block?.name === "string" ? block.name : undefined,
+                args: "",
+                started: false,
+                input: isObjectRecord(block?.input) ? block.input : undefined,
+                raw,
+                text: typeof block?.text === "string" ? block.text : "",
+                thinking: typeof block?.thinking === "string" ? block.thinking : "",
+                signature: typeof block?.signature === "string" ? block.signature : "",
+            };
+            blocks.set(index, state);
+            if (blockType === "text" && typeof block?.text === "string" && block.text) {
+                yield { type: "text", content: block.text };
+            }
+            if (blockType === "thinking" && typeof block?.thinking === "string" && block.thinking) {
+                yield { type: "reasoning_delta", content: block.thinking };
+            }
+            if (blockType === "tool_use" && state.id && state.name) {
+                state.started = true;
+                yield { type: "tool_call", id: state.id, name: state.name, arguments: "", isStart: true, isEnd: false };
+            }
+            continue;
+        }
+        if (type === "content_block_delta") {
+            const index = typeof event.index === "number" ? event.index : 0;
+            const state = blocks.get(index);
+            const delta = event.delta;
+            const deltaType = typeof delta?.type === "string" ? delta.type : "";
+            if (deltaType === "text_delta" && typeof delta?.text === "string" && delta.text) {
+                if (state) {
+                    state.text += delta.text;
+                    state.raw.text = state.text;
+                }
+                yield { type: "text", content: delta.text };
+            }
+            else if (deltaType === "thinking_delta" && typeof delta?.thinking === "string" && delta.thinking) {
+                if (state) {
+                    state.thinking += delta.thinking;
+                    state.raw.thinking = state.thinking;
+                }
+                yield { type: "reasoning_delta", content: delta.thinking };
+            }
+            else if (deltaType === "signature_delta" && typeof delta?.signature === "string" && state) {
+                state.signature += delta.signature;
+                state.raw.signature = state.signature;
+            }
+            else if (deltaType === "input_json_delta" && state?.id && state.name && typeof delta?.partial_json === "string") {
+                state.args += delta.partial_json;
+                if (!state.started) {
+                    state.started = true;
+                    yield { type: "tool_call", id: state.id, name: state.name, arguments: "", isStart: true, isEnd: false };
+                }
+                if (delta.partial_json) {
+                    yield { type: "tool_call", id: state.id, name: state.name, arguments: delta.partial_json, isStart: false, isEnd: false };
+                }
+            }
+            continue;
+        }
+        if (type === "content_block_stop") {
+            const index = typeof event.index === "number" ? event.index : 0;
+            const state = blocks.get(index);
+            blocks.delete(index);
+            if (state?.type === "tool_use" && state.id && state.name) {
+                const finalArgs = state.args || JSON.stringify(state.input ?? {});
+                state.raw.input = parseToolInput(normalizeToolArgs(finalArgs));
+                yield { type: "provider_content_block", provider: "anthropic", block: state.raw };
+                yield {
+                    type: "tool_call",
+                    id: state.id,
+                    name: state.name,
+                    arguments: "",
+                    argumentsFull: normalizeToolArgs(finalArgs),
+                    isStart: false,
+                    isEnd: true,
+                };
+            }
+            else if (state && isReplayableAssistantContentBlock(state.raw)) {
+                finalizeRawContentBlock(state);
+                yield { type: "provider_content_block", provider: "anthropic", block: state.raw };
+            }
+        }
+    }
+}
+export async function* readSseEvents(response) {
+    if (!response.body) {
+        throw new Error("Anthropic Messages API returned an empty stream body.");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let separator = buffer.indexOf("\n\n");
+            while (separator >= 0) {
+                const raw = buffer.slice(0, separator);
+                buffer = buffer.slice(separator + 2);
+                const event = parseSseEvent(raw);
+                if (event)
+                    yield event;
+                separator = buffer.indexOf("\n\n");
+            }
+        }
+        buffer += decoder.decode();
+        const event = parseSseEvent(buffer);
+        if (event)
+            yield event;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function fetchAnthropicResponseWithRetry(options, request) {
+    const maxAttempts = shouldRetryMiniMaxAnthropic(options) ? 2 : 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const response = await fetch(request.url, {
+            method: request.method,
+            headers: buildAnthropicHeaders(options, request.stream),
+            body: request.body,
+            signal: request.signal,
+        });
+        if (response.ok)
+            return response;
+        const detail = await readAnthropicErrorDetail(response);
+        const error = new Error(`Anthropic Messages API error ${response.status}: ${detail || response.statusText}`);
+        lastError = error;
+        if (attempt >= maxAttempts || !isRetryableMiniMaxAnthropicError(response.status, detail)) {
+            throw error;
+        }
+        await sleepBeforeRetry(getAnthropicRetryDelayMs(), request.signal);
+    }
+    throw lastError ?? new Error("Anthropic Messages API request failed");
+}
+function resolveAnthropicMessagesUrl(baseURL) {
+    const normalized = baseURL.trim().replace(/\/+$/, "");
+    if (normalized.endsWith("/v1/messages"))
+        return normalized;
+    if (normalized.endsWith("/v1"))
+        return `${normalized}/messages`;
+    return `${normalized || "https://api.anthropic.com"}/v1/messages`;
+}
+function buildAnthropicHeaders(options, stream) {
+    const headers = {
+        "content-type": "application/json",
+        "x-api-key": options.apiKey,
+        "anthropic-version": ANTHROPIC_VERSION,
+    };
+    if (shouldSendBearerAuth(options)) {
+        headers.authorization = `Bearer ${options.apiKey}`;
+    }
+    if (stream)
+        headers.accept = "text/event-stream";
+    return headers;
+}
+async function readAnthropicErrorDetail(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return response.statusText;
+    }
+}
+function shouldRetryMiniMaxAnthropic(options) {
+    const providerId = (options.providerId || "").toLowerCase();
+    const baseURL = options.baseURL.toLowerCase();
+    return providerId.startsWith("minimax") || baseURL.includes("api.minimaxi.com") || baseURL.includes("api.minimax.io");
+}
+function isRetryableMiniMaxAnthropicError(status, detail) {
+    return status === 500
+        || status === 502
+        || status === 503
+        || status === 504
+        || detail.includes("714 (1000)");
+}
+function getAnthropicRetryDelayMs() {
+    if (process.env.NODE_ENV === "test")
+        return 0;
+    return 800 + Math.floor(Math.random() * 700);
+}
+function sleepBeforeRetry(ms, signal) {
+    if (signal?.aborted) {
+        return Promise.reject(toAbortError(signal));
+    }
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(toAbortError(signal));
+        }, { once: true });
+    });
+}
+function toAbortError(signal) {
+    const reason = signal?.reason;
+    if (reason instanceof Error)
+        return reason;
+    const error = new Error("Anthropic request retry aborted.");
+    error.name = "AbortError";
+    return error;
+}
+function parseSseEvent(raw) {
+    const dataLines = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line || line.startsWith(":"))
+            continue;
+        if (line.startsWith("data:")) {
+            dataLines.push(line.slice(5).trimStart());
+        }
+    }
+    if (dataLines.length === 0)
+        return undefined;
+    const data = dataLines.join("\n");
+    if (!data || data === "[DONE]")
+        return undefined;
+    return JSON.parse(data);
+}
+function cloneProviderBlock(block, fallbackType) {
+    const type = typeof block?.type === "string" && block.type ? block.type : fallbackType || "unknown";
+    const clone = block ? JSON.parse(JSON.stringify(block)) : {};
+    clone.type = type;
+    return clone;
+}
+function finalizeRawContentBlock(state) {
+    if (state.type === "text") {
+        state.raw.text = state.text;
+    }
+    else if (state.type === "thinking") {
+        state.raw.thinking = state.thinking;
+        if (state.signature) {
+            state.raw.signature = state.signature;
+        }
+    }
+}
+function contentPartsToAnthropicBlocks(parts) {
+    const blocks = [];
+    for (const part of parts) {
+        if (part.type === "text") {
+            blocks.push({ type: "text", text: part.text });
+            continue;
+        }
+        const image = part.image_url.url;
+        const dataUrlMatch = image.match(/^data:([^;,]+);base64,(.+)$/);
+        if (dataUrlMatch) {
+            blocks.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: dataUrlMatch[1],
+                    data: dataUrlMatch[2],
+                },
+            });
+        }
+        else {
+            blocks.push({ type: "image", source: { type: "url", url: image } });
+        }
+    }
+    return blocks;
+}
+function pushAnthropicMessage(messages, next) {
+    const last = messages.at(-1);
+    if (!last || last.role !== next.role) {
+        messages.push(next);
+        return;
+    }
+    last.content = mergeAnthropicContent(last.content, next.content);
+}
+function mergeAnthropicContent(current, next) {
+    const currentBlocks = typeof current === "string" ? [{ type: "text", text: current }] : current;
+    const nextBlocks = typeof next === "string" ? [{ type: "text", text: next }] : next;
+    return [...currentBlocks, ...nextBlocks];
+}
+function parseToolInput(raw) {
+    try {
+        const parsed = JSON.parse(raw || "{}");
+        return isObjectRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeToolArgs(raw) {
+    try {
+        JSON.parse(raw);
+        return raw;
+    }
+    catch {
+        return "{}";
+    }
+}
+function isObjectRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function extractAnthropicText(content) {
+    if (!content)
+        return [];
+    return content.flatMap((block) => block.type === "text" && typeof block.text === "string" ? [block.text] : []);
+}
+function mergeAnthropicUsage(current, raw) {
+    if (!isObjectRecord(raw))
+        return current;
+    const rawInput = typeof raw.input_tokens === "number" ? raw.input_tokens : undefined;
+    const rawCacheRead = typeof raw.cache_read_input_tokens === "number" ? raw.cache_read_input_tokens : undefined;
+    const rawCacheCreation = typeof raw.cache_creation_input_tokens === "number" ? raw.cache_creation_input_tokens : undefined;
+    const outputTokens = typeof raw.output_tokens === "number" ? raw.output_tokens : current?.completionTokens ?? 0;
+    const hasPromptUsage = rawInput !== undefined || rawCacheRead !== undefined || rawCacheCreation !== undefined;
+    let promptTokens = current?.promptTokens ?? 0;
+    let promptCacheHitTokens = current?.promptCacheHitTokens;
+    let promptCacheMissTokens = current?.promptCacheMissTokens;
+    if (hasPromptUsage) {
+        const inputTokens = rawInput ?? promptCacheMissTokens ?? promptTokens;
+        const cacheRead = rawCacheRead ?? promptCacheHitTokens ?? 0;
+        const cacheCreation = rawCacheCreation ?? 0;
+        promptTokens = inputTokens + cacheRead + cacheCreation;
+        promptCacheHitTokens = cacheRead;
+        promptCacheMissTokens = inputTokens + cacheCreation;
+    }
+    return {
+        promptTokens,
+        completionTokens: outputTokens,
+        promptCacheHitTokens,
+        promptCacheMissTokens,
+        totalTokens: promptTokens + outputTokens,
+    };
+}
+function shouldEchoThinking(providerId) {
+    return providerId?.startsWith("minimax") ?? false;
+}
+function shouldSendBearerAuth(options) {
+    return !isOfficialAnthropicBaseUrl(options.baseURL) || options.providerId?.startsWith("minimax") === true;
+}
+function isOfficialAnthropicBaseUrl(baseURL) {
+    try {
+        return new URL(baseURL).hostname === "api.anthropic.com";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/provider-registry.d.ts

@@ -5,6 +5,7 @@
  * Reads provider configuration from models.json first, then falls back to config.json.
  */
 import type { UserConfig } from "./config.js";
+import { type ProviderProtocol } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
@@ -15,6 +16,7 @@ export interface ProviderProfile {
     apiKey: string;
     enabled: boolean;
     authType?: "api" | "oauth";
+    protocol?: ProviderProtocol;
 }
 export interface ModelInfo {
     id: string;

package/dist/provider-registry.js

@@ -11,7 +11,7 @@ import { fetchOpenAICodexModels } from "./provider-openai-codex.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
 export const USER_VISIBLE_PROVIDER_IDS = BUILTIN_PROVIDERS
-    .filter((provider) => provider.id !== "openrouter" && provider.id !== "openai-codex")
+    .filter((provider) => !provider.hidden && provider.id !== "openrouter" && provider.id !== "openai-codex")
     .map((provider) => provider.id);
 export function isUserVisibleProvider(providerId) {
     return USER_VISIBLE_PROVIDER_IDS.includes(providerId);
@@ -123,19 +123,27 @@ export class ProviderRegistry {
             providers = keys.map((id) => {
                 const builtin = getBuiltinProvider(id);
                 const cfg = modelsJsonProviders[id];
+                const baseURL = cfg.baseURL || builtin?.baseURL || "";
                 return {
                     id,
                     name: builtin?.name || id,
-                    baseURL: cfg.baseURL || builtin?.baseURL || "",
+                    baseURL,
                     apiKey: cfg.apiKey || "",
                     enabled: true,
                     authType: "api",
+                    protocol: resolveConfiguredProtocol(id, baseURL, cfg.protocol),
                 };
             });
         }
         else {
             // 2. Fall back to config.json providers (interactive TUI style)
-            providers = this.config.getProviders();
+            providers = this.config.getProviders().map((provider) => {
+                const builtin = getBuiltinProvider(provider.id);
+                return {
+                    ...provider,
+                    protocol: resolveConfiguredProtocol(provider.id, provider.baseURL, provider.protocol),
+                };
+            });
         }
         // 3. Inject OAuth access tokens
         for (const p of providers) {
@@ -283,6 +291,24 @@ export class ProviderRegistry {
         }));
     }
 }
+function resolveConfiguredProtocol(providerId, baseURL, explicitProtocol) {
+    if (explicitProtocol)
+        return explicitProtocol;
+    const builtin = getBuiltinProvider(providerId);
+    if (!builtin?.protocol)
+        return undefined;
+    const normalizedBaseURL = normalizeBaseURL(baseURL);
+    if (!normalizedBaseURL || normalizedBaseURL === normalizeBaseURL(builtin.baseURL)) {
+        return builtin.protocol;
+    }
+    if (normalizedBaseURL.includes("/anthropic")) {
+        return "anthropic-messages";
+    }
+    return undefined;
+}
+function normalizeBaseURL(baseURL) {
+    return baseURL.trim().replace(/\/+$/, "").toLowerCase();
+}
 /** Encode a model selection as "providerId:modelId". */
 export function encodeModel(providerId, modelId) {
     return `${providerId}:${modelId}`;

package/dist/provider-transform.d.ts

@@ -3,7 +3,7 @@ export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;
-    reasoningContentEcho?: "tool_calls" | "all" | "none";
+    reasoningContentEcho?: "tool_calls" | "all" | "none" | "minimax";
     parallelToolCalls?: boolean;
     maxTokens?: number;
     extraBody?: Record<string, unknown>;

package/dist/provider-transform.js

@@ -4,6 +4,7 @@ const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for
 const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
 const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
+const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
 function isFireworksKimi(providerId, modelId) {
     const model = modelId.toLowerCase();
     return providerId === "fireworks" && (model.includes("kimi")
@@ -45,6 +46,19 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 : { reasoning_effort: effectiveThinkingLevel },
         };
     }
+    if (providerId === "minimax" || providerId === "minimax-openai") {
+        const extraBody = { reasoning_split: true };
+        if (MINIMAX_M3_FAMILY.has(modelId)) {
+            extraBody.thinking = {
+                type: effectiveThinkingLevel === "off" ? "disabled" : "adaptive",
+            };
+        }
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "minimax",
+            extraBody,
+        };
+    }
     // Zhipu/Z.AI OpenAI-compatible endpoints expose reasoning via a provider-specific
     // `thinking` block rather than OpenAI's `reasoning_effort` shape.
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {

package/dist/provider.d.ts

@@ -4,12 +4,14 @@
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
 import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
+import type { ProviderProtocol } from "./model-catalog.js";
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
-type ReasoningContentEcho = "tool_calls" | "all" | "none";
+type ReasoningContentEcho = "tool_calls" | "all" | "none" | "minimax";
 export type ToolArgsMergeMode = "delta" | "snapshot";
 export interface TranslateOpenAIStreamOptions {
     toolArgsMergeMode?: ToolArgsMergeMode;
     reasoningMergeMode?: ToolArgsMergeMode;
+    textMergeMode?: ToolArgsMergeMode;
     debugProviderId?: string;
     debugModelId?: string;
 }
@@ -24,6 +26,7 @@ export interface ProviderInstanceOptions {
     thinkingLevel?: ThinkingLevel;
     /** Stable per-session seed for provider prompt caches. */
     promptCacheKey?: string;
+    protocol?: ProviderProtocol;
     /** Dynamic OAuth access-token loader/refresh hook for ChatGPT Codex requests. */
     openAICodexAuth?: OpenAICodexAuthAdapter;
 }