@bubblebrain-ai/bubble 0.0.24 → 0.0.26

package/dist/provider-anthropic.js

@@ -17,6 +17,25 @@ const MINIMAX_PROMPT_CACHE_MODELS = new Set([
     "minimax-m2",
     "m2-her",
 ]);
+function anthropicEffortForLevel(level) {
+    switch (level) {
+        case "off":
+            return undefined;
+        case "minimal":
+        case "low":
+            return "low";
+        case "medium":
+            return "medium";
+        case "high":
+            return "high";
+        case "xhigh":
+            return "xhigh";
+        case "max":
+            return "max";
+        default:
+            return undefined;
+    }
+}
 export function createAnthropicMessagesProvider(options) {
     async function* streamChat(messages, chatOptions) {
         const body = buildAnthropicRequest(options, messages, {
@@ -87,6 +106,18 @@ export function buildAnthropicRequest(options, messages, chatOptions) {
     }
     if (effectiveThinkingLevel !== "off") {
         body.thinking = { type: "adaptive" };
+        // Apply the selected reasoning depth via output_config.effort. Without this
+        // every thinking request silently ran at Anthropic's default (high),
+        // ignoring the chosen level. effort is an official-API feature, so only
+        // send it to the official endpoint — anthropic-compatible third parties
+        // (e.g. MiniMax) reject it. Levels are already clamped to the model's
+        // supported set, so the value is always a valid effort for this model.
+        if (isOfficialAnthropicBaseUrl(options.baseURL)) {
+            const effort = anthropicEffortForLevel(effectiveThinkingLevel);
+            if (effort) {
+                body.output_config = { effort };
+            }
+        }
     }
     return body;
 }

package/dist/provider-ark-responses.d.ts

@@ -0,0 +1,17 @@
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, TokenUsage, ToolChoiceMode, ToolDefinition } from "./types.js";
+export interface ArkResponsesProviderOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL: string;
+    thinkingLevel?: ThinkingLevel;
+}
+export declare function createArkResponsesProvider(options: ArkResponsesProviderOptions): Provider;
+export declare function buildArkResponsesBody(messages: ProviderMessage[], options: {
+    model: string;
+    tools?: ToolDefinition[];
+    toolChoice?: ToolChoiceMode;
+    thinkingLevel?: ThinkingLevel;
+    stream: boolean;
+}): Record<string, unknown>;
+export declare function translateArkResponsesStream(response: Response): AsyncIterable<StreamChunk>;
+export declare function normalizeArkResponsesUsage(usage: any): TokenUsage;

package/dist/provider-ark-responses.js

@@ -0,0 +1,462 @@
+import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
+import { RateLimitError } from "./network/errors.js";
+import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, retryAfterMsFromResponse, sleepBeforeRetry, } from "./network/retry.js";
+const DEFAULT_ARK_MODEL = "doubao-seed-2-1-pro-260628";
+export function createArkResponsesProvider(options) {
+    async function* streamChat(messages, chatOptions) {
+        const body = buildArkResponsesBody(messages, {
+            model: chatOptions.model,
+            tools: chatOptions.tools,
+            toolChoice: chatOptions.toolChoice,
+            thinkingLevel: chatOptions.thinkingLevel ?? options.thinkingLevel ?? "high",
+            stream: true,
+        });
+        for (let attempt = 0;; attempt += 1) {
+            const response = await sendArkResponsesRequest(options, body, {
+                signal: chatOptions.abortSignal,
+                rateLimitPolicy: chatOptions.rateLimitPolicy,
+                attempt,
+            });
+            yield* translateArkResponsesStream(response);
+            yield { type: "done" };
+            return;
+        }
+    }
+    async function complete(messages, chatOptions) {
+        const body = buildArkResponsesBody(messages, {
+            model: chatOptions?.model ?? DEFAULT_ARK_MODEL,
+            thinkingLevel: chatOptions?.thinkingLevel ?? options.thinkingLevel ?? "high",
+            stream: false,
+        });
+        const response = await sendArkResponsesRequest(options, body, {
+            signal: chatOptions?.abortSignal,
+            attempt: 0,
+        });
+        const payload = await response.json().catch(() => undefined);
+        return extractArkResponsesText(payload);
+    }
+    return { streamChat, complete };
+}
+export function buildArkResponsesBody(messages, options) {
+    const body = {
+        model: options.model,
+        input: messages.flatMap((message) => convertMessageToArkResponsesInput(message)),
+        store: false,
+        stream: options.stream,
+        thinking: {
+            type: shouldDisableArkThinking(options.thinkingLevel) ? "disabled" : "enabled",
+        },
+    };
+    if (options.tools && options.tools.length > 0) {
+        body.tools = options.tools.map((tool) => ({
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+        if (options.toolChoice === "none") {
+            body.tool_choice = "none";
+        }
+    }
+    return body;
+}
+function shouldDisableArkThinking(level) {
+    return level === "off" || level === "minimal";
+}
+function convertMessageToArkResponsesInput(message) {
+    if (message.role === "user") {
+        if (typeof message.content === "string") {
+            return [{
+                    type: "message",
+                    role: "user",
+                    content: message.content,
+                }];
+        }
+        return [{
+                type: "message",
+                role: "user",
+                content: message.content.map((part) => {
+                    if (part.type === "text") {
+                        return { type: "input_text", text: part.text };
+                    }
+                    return { type: "input_image", image_url: part.image_url.url };
+                }),
+            }];
+    }
+    if (message.role === "system") {
+        return [{
+                type: "message",
+                role: "system",
+                content: message.content,
+            }];
+    }
+    if (message.role === "assistant") {
+        const items = [];
+        if (message.content) {
+            items.push({
+                type: "message",
+                role: "assistant",
+                status: "completed",
+                content: [{ type: "output_text", text: message.content, annotations: [] }],
+            });
+        }
+        for (const toolCall of message.toolCalls ?? []) {
+            items.push({
+                type: "function_call",
+                call_id: toolCall.id,
+                name: toolCall.name,
+                arguments: toolCall.arguments || "{}",
+                status: "completed",
+            });
+        }
+        return items;
+    }
+    return [{
+            type: "function_call_output",
+            call_id: message.toolCallId,
+            output: message.content,
+        }];
+}
+async function sendArkResponsesRequest(options, body, requestOptions) {
+    const response = await fetch(resolveArkResponsesUrl(options.baseURL), {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${options.apiKey}`,
+            "Content-Type": "application/json",
+            "Accept": body.stream ? "text/event-stream" : "application/json",
+        },
+        body: JSON.stringify(body),
+        signal: requestOptions.signal,
+    });
+    if (response.ok)
+        return response;
+    const errorText = await response.text().catch(() => "");
+    if (response.status === 429) {
+        const retryAfterMs = retryAfterMsFromResponse(response);
+        if (requestOptions.rateLimitPolicy !== "defer"
+            && requestOptions.attempt < getProviderMaxRetries()) {
+            await sleepBeforeRetry(computeRetryDelayMs(requestOptions.attempt + 1, { retryAfterMs }), requestOptions.signal);
+            return sendArkResponsesRequest(options, body, {
+                ...requestOptions,
+                attempt: requestOptions.attempt + 1,
+            });
+        }
+        throw new RateLimitError(errorText || "Rate limited (429)", {
+            status: 429,
+            retryAfterMs,
+        });
+    }
+    if (isRetryableHttpStatus(response.status) && requestOptions.attempt < getProviderMaxRetries()) {
+        await sleepBeforeRetry(computeRetryDelayMs(requestOptions.attempt + 1), requestOptions.signal);
+        return sendArkResponsesRequest(options, body, {
+            ...requestOptions,
+            attempt: requestOptions.attempt + 1,
+        });
+    }
+    throw new Error(`${response.status} status code${errorText ? `: ${errorText}` : " (no body)"}`);
+}
+function resolveArkResponsesUrl(baseURL) {
+    return `${baseURL.trim().replace(/\/+$/, "")}/responses`;
+}
+export async function* translateArkResponsesStream(response) {
+    const toolCalls = new Map();
+    const textFilter = createProviderProtocolArtifactFilter();
+    for await (const event of parseArkResponsesSse(response)) {
+        const type = typeof event.type === "string" ? event.type : undefined;
+        if (!type)
+            continue;
+        if (type === "error") {
+            const message = typeof event.message === "string" ? event.message : JSON.stringify(event);
+            throw new Error(message);
+        }
+        if (type === "response.failed") {
+            const message = typeof event.response?.error?.message === "string"
+                ? event.response.error.message
+                : "Ark Responses request failed";
+            throw new Error(message);
+        }
+        if (type === "response.output_item.added") {
+            const item = event.item;
+            if (item?.type === "function_call" && typeof item.call_id === "string" && typeof item.name === "string") {
+                const key = toolCallEventKey(event, item);
+                const entry = {
+                    id: item.call_id,
+                    name: item.name,
+                    args: typeof item.arguments === "string" ? item.arguments : "",
+                    started: true,
+                };
+                toolCalls.set(key, entry);
+                yield {
+                    type: "tool_call",
+                    id: entry.id,
+                    name: entry.name,
+                    arguments: "",
+                    isStart: true,
+                    isEnd: false,
+                };
+            }
+            continue;
+        }
+        if (type === "response.output_text.delta" || type === "response.refusal.delta") {
+            const delta = typeof event.delta === "string" ? event.delta : "";
+            if (delta) {
+                const cleaned = textFilter.push(delta);
+                if (cleaned)
+                    yield { type: "text", content: cleaned };
+            }
+            continue;
+        }
+        if (type === "response.reasoning_summary_text.delta") {
+            const delta = typeof event.delta === "string" ? event.delta : "";
+            if (delta) {
+                yield { type: "reasoning_delta", content: delta };
+            }
+            continue;
+        }
+        if (type === "response.function_call_arguments.delta") {
+            const entry = toolCalls.get(toolCallEventKey(event));
+            const delta = typeof event.delta === "string" ? event.delta : "";
+            if (entry && delta) {
+                entry.args += delta;
+                yield {
+                    type: "tool_call",
+                    id: entry.id,
+                    name: entry.name,
+                    arguments: delta,
+                    isStart: false,
+                    isEnd: false,
+                };
+            }
+            continue;
+        }
+        if (type === "response.function_call_arguments.done") {
+            const entry = toolCalls.get(toolCallEventKey(event));
+            if (entry) {
+                const finalArgs = typeof event.arguments === "string" ? event.arguments : entry.args;
+                if (finalArgs.startsWith(entry.args)) {
+                    const tail = finalArgs.slice(entry.args.length);
+                    if (tail) {
+                        yield {
+                            type: "tool_call",
+                            id: entry.id,
+                            name: entry.name,
+                            arguments: tail,
+                            isStart: false,
+                            isEnd: false,
+                        };
+                    }
+                }
+                entry.args = finalArgs;
+            }
+            continue;
+        }
+        if (type === "response.output_item.done") {
+            const item = event.item;
+            if (item?.type === "function_call") {
+                const key = toolCallEventKey(event, item);
+                const entry = toolCalls.get(key);
+                if (entry) {
+                    const finalArgs = typeof item.arguments === "string" ? item.arguments : entry.args;
+                    const normalized = normalizeToolArgsDetailed(finalArgs);
+                    yield {
+                        type: "tool_call",
+                        id: entry.id,
+                        name: entry.name,
+                        arguments: "",
+                        argumentsFull: normalized.args,
+                        argumentsCorrupt: normalized.corrupt || undefined,
+                        isStart: false,
+                        isEnd: true,
+                    };
+                    toolCalls.delete(key);
+                }
+            }
+            continue;
+        }
+        if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+            const remainingText = textFilter.flush();
+            if (remainingText) {
+                yield { type: "text", content: remainingText };
+            }
+            for (const [key, entry] of toolCalls) {
+                const normalized = normalizeToolArgsDetailed(entry.args);
+                yield {
+                    type: "tool_call",
+                    id: entry.id,
+                    name: entry.name,
+                    arguments: "",
+                    argumentsFull: normalized.args,
+                    argumentsCorrupt: normalized.corrupt || type === "response.incomplete" || undefined,
+                    isStart: false,
+                    isEnd: true,
+                };
+                toolCalls.delete(key);
+            }
+            const usage = event.response?.usage;
+            if (usage) {
+                yield {
+                    type: "usage",
+                    usage: normalizeArkResponsesUsage(usage),
+                };
+            }
+            continue;
+        }
+    }
+    const remainingText = textFilter.flush();
+    if (remainingText) {
+        yield { type: "text", content: remainingText };
+    }
+    for (const [, entry] of toolCalls) {
+        const normalized = normalizeToolArgsDetailed(entry.args);
+        yield {
+            type: "tool_call",
+            id: entry.id,
+            name: entry.name,
+            arguments: "",
+            argumentsFull: normalized.args,
+            argumentsCorrupt: normalized.corrupt || undefined,
+            isStart: false,
+            isEnd: true,
+        };
+    }
+}
+function toolCallEventKey(event, item) {
+    if (typeof event.output_index === "number")
+        return `output:${event.output_index}`;
+    const itemId = typeof event.item_id === "string"
+        ? event.item_id
+        : typeof item?.id === "string"
+            ? item.id
+            : undefined;
+    if (itemId)
+        return itemId;
+    return "output:0";
+}
+async function* parseArkResponsesSse(response) {
+    if (!response.body)
+        return;
+    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 boundary = buffer.indexOf("\n\n");
+            while (boundary >= 0) {
+                const chunk = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = chunk
+                    .split("\n")
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice(5).trim())
+                    .join("\n")
+                    .trim();
+                if (data && data !== "[DONE]") {
+                    try {
+                        yield JSON.parse(data);
+                    }
+                    catch {
+                        // Ignore malformed event frames; the provider will surface failure
+                        // through response.failed when the request itself failed.
+                    }
+                }
+                boundary = buffer.indexOf("\n\n");
+            }
+        }
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Ignore cleanup errors.
+        }
+    }
+}
+export function normalizeArkResponsesUsage(usage) {
+    const promptTokens = typeof usage?.input_tokens === "number" ? usage.input_tokens : 0;
+    const cachedTokens = typeof usage?.input_tokens_details?.cached_tokens === "number"
+        ? usage.input_tokens_details.cached_tokens
+        : undefined;
+    return {
+        promptTokens,
+        completionTokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : 0,
+        promptCacheHitTokens: cachedTokens,
+        promptCacheMissTokens: cachedTokens !== undefined ? Math.max(0, promptTokens - cachedTokens) : undefined,
+        reasoningTokens: typeof usage?.output_tokens_details?.reasoning_tokens === "number"
+            ? usage.output_tokens_details.reasoning_tokens
+            : undefined,
+        totalTokens: typeof usage?.total_tokens === "number" ? usage.total_tokens : undefined,
+    };
+}
+function extractArkResponsesText(payload) {
+    const output = Array.isArray(payload?.output) ? payload.output : [];
+    const text = [];
+    for (const item of output) {
+        if (item?.type !== "message" || !Array.isArray(item.content))
+            continue;
+        for (const part of item.content) {
+            if ((part?.type === "output_text" || part?.type === "text") && typeof part.text === "string") {
+                text.push(part.text);
+            }
+        }
+    }
+    return text.join("");
+}
+function normalizeToolArgsDetailed(raw) {
+    const s = (raw ?? "").trim();
+    if (!s)
+        return { args: "{}", corrupt: false };
+    try {
+        JSON.parse(s);
+        return { args: s, corrupt: false };
+    }
+    catch {
+        const balanced = extractBalancedJson(s, 0);
+        if (!balanced)
+            return { args: "{}", corrupt: true };
+        try {
+            JSON.parse(balanced);
+            return { args: balanced, corrupt: false };
+        }
+        catch {
+            return { args: "{}", corrupt: true };
+        }
+    }
+}
+function extractBalancedJson(s, start) {
+    if (s[start] !== "{")
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let escape = false;
+    for (let i = start; i < s.length; i += 1) {
+        const c = s[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (c === "\\" && inStr) {
+            escape = true;
+            continue;
+        }
+        if (c === "\"") {
+            inStr = !inStr;
+            continue;
+        }
+        if (inStr)
+            continue;
+        if (c === "{") {
+            depth += 1;
+        }
+        else if (c === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return s.slice(start, i + 1);
+        }
+    }
+    return null;
+}

package/dist/provider-transform.js

@@ -47,6 +47,13 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 : { reasoning_effort: effectiveThinkingLevel },
         };
     }
+    if (providerId === "doubao") {
+        return {
+            effectiveThinkingLevel,
+            parallelToolCalls: false,
+            extraBody: { reasoning_effort: effectiveThinkingLevel },
+        };
+    }
     if (providerId === "minimax" || providerId === "minimax-openai") {
         const extraBody = { reasoning_split: true };
         if (MINIMAX_M3_FAMILY.has(modelId)) {

package/dist/provider.d.ts

@@ -38,6 +38,13 @@ export interface NormalizedToolArgs {
 }
 export declare function normalizeToolArgsDetailed(raw: string): NormalizedToolArgs;
 export declare function normalizeToolArgs(raw: string): string;
+/**
+ * Convert a non-streaming OpenAI-compatible chat-completions response into the
+ * same chunk protocol used by the streaming adapter. This is used for provider
+ * tool-call paths where streamed function arguments are not reliable enough to
+ * execute safely.
+ */
+export declare function translateOpenAIFullResponse(response: any): AsyncIterable<StreamChunk>;
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *