@bubblebrain-ai/bubble 0.0.55 → 0.0.57

package/dist/mcp/client.js

@@ -154,7 +154,21 @@ export class MCPClient {
             }
             return;
         }
-        // Server→client request or notification. v1 ignores these (no sampling, no roots).
+        // Ping is a core MCP request and requires no advertised capability. Long-lived
+        // servers (including Playwright) close healthy sessions when it is ignored.
+        if ("id" in msg && "method" in msg) {
+            const response = msg.method === "ping"
+                ? { jsonrpc: "2.0", id: msg.id, result: {} }
+                : { jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `Unsupported client method: ${msg.method}` } };
+            void this.transport.send(response).catch((error) => {
+                for (const pending of this.pending.values()) {
+                    clearTimeout(pending.timer);
+                    pending.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+                this.pending.clear();
+            });
+        }
+        // Notifications need no response; sampling and roots are not advertised.
     }
     async close() {
         this.closed = true;

package/dist/mcp/transports.d.ts

@@ -27,7 +27,7 @@ export declare class StdioTransport implements McpTransport {
     constructor(config: StdioServerConfig);
     start(): Promise<void>;
     private onStdout;
-    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
     onMessage(handler: IncomingHandler): void;
     onError(handler: (err: Error) => void): void;
     onClose(handler: () => void): void;
@@ -44,7 +44,7 @@ export declare class HttpTransport implements McpTransport {
     private readonly baseHeaders;
     constructor(config: HttpServerConfig | SseServerConfig);
     start(): Promise<void>;
-    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
     private parseSseBody;
     onMessage(handler: IncomingHandler): void;
     onError(handler: (err: Error) => void): void;

package/dist/mcp/types.d.ts

@@ -100,7 +100,7 @@ export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcRespo
 /** Low-level transport interface. */
 export interface McpTransport {
     start(): Promise<void>;
-    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
     /** Called once per incoming JSON-RPC message (response or server→client request/notification). */
     onMessage(handler: (msg: JsonRpcResponse | JsonRpcNotification | JsonRpcRequest) => void): void;
     onError(handler: (err: Error) => void): void;

package/dist/memory/phase1.js

@@ -160,6 +160,10 @@ function serializeSessionEntry(entry) {
             return `[tool_call:${entry.toolCall.name}] ${truncate(entry.toolCall.arguments, 1_500)}`;
         case "tool_result":
             return `[tool_result${entry.message.isError ? " error=true" : ""}] ${truncate(entry.message.content, 2_000)}`;
+        case "provider_error":
+            // Operational diagnostics stay out of the memory-extraction prompt. The
+            // structured session record remains available for local debugging.
+            return "";
     }
 }
 function countMeaningfulEntries(entries) {

package/dist/model-catalog.d.ts

@@ -1,5 +1,5 @@
 import type { ReasoningEffort } from "./types.js";
-export type ProviderProtocol = "openai-chat" | "anthropic-messages" | "ark-responses" | "ai-sdk";
+export type ProviderProtocol = "openai-chat" | "openai-responses" | "anthropic-messages" | "ark-responses" | "ai-sdk";
 export interface BuiltinProviderDefinition {
     id: string;
     name: string;

package/dist/model-catalog.js

@@ -3,6 +3,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: "opencode-zen", name: "OpenCode Zen", baseURL: "https://opencode.ai/zen/v1", protocol: "openai-responses" },
     // Grok subscription models via the CLI chat proxy. OAuth-only: the proxy
     // accepts xAI session bearers (from /login grok), not api.x.ai API keys.
     { id: "grok", name: "Grok Subscription", baseURL: "https://cli-chat-proxy.grok.com/v1", supportsOAuth: true },
@@ -39,6 +40,7 @@ const GPT51_LEVELS = ["off", "low", "medium", "high"];
 const GPT51_CODEX_MAX_LEVELS = ["off", "low", "medium", "high", "xhigh"];
 const GPT51_CODEX_MINI_LEVELS = ["off", "medium", "high"];
 const OPENAI_CHAT_LEVELS = ["off"];
+const MUSE_SPARK_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
 // Ox Alpha declares mandatory reasoning with exactly low/high/max through
 // OpenRouter's live model metadata. The endpoint rejects disabled reasoning.
 const OPENROUTER_OX_REASONING_LEVELS = ["low", "high", "max"];
@@ -117,11 +119,16 @@ export const BUILTIN_MODELS = [
     { id: "o1-preview", name: "o1-preview", providerId: "openai", tier: "strong", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "o1-mini", name: "o1-mini", providerId: "openai", tier: "fast", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "gpt-4-turbo", name: "gpt-4-turbo", providerId: "openai", reasoningLevels: OPENAI_CHAT_LEVELS, contextWindow: 128000 },
+    { id: "muse-spark-1.3-contributor-free", name: "Muse Spark 1.3 Free", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "muse-spark-1.2", name: "Muse Spark 1.2", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "muse-spark-1.2-contributor-free", name: "Muse Spark 1.2 Free", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "claude-fable-5", name: "Claude Fable 5", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_FABLE_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-opus-4-8", name: "Claude Opus 4.8", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_OPUS_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", tier: "balanced", reasoningLevels: ANTHROPIC_SONNET_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", providerId: "anthropic", tier: "fast", reasoningLevels: ANTHROPIC_CHAT_LEVELS, contextWindow: 200000 },
     { id: "deepseek-v4-flash", name: "deepseek-v4-flash", providerId: "deepseek", tier: "fast", reasoningLevels: DEEPSEEK_V4_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    // DeepSeek Flash: retain the high effort used by the previous preview.
+    { id: "deepseek-flash", name: "deepseek-flash", providerId: "deepseek", reasoningLevels: ["high"], defaultReasoningLevel: "high" },
     // Experimental vision model stays explicit-only: it is text-capable, but
     // automatic fast-tier routing must not silently switch ordinary subagents
     // from the stable Flash model to an experimental multimodal endpoint.

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

@@ -1,5 +1,5 @@
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, TokenUsage, ToolChoiceMode, ToolDefinition } from "./types.js";
-export interface ArkResponsesProviderOptions {
+export interface ResponsesProviderOptions {
     providerId?: string;
     apiKey: string;
     baseURL: string;
@@ -7,7 +7,9 @@ export interface ArkResponsesProviderOptions {
     /** User-configured extra headers, merged last (client-identity gates). */
     headers?: Record<string, string>;
 }
+export type ArkResponsesProviderOptions = ResponsesProviderOptions;
 export declare function createArkResponsesProvider(options: ArkResponsesProviderOptions): Provider;
+export declare function createOpenAIResponsesProvider(options: ResponsesProviderOptions): Provider;
 export declare function buildArkResponsesBody(messages: ProviderMessage[], options: {
     model: string;
     tools?: ToolDefinition[];
@@ -15,5 +17,13 @@ export declare function buildArkResponsesBody(messages: ProviderMessage[], optio
     thinkingLevel?: ThinkingLevel;
     stream: boolean;
 }): Record<string, unknown>;
-export declare function translateArkResponsesStream(response: Response): AsyncIterable<StreamChunk>;
+export declare function buildOpenAIResponsesBody(messages: ProviderMessage[], options: {
+    model: string;
+    tools?: ToolDefinition[];
+    toolChoice?: ToolChoiceMode;
+    temperature?: number;
+    thinkingLevel?: ThinkingLevel;
+    stream: boolean;
+}): Record<string, unknown>;
+export declare function translateArkResponsesStream(response: Response, captureOpenAIReasoning?: boolean): AsyncIterable<StreamChunk>;
 export declare function normalizeArkResponsesUsage(usage: any): TokenUsage;

package/dist/provider-ark-responses.js

@@ -1,33 +1,43 @@
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { RateLimitError } from "./network/errors.js";
 import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, retryAfterMsFromResponse, sleepBeforeRetry, } from "./network/retry.js";
+import { providerFetch } from "./network/provider-transport.js";
 const DEFAULT_ARK_MODEL = "doubao-seed-2-1-pro-260628";
+const DEFAULT_MUSE_MODEL = "muse-spark-1.3-contributor-free";
 export function createArkResponsesProvider(options) {
+    return createResponsesProvider(options, "ark", DEFAULT_ARK_MODEL);
+}
+export function createOpenAIResponsesProvider(options) {
+    return createResponsesProvider(options, "openai", DEFAULT_MUSE_MODEL);
+}
+function createResponsesProvider(options, dialect, defaultModel) {
     async function* streamChat(messages, chatOptions) {
-        const body = buildArkResponsesBody(messages, {
+        const body = buildResponsesBody(messages, {
             model: chatOptions.model,
             tools: chatOptions.tools,
             toolChoice: chatOptions.toolChoice,
+            temperature: chatOptions.temperature,
             thinkingLevel: chatOptions.thinkingLevel ?? options.thinkingLevel ?? "high",
             stream: true,
-        });
+        }, dialect);
         for (let attempt = 0;; attempt += 1) {
             const response = await sendArkResponsesRequest(options, body, {
                 signal: chatOptions.abortSignal,
                 rateLimitPolicy: chatOptions.rateLimitPolicy,
                 attempt,
             });
-            yield* translateArkResponsesStream(response);
+            yield* translateArkResponsesStream(response, dialect === "openai");
             yield { type: "done" };
             return;
         }
     }
     async function complete(messages, chatOptions) {
-        const body = buildArkResponsesBody(messages, {
-            model: chatOptions?.model ?? DEFAULT_ARK_MODEL,
+        const body = buildResponsesBody(messages, {
+            model: chatOptions?.model ?? defaultModel,
+            temperature: chatOptions?.temperature,
             thinkingLevel: chatOptions?.thinkingLevel ?? options.thinkingLevel ?? "high",
             stream: false,
-        });
+        }, dialect);
         const response = await sendArkResponsesRequest(options, body, {
             signal: chatOptions?.abortSignal,
             attempt: 0,
@@ -38,15 +48,34 @@ export function createArkResponsesProvider(options) {
     return { streamChat, complete };
 }
 export function buildArkResponsesBody(messages, options) {
+    return buildResponsesBody(messages, options, "ark");
+}
+export function buildOpenAIResponsesBody(messages, options) {
+    return buildResponsesBody(messages, options, "openai");
+}
+function buildResponsesBody(messages, options, dialect) {
     const body = {
         model: options.model,
-        input: messages.flatMap((message) => convertMessageToArkResponsesInput(message)),
+        input: messages.flatMap((message) => convertMessageToResponsesInput(message, dialect)),
         store: false,
         stream: options.stream,
-        thinking: {
-            type: shouldDisableArkThinking(options.thinkingLevel) ? "disabled" : "enabled",
-        },
     };
+    if (dialect === "ark") {
+        body.thinking = {
+            type: shouldDisableArkThinking(options.thinkingLevel) ? "disabled" : "enabled",
+        };
+    }
+    else {
+        body.include = ["reasoning.encrypted_content"];
+        if (options.thinkingLevel && options.thinkingLevel !== "off") {
+            body.reasoning = {
+                effort: options.thinkingLevel === "ultra" ? "xhigh" : options.thinkingLevel,
+                summary: "auto",
+            };
+        }
+        if (options.temperature !== undefined)
+            body.temperature = options.temperature;
+    }
     if (options.tools && options.tools.length > 0) {
         body.tools = options.tools.map((tool) => ({
             type: "function",
@@ -63,7 +92,7 @@ export function buildArkResponsesBody(messages, options) {
 function shouldDisableArkThinking(level) {
     return level === "off" || level === "minimal";
 }
-function convertMessageToArkResponsesInput(message) {
+function convertMessageToResponsesInput(message, dialect) {
     if (message.role === "user") {
         if (typeof message.content === "string") {
             return [{
@@ -92,6 +121,17 @@ function convertMessageToArkResponsesInput(message) {
     }
     if (message.role === "assistant") {
         const items = [];
+        if (dialect === "openai") {
+            for (const block of message.providerMetadata?.openai?.contentBlocks ?? []) {
+                if (block.type !== "reasoning" || typeof block.encrypted_content !== "string")
+                    continue;
+                items.push({
+                    type: "reasoning",
+                    summary: Array.isArray(block.summary) ? block.summary : [],
+                    encrypted_content: block.encrypted_content,
+                });
+            }
+        }
         if (message.content) {
             items.push({
                 type: "message",
@@ -118,7 +158,7 @@ function convertMessageToArkResponsesInput(message) {
         }];
 }
 async function sendArkResponsesRequest(options, body, requestOptions) {
-    const response = await fetch(resolveArkResponsesUrl(options.baseURL), {
+    const response = await providerFetch(resolveArkResponsesUrl(options.baseURL), {
         method: "POST",
         headers: {
             "Authorization": `Bearer ${options.apiKey}`,
@@ -128,6 +168,8 @@ async function sendArkResponsesRequest(options, body, requestOptions) {
         },
         body: JSON.stringify(body),
         signal: requestOptions.signal,
+    }, {
+        providerName: options.providerId ?? "Responses provider",
     });
     if (response.ok)
         return response;
@@ -159,7 +201,7 @@ async function sendArkResponsesRequest(options, body, requestOptions) {
 function resolveArkResponsesUrl(baseURL) {
     return `${baseURL.trim().replace(/\/+$/, "")}/responses`;
 }
-export async function* translateArkResponsesStream(response) {
+export async function* translateArkResponsesStream(response, captureOpenAIReasoning = false) {
     const toolCalls = new Map();
     const textFilter = createProviderProtocolArtifactFilter();
     for await (const event of parseArkResponsesSse(response)) {
@@ -253,6 +295,19 @@ export async function* translateArkResponsesStream(response) {
         }
         if (type === "response.output_item.done") {
             const item = event.item;
+            if (captureOpenAIReasoning
+                && item?.type === "reasoning"
+                && typeof item.encrypted_content === "string") {
+                yield {
+                    type: "provider_content_block",
+                    provider: "openai",
+                    block: {
+                        type: "reasoning",
+                        summary: Array.isArray(item.summary) ? item.summary : [],
+                        encrypted_content: item.encrypted_content,
+                    },
+                };
+            }
             if (item?.type === "function_call") {
                 const key = toolCallEventKey(event, item);
                 const entry = toolCalls.get(key);

package/dist/provider-error-record.d.ts

@@ -0,0 +1,34 @@
+import type { ThinkingLevel } from "./types.js";
+export interface SanitizedProviderError {
+    providerId: string;
+    modelId: string;
+    model?: string;
+    thinkingLevel: ThinkingLevel;
+    name: string;
+    message: string;
+    httpStatus?: number;
+    code?: string;
+    parameter?: string;
+    messageCount: number;
+    toolCount: number;
+    bubbleVersion: string;
+    pid: number;
+    runtimeStartedAt: number;
+}
+export interface ProviderErrorContext {
+    providerId: string;
+    modelId: string;
+    model?: string;
+    thinkingLevel: ThinkingLevel;
+    messageCount: number;
+    toolCount: number;
+}
+/**
+ * Build the allowlisted diagnostic record written to a session log.
+ *
+ * Deliberately do not serialize the original error object: SDK errors can
+ * contain request headers, request bodies, response bodies and stacks. Only
+ * scalar identifiers plus a locally-authored error category are retained.
+ */
+export declare function createSanitizedProviderError(error: unknown, context: ProviderErrorContext): SanitizedProviderError;
+export declare function sanitizeProviderErrorText(value: string): string;

package/dist/provider-error-record.js

@@ -0,0 +1,185 @@
+import { getCurrentVersion } from "./update/index.js";
+const MAX_FIELD_CHARS = 160;
+const RUNTIME_STARTED_AT = Date.now();
+const SAFE_ERROR_CODES = new Map([
+    ["authentication_error", "authentication_error"],
+    ["bad_request", "bad_request"],
+    ["context_length_exceeded", "context_length_exceeded"],
+    ["failed_precondition", "failed_precondition"],
+    ["internal_error", "internal_error"],
+    ["invalid_argument", "invalid_argument"],
+    ["invalidparameter", "invalid_parameter"],
+    ["invalid_parameter", "invalid_parameter"],
+    ["location_not_supported", "location_not_supported"],
+    ["permission_denied", "permission_denied"],
+    ["rate_limit_exceeded", "rate_limit_exceeded"],
+    ["rate_limit_exhausted", "rate_limit_exhausted"],
+    ["resource_exhausted", "resource_exhausted"],
+    ["service_unavailable", "service_unavailable"],
+    ["timeout", "timeout"],
+    ["unauthenticated", "unauthenticated"],
+    ["unsupported_parameter", "unsupported_parameter"],
+    ["unsupported_value", "unsupported_value"],
+]);
+const SAFE_PARAMETER_NAMES = new Set([
+    "contents",
+    "frequency_penalty",
+    "generationConfig",
+    "input",
+    "max_output_tokens",
+    "max_tokens",
+    "messages",
+    "model",
+    "n",
+    "presence_penalty",
+    "prompt",
+    "reasoning_effort",
+    "response_format",
+    "seed",
+    "stop",
+    "stream",
+    "temperature",
+    "thinkingConfig",
+    "thinkingLevel",
+    "thinking_level",
+    "tool_choice",
+    "tools",
+    "topP",
+    "top_p",
+]);
+/**
+ * Build the allowlisted diagnostic record written to a session log.
+ *
+ * Deliberately do not serialize the original error object: SDK errors can
+ * contain request headers, request bodies, response bodies and stacks. Only
+ * scalar identifiers plus a locally-authored error category are retained.
+ */
+export function createSanitizedProviderError(error, context) {
+    const sources = errorSources(error);
+    const rawMessage = firstString(sources, ["message"])
+        || (typeof error === "string" ? error : "Provider request failed.");
+    const httpStatus = firstHttpStatus(sources);
+    const code = sanitizeErrorCode(firstScalarString(sources, ["code", "errorCode", "type"]));
+    const parameter = sanitizeParameterName(firstScalarString(sources, ["param", "parameter"]));
+    return {
+        providerId: sanitizeControlledIdentifier(context.providerId),
+        modelId: sanitizeControlledIdentifier(context.modelId),
+        ...(context.model ? { model: sanitizeControlledIdentifier(context.model) } : {}),
+        thinkingLevel: context.thinkingLevel,
+        name: "ProviderError",
+        message: sanitizeProviderErrorText(rawMessage),
+        ...(httpStatus !== undefined ? { httpStatus } : {}),
+        ...(code ? { code } : {}),
+        ...(parameter ? { parameter } : {}),
+        messageCount: Math.max(0, Math.trunc(context.messageCount)),
+        toolCount: Math.max(0, Math.trunc(context.toolCount)),
+        bubbleVersion: getCurrentVersion(),
+        pid: process.pid,
+        runtimeStartedAt: RUNTIME_STARTED_AT,
+    };
+}
+export function sanitizeProviderErrorText(value) {
+    const text = value.replace(/[\r\n\t]+/g, " ").replace(/\s{2,}/g, " ").trim();
+    // Fail closed: provider/SDK messages can embed request headers, bodies,
+    // prompts, URLs or credentials in formats a denylist cannot anticipate.
+    // Persist only fixed, locally-authored summaries selected by broad error
+    // categories; never return any substring copied from the provider message.
+    if (/user location (?:is )?not supported|location[^.]{0,40}(?:unsupported|not supported)/i.test(text)) {
+        return "User location is not supported for API use.";
+    }
+    if (/context[_ -]?(?:length|window)|prompt (?:is )?too long|maximum context|token limit/i.test(text)) {
+        return "Provider context limit was exceeded.";
+    }
+    if (/rate limit|too many requests|quota|resource exhausted|\b429\b/i.test(text)) {
+        return "Provider rate limit was exceeded.";
+    }
+    if (/unauthori[sz]ed|authentication|invalid (?:api )?key|missing (?:api )?key|\b401\b/i.test(text)) {
+        return "Provider authentication failed.";
+    }
+    if (/forbidden|permission denied|access denied|\b403\b/i.test(text)) {
+        return "Provider denied the request.";
+    }
+    if (/invalid[^.]{0,60}(?:parameter|argument)|unsupported[^.]{0,60}(?:parameter|argument)|bad request|\b400\b/i.test(text)) {
+        return "Provider rejected a request parameter.";
+    }
+    if (/timed? ?out|timeout/i.test(text)) {
+        return "Provider request timed out.";
+    }
+    if (/network|connection|socket|fetch failed|stream (?:closed|interrupted)/i.test(text)) {
+        return "Provider connection failed.";
+    }
+    if (/abort|cancel/i.test(text)) {
+        return "Provider request was cancelled.";
+    }
+    return "Provider request failed.";
+}
+function errorSources(error) {
+    const sources = [];
+    const root = asRecord(error);
+    if (root)
+        sources.push(root);
+    const nested = asRecord(root?.error);
+    if (nested)
+        sources.push(nested);
+    const cause = asRecord(root?.cause);
+    if (cause)
+        sources.push(cause);
+    const causeError = asRecord(cause?.error);
+    if (causeError)
+        sources.push(causeError);
+    return sources;
+}
+function asRecord(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function")
+        ? value
+        : undefined;
+}
+function firstString(sources, keys) {
+    for (const source of sources) {
+        for (const key of keys) {
+            const value = source[key];
+            if (typeof value === "string" && value.trim())
+                return value.trim();
+        }
+    }
+    return undefined;
+}
+function firstScalarString(sources, keys) {
+    for (const source of sources) {
+        for (const key of keys) {
+            const value = source[key];
+            if ((typeof value === "string" || typeof value === "number") && String(value).trim()) {
+                return String(value).trim();
+            }
+        }
+    }
+    return undefined;
+}
+function firstHttpStatus(sources) {
+    for (const source of sources) {
+        for (const key of ["status", "statusCode", "httpStatus"]) {
+            const value = source[key];
+            const numeric = typeof value === "number" ? value : Number(value);
+            if (Number.isInteger(numeric) && numeric >= 100 && numeric <= 599)
+                return numeric;
+        }
+    }
+    return undefined;
+}
+function sanitizeControlledIdentifier(value) {
+    const normalized = value.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/.test(normalized))
+        return "unknown";
+    return normalized.slice(0, MAX_FIELD_CHARS);
+}
+function sanitizeErrorCode(value) {
+    if (!value)
+        return undefined;
+    return SAFE_ERROR_CODES.get(value.trim().toLowerCase());
+}
+function sanitizeParameterName(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim();
+    return SAFE_PARAMETER_NAMES.has(normalized) ? normalized : undefined;
+}

package/dist/provider-transform.js

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

package/dist/provider.js

@@ -6,7 +6,7 @@
 import OpenAI from "openai";
 import { appendFileSync } from "node:fs";
 import { createAnthropicMessagesProvider } from "./provider-anthropic.js";
-import { createArkResponsesProvider } from "./provider-ark-responses.js";
+import { createArkResponsesProvider, createOpenAIResponsesProvider } from "./provider-ark-responses.js";
 import { createAiSdkProvider } from "./provider-ai-sdk.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { buildGrokSubscriptionHeaders, createGrokSubscriptionFetch, isGrokSubscriptionBaseUrl, } from "./provider-grok.js";
@@ -89,6 +89,9 @@ export function createProviderInstance(options) {
     if (protocol === "ark-responses") {
         return createArkResponsesProvider(options);
     }
+    if (protocol === "openai-responses") {
+        return createOpenAIResponsesProvider(options);
+    }
     if (protocol === "ai-sdk") {
         return createAiSdkProvider(options);
     }
@@ -273,6 +276,9 @@ function resolveProviderProtocol(options) {
         return options.protocol;
     const providerId = (options.providerId || "").toLowerCase();
     const baseURL = (options.baseURL || "").toLowerCase();
+    if (providerId === "opencode-zen") {
+        return "openai-responses";
+    }
     if (providerId === "doubao"
         && baseURL.replace(/\/+$/, "") === "https://ark.cn-beijing.volces.com/api/v3") {
         return "ark-responses";

package/dist/sdk/index.js

@@ -417,6 +417,11 @@ export class BubbleSdk {
                     if (message.role === "assistant")
                         recordMemoryCitations(cwd, message.content);
                 },
+                onProviderError: (error) => {
+                    if (this.turnCoordinator.isDeleted(sessionId))
+                        return;
+                    session.appendProviderError(error);
+                },
                 onCompactionApplied: (summary) => {
                     if (this.turnCoordinator.isDeleted(sessionId))
                         return;

package/dist/session-log.d.ts

@@ -1,5 +1,6 @@
 import type { Message } from "./types.js";
-import type { SessionLogEntry, SessionMarkerKind, SessionMetadata, SessionSummaryEntry } from "./session-types.js";
+import type { SessionLogEntry, SessionMarkerKind, SessionMetadata, SessionProviderErrorEntry, SessionSummaryEntry } from "./session-types.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
 export declare class SessionLog {
     private entries;
     load(lines: string[]): void;
@@ -10,5 +11,6 @@ export declare class SessionLog {
     appendMessage(message: Message): SessionLogEntry[];
     appendSummary(summary: string): SessionSummaryEntry;
     appendMarker(kind: SessionMarkerKind, value: string): SessionLogEntry;
+    appendProviderError(error: SanitizedProviderError): SessionProviderErrorEntry;
     toMessages(): Message[];
 }

package/dist/session-log.js

@@ -71,6 +71,16 @@ export class SessionLog {
         this.entries.push(entry);
         return entry;
     }
+    appendProviderError(error) {
+        const entry = {
+            id: nextEntryId(this.entries),
+            type: "provider_error",
+            error,
+            timestamp: Date.now(),
+        };
+        this.entries.push(entry);
+        return entry;
+    }
     toMessages() {
         const messages = [];
         let latestSummaryIndex = -1;
@@ -217,6 +227,7 @@ function isSessionLogEntry(entry) {
         "assistant_message",
         "tool_call",
         "tool_result",
+        "provider_error",
     ].includes(entry.type);
 }
 function nextEntryId(entries) {

package/dist/session-types.d.ts

@@ -1,5 +1,6 @@
 import type { AssistantMessage, Message, ThinkingLevel, ToolCall, ToolMessage, UserMessage } from "./types.js";
 import type { GoalState } from "./goal/store.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
 export interface ExternalRuntimeSessionMetadata {
     /** External agent runtime that owns the conversational state. */
     id: "grok";
@@ -65,7 +66,11 @@ export interface SessionToolResultEntry extends BaseSessionLogEntry {
     type: "tool_result";
     message: ToolMessage;
 }
-export type SessionLogEntry = SessionMetadataEntry | SessionSummaryEntry | SessionMarkerEntry | SessionUserMessageEntry | SessionAssistantMessageEntry | SessionToolCallEntry | SessionToolResultEntry;
+export interface SessionProviderErrorEntry extends BaseSessionLogEntry {
+    type: "provider_error";
+    error: SanitizedProviderError;
+}
+export type SessionLogEntry = SessionMetadataEntry | SessionSummaryEntry | SessionMarkerEntry | SessionUserMessageEntry | SessionAssistantMessageEntry | SessionToolCallEntry | SessionToolResultEntry | SessionProviderErrorEntry;
 export interface LegacySessionEntry {
     id: string;
     type: "metadata" | "message" | "compaction";

package/dist/session.d.ts

@@ -5,6 +5,7 @@ import { CheckpointStore } from "./checkpoints.js";
 import { type CompactOptions, type CompactResult } from "./context/compact.js";
 import type { Message } from "./types.js";
 import type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
 export interface SessionSummary {
     file: string;
     name: string;
@@ -62,6 +63,7 @@ export declare class SessionManager {
     appendMessage(message: Message): void;
     appendCompaction(summary: string): void;
     appendMarker(kind: SessionMarkerKind, value: string): void;
+    appendProviderError(error: SanitizedProviderError): void;
     compact(options?: CompactOptions): CompactResult;
     /**
      * Inspect whether the session is large enough to compact and, if so, return