@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/provider-transform.d.ts

@@ -0,0 +1,12 @@
+import type { ThinkingLevel } from "./types.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export interface ProviderRequestConfig {
+    effectiveThinkingLevel: ThinkingLevel;
+    reasoningEffort?: ThinkingLevel;
+    reasoningContentEcho?: "tool_calls" | "all" | "none" | "minimax";
+    parallelToolCalls?: boolean;
+    maxTokens?: number;
+    extraBody?: Record<string, unknown>;
+    omitTemperature?: boolean;
+}
+export declare function resolveProviderRequestConfig(providerId: string, modelId: string, requestedLevel: ThinkingLevel): ProviderRequestConfig;

package/dist/provider-transform.js

@@ -0,0 +1,293 @@
+import { getBuiltinModel } from "./model-catalog.js";
+import { getAvailableThinkingLevels, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
+const KIMI_K27_FAMILY = new Set([
+    "kimi-k2.7-code",
+    "kimi-k2.7-code-highspeed",
+    // Coding-plan slot ids for the same generation (GET /coding/v1/models).
+    "kimi-for-coding",
+    "kimi-for-coding-highspeed",
+]);
+// K3 takes OpenAI-style reasoning_effort (low/high/max, no "medium"); "off"
+// disables thinking via top-level thinking.type. Verified live: effort changes
+// reasoning-token spend, and nested extra_body.thinking is ignored server-side.
+// K3.1 Pro takes the same body but is thinking-only (thinking.type "disabled"
+// 400s); its catalog levels have no "off", so the disabled branch never fires.
+const KIMI_K3_FAMILY = new Set([
+    "k3",
+    "k3-256k",
+    "kimi-k3",
+    "k3.1-pro",
+    "k3.1-pro-highspeed",
+    "kimi-k3.1-pro",
+    "kimi-k3.1-pro-highspeed",
+]);
+const KIMI_TOGGLE_THINKING_FAMILY = new Set(["kimi-k2.5", "kimi-k2.6"]);
+const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
+const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
+const DEEPSEEK_V4_FAMILY = new Set([
+    "deepseek-flash",
+    "deepseek-v4-flash",
+    "deepseek-v4-flash-vision-exp",
+    "deepseek-v4-pro",
+]);
+// DashScope serves Kimi first-party ("kimi-k3") and as a Moonshot passthrough
+// under a vendor prefix ("kimi/kimi-k3.1-pro"). The two take different thinking
+// controls; the passthrough contract comes from DashScope's Kimi doc
+// (help.aliyun.com/zh/model-studio/kimi-api-by-moonshot-ai): its K3 ids accept
+// reasoning_effort "max" only, K2.6 toggles via enable_thinking, and the K2.7
+// Code ids take no thinking parameter at all.
+const ALIBABA_KIMI_PASSTHROUGH_EFFORT = new Set([
+    "kimi/kimi-k3",
+    "kimi/kimi-k3.1-pro",
+    "kimi/kimi-k3.1-pro-highspeed",
+]);
+const ALIBABA_KIMI_PASSTHROUGH_TOGGLE = new Set(["kimi/kimi-k2.6"]);
+function isAlibabaKimi(providerId, modelId) {
+    return providerId === "alibaba" && /^(kimi\/)?kimi-/i.test(modelId);
+}
+function isFireworksKimi(providerId, modelId) {
+    const model = modelId.toLowerCase();
+    return providerId === "fireworks" && (model.includes("kimi")
+        || model.includes("k2p6")
+        || model === "k2.6");
+}
+export function resolveProviderRequestConfig(providerId, modelId, requestedLevel) {
+    const supportedLevels = getAvailableThinkingLevels(providerId, modelId);
+    const effectiveThinkingLevel = normalizeThinkingLevel(requestedLevel, supportedLevels);
+    if (providerId === "opencode-zen" && modelId === "space-bunny-free") {
+        const level = normalizeInheritedThinkingLevel(providerId, modelId, requestedLevel);
+        return {
+            effectiveThinkingLevel: level,
+            reasoningContentEcho: "tool_calls",
+            extraBody: { reasoning_effort: level },
+        };
+    }
+    if (providerId === "openai-codex") {
+        const model = getBuiltinModel(providerId, modelId);
+        if (!model || model.reasoningLevels.length === 0) {
+            return { effectiveThinkingLevel: "off" };
+        }
+        // Provider serialization is the final defensive boundary. Upstream model
+        // selection validates explicit choices, while inherited stale state falls
+        // back to the model's declared default here rather than leaking an invalid
+        // effort to the ChatGPT Responses endpoint.
+        const codexThinkingLevel = normalizeInheritedThinkingLevel(providerId, modelId, requestedLevel);
+        return {
+            effectiveThinkingLevel: codexThinkingLevel,
+            reasoningEffort: codexThinkingLevel !== "off" && model.reasoningLevels.includes(codexThinkingLevel)
+                ? codexThinkingLevel
+                : undefined,
+        };
+    }
+    // Grok's CLI chat proxy is OpenAI-compatible; effort rides in the body as
+    // `reasoning_effort`, and reasoning arrives back as `reasoning_content`.
+    if (providerId === "grok") {
+        return {
+            effectiveThinkingLevel,
+            extraBody: effectiveThinkingLevel === "off"
+                ? undefined
+                : { reasoning_effort: effectiveThinkingLevel },
+        };
+    }
+    // Ox Alpha exposes mandatory low/high/max reasoning. Treat unsupported state
+    // restored from an older session as inherited state and fall back to the
+    // model's declared default (max), never OpenRouter's disabling "none" value.
+    if (providerId === "openrouter") {
+        const openRouterThinkingLevel = normalizeInheritedThinkingLevel(providerId, modelId, requestedLevel);
+        return {
+            effectiveThinkingLevel: openRouterThinkingLevel,
+            reasoningContentEcho: "tool_calls",
+            extraBody: {
+                reasoning: {
+                    effort: openRouterThinkingLevel,
+                },
+            },
+        };
+    }
+    if (isFireworksKimi(providerId, modelId)) {
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "none",
+            parallelToolCalls: false,
+            maxTokens: KIMI_K26_DEFAULT_MAX_TOKENS,
+        };
+    }
+    if (providerId === "deepseek" && DEEPSEEK_V4_FAMILY.has(modelId)) {
+        if (effectiveThinkingLevel === "off") {
+            return {
+                effectiveThinkingLevel,
+                // Non-thinking requests do not need prior reasoning replayed. Omitting
+                // reasoning_content also keeps the history valid when switching modes.
+                reasoningContentEcho: "none",
+                extraBody: { thinking: { type: "disabled" } },
+            };
+        }
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "all",
+            extraBody: {
+                thinking: { type: "enabled" },
+                reasoning_effort: effectiveThinkingLevel,
+            },
+        };
+    }
+    // Bailian token plan speaks OpenAI-compatible reasoning_effort, with "none"
+    // as its off value (verified: enable_thinking=false works too, but "none"
+    // keeps one parameter for every level). Grades are validated server-side —
+    // an unknown value is a 400 — so the catalog's per-model ladder matters.
+    if (providerId === "bailian-token-plan") {
+        return {
+            effectiveThinkingLevel,
+            extraBody: {
+                reasoning_effort: effectiveThinkingLevel === "off" ? "none" : effectiveThinkingLevel,
+            },
+        };
+    }
+    // DashScope-hosted Kimi: the server rejects any temperature but the locked
+    // one ("Parameter 'temperature'=0.2 is not supported for kimi-k3 model").
+    // First-party ids take reasoning_effort validated against DashScope's own
+    // list, where "none" disables thinking (verified on kimi-k3/k2.5/k2.6; K2.7
+    // Code stays in thinking mode whatever is sent). Passthrough ids follow the
+    // documented contract above. Models missing from the catalog get no
+    // thinking field, so a thinking-only newcomer is never switched off.
+    if (isAlibabaKimi(providerId, modelId)) {
+        let extraBody;
+        if (ALIBABA_KIMI_PASSTHROUGH_EFFORT.has(modelId)) {
+            extraBody = { reasoning_effort: effectiveThinkingLevel };
+        }
+        else if (ALIBABA_KIMI_PASSTHROUGH_TOGGLE.has(modelId)) {
+            extraBody = { enable_thinking: effectiveThinkingLevel !== "off" };
+        }
+        else if (!modelId.toLowerCase().startsWith("kimi/") && getBuiltinModel(providerId, modelId)) {
+            extraBody = { reasoning_effort: effectiveThinkingLevel === "off" ? "none" : effectiveThinkingLevel };
+        }
+        return {
+            effectiveThinkingLevel,
+            omitTemperature: true,
+            reasoningContentEcho: "tool_calls",
+            extraBody,
+        };
+    }
+    if (providerId === "stepfun-api") {
+        return { effectiveThinkingLevel, reasoningContentEcho: "none" };
+    }
+    if (providerId === "stepfun") {
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "none",
+            extraBody: effectiveThinkingLevel === "off"
+                ? undefined
+                : { 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)) {
+            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)) {
+        // GLM-5.2+ also accept `reasoning_effort`. GLM-5.2 can disable thinking;
+        // the GLM-5.3 family requires thinking and normalizes its effort into
+        // low/high/max. The catalog clamps 5.3 choices before this serialization
+        // boundary. The effort field rides inside the body alongside `thinking`,
+        // so it goes in extraBody, not the OpenRouter-style config field.
+        if (modelId === "glm-5.2" || modelId === "glm-5.3" || modelId === "glm-5.3-flash") {
+            return {
+                effectiveThinkingLevel,
+                extraBody: modelId === "glm-5.2" && effectiveThinkingLevel === "off"
+                    ? { thinking: { type: "disabled" } }
+                    : {
+                        thinking: { type: "enabled", clear_thinking: false },
+                        reasoning_effort: effectiveThinkingLevel,
+                    },
+            };
+        }
+        return {
+            effectiveThinkingLevel,
+            extraBody: effectiveThinkingLevel === "off"
+                ? undefined
+                : {
+                    thinking: {
+                        type: "enabled",
+                        clear_thinking: false,
+                    },
+                },
+        };
+    }
+    // Moonshot / Kimi: K2.5/K2.6 lock temperature/top_p/n/penalties and expose
+    // thinking via extra_body.thinking.
+    if (MOONSHOT_PROVIDER_IDS.has(providerId)) {
+        // Kimi K2.7 Code variants are thinking-only: temperature is locked to 1.0
+        // server-side (any explicit value errors), thinking can never be disabled, and
+        // reasoning_content must be echoed back on tool-call turns.
+        if (KIMI_K27_FAMILY.has(modelId)) {
+            return {
+                effectiveThinkingLevel,
+                omitTemperature: true,
+                reasoningContentEcho: "tool_calls",
+                extraBody: {
+                    thinking: { type: "enabled" },
+                },
+            };
+        }
+        if (KIMI_K3_FAMILY.has(modelId)) {
+            return {
+                effectiveThinkingLevel,
+                omitTemperature: true,
+                reasoningContentEcho: "tool_calls",
+                // extraBody spreads onto the request body verbatim. The sibling
+                // `reasoningEffort` field is NOT the same thing: the generic chat path
+                // turns it into OpenRouter's `reasoning: {enabled: true}`, which drops
+                // the grade entirely.
+                extraBody: effectiveThinkingLevel === "off"
+                    ? { thinking: { type: "disabled" } }
+                    : { reasoning_effort: effectiveThinkingLevel },
+            };
+        }
+        if (KIMI_TOGGLE_THINKING_FAMILY.has(modelId)) {
+            return {
+                effectiveThinkingLevel,
+                omitTemperature: true,
+                reasoningContentEcho: "tool_calls",
+                extraBody: {
+                    thinking: { type: effectiveThinkingLevel === "off" ? "disabled" : "enabled" },
+                },
+            };
+        }
+        // Unlisted Moonshot models: every generation since K2.5 locks temperature
+        // and 400s on any other value, so let the server pick its own default.
+        // Pre-K2.5 ids (moonshot-v1, kimi-k2-*-preview) are deliberately not
+        // supported: the endpoints no longer list them, and they would merely lose
+        // the 0.2 default here rather than fail.
+        return { effectiveThinkingLevel, omitTemperature: true };
+    }
+    if (providerId === "openai"
+        || providerId === "google"
+        || providerId === "azure"
+        || providerId === "openai-compatible") {
+        return {
+            effectiveThinkingLevel,
+            reasoningEffort: effectiveThinkingLevel === "off" ? undefined : effectiveThinkingLevel,
+        };
+    }
+    return { effectiveThinkingLevel };
+}

package/dist/provider-zen-errors.d.ts

@@ -0,0 +1,9 @@
+import { ProviderStreamInterruptedError } from "./network/retry.js";
+/** Only Zen's opaque upstream rejection is recoverable, not arbitrary 422s. */
+export declare function isSpaceBunnyUpstreamRejection(providerId: string | undefined, model: string, error: unknown): boolean;
+export declare function recoverableSpaceBunnyError(error: unknown): ProviderStreamInterruptedError;
+/** Counts only: never persist prompts, tool arguments, URLs or API headers. */
+export declare function chatRequestShape(body: {
+    messages?: Record<string, unknown>[];
+    tools?: unknown[];
+}): Record<string, number>;

package/dist/provider-zen-errors.js

@@ -0,0 +1,36 @@
+import { ProviderStreamInterruptedError } from "./network/retry.js";
+/** Only Zen's opaque upstream rejection is recoverable, not arbitrary 422s. */
+export function isSpaceBunnyUpstreamRejection(providerId, model, error) {
+    if (providerId !== "opencode-zen" || model !== "space-bunny-free")
+        return false;
+    const e = error;
+    return e?.status === 422 && typeof e.message === "string"
+        && /Upstream request failed:\s*\[invalid_request_error\]\s*unprocessable entity/i.test(e.message);
+}
+export function recoverableSpaceBunnyError(error) {
+    return new ProviderStreamInterruptedError("Space Bunny upstream rejected the request (422); retrying the model request.", {
+        cause: error, maxRetries: 2,
+    });
+}
+/** Counts only: never persist prompts, tool arguments, URLs or API headers. */
+export function chatRequestShape(body) {
+    const messages = body.messages ?? [];
+    const shape = { messages: messages.length, tools: body.tools?.length ?? 0, assistant: 0,
+        emptyAssistant: 0, reasoning: 0, toolCalls: 0, toolResults: 0, contentChars: 0 };
+    for (const m of messages) {
+        if (typeof m.content === "string")
+            shape.contentChars += m.content.length;
+        if (m.role === "assistant") {
+            shape.assistant++;
+            const calls = Array.isArray(m.tool_calls) ? m.tool_calls.length : 0;
+            shape.toolCalls += calls;
+            if (!m.content && !calls)
+                shape.emptyAssistant++;
+            if (m.reasoning_content)
+                shape.reasoning++;
+        }
+        if (m.role === "tool")
+            shape.toolResults++;
+    }
+    return shape;
+}

package/dist/provider.d.ts

@@ -0,0 +1,85 @@
+/**
+ * OpenAI-compatible Provider implementation.
+ *
+ * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
+ */
+import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
+import { type GrokAuthAdapter } from "./provider-grok.js";
+import type { ProviderProtocol } from "./model-catalog.js";
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
+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;
+}
+export declare function toChatCompletionsMessage(message: ProviderMessage, options?: {
+    reasoningContentEcho?: ReasoningContentEcho;
+}): Record<string, unknown>;
+export interface ProviderInstanceOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL: string;
+    /** Requested thinking level */
+    thinkingLevel?: ThinkingLevel;
+    /** Stable per-session seed for provider prompt caches. */
+    promptCacheKey?: string;
+    protocol?: ProviderProtocol;
+    /**
+     * User-configured extra request headers (provider entry `headers` in
+     * config.json/models.json). Merged over protocol defaults, so a coding-plan
+     * endpoint's client-identity gate (usually a User-Agent allowlist) can be
+     * satisfied from config.
+     */
+    headers?: Record<string, string>;
+    /** Dynamic OAuth access-token loader/refresh hook for ChatGPT Codex requests. */
+    openAICodexAuth?: OpenAICodexAuthAdapter;
+    /** Dynamic OAuth access-token loader/refresh hook for Grok subscription requests. */
+    grokAuth?: GrokAuthAdapter;
+}
+export declare function createUnavailableProvider(message: string): Provider;
+export declare function createProviderInstance(options: ProviderInstanceOptions): Provider;
+export interface NormalizedToolArgs {
+    args: string;
+    corrupt: boolean;
+}
+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.
+ *
+ * Multi-tool-call streams are tracked by `index`, but tool-call starts and
+ * argument deltas are emitted as soon as they arrive so the TUI can render
+ * partial write previews before the tool executes. End events are still flushed
+ * in index order to keep multi-call turns deterministic.
+ */
+export declare function translateOpenAIStream(stream: AsyncIterable<any>, options?: TranslateOpenAIStreamOptions): AsyncIterable<StreamChunk>;
+/**
+ * Largest value that survives the OpenAI SDK's internal `timeout + 1000`
+ * agent-grace (core.js minAgentTimeout) without overflowing Node's 32-bit
+ * timers; ~24.8 days.
+ */
+export declare const MAX_TIMER_MS = 2147482647;
+/**
+ * Resolve the provider request timeout (ms) from the operator override.
+ *
+ * Default is effectively NO TIMEOUT — safe for streaming APIs where the model
+ * sends chunks continuously. But Node's timers are 32-bit: a duration above
+ * 2**31-1 ms overflows, which makes Node print a TimeoutOverflowWarning to
+ * stderr (corrupting the Ink TUI) AND silently clamp the timeout to 1ms,
+ * aborting the request almost immediately. So we use the largest SAFE timer
+ * value as the "no timeout" sentinel — never Number.MAX_SAFE_INTEGER — and
+ * clamp any operator-supplied value into range too.
+ */
+export declare function resolveRequestTimeoutMs(raw: string | undefined): number;
+export {};