@bubblebrain-ai/bubble 0.0.58 → 0.0.60

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.js

@@ -11,11 +11,13 @@ import { createAiSdkProvider } from "./provider-ai-sdk.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { buildGrokSubscriptionHeaders, createGrokSubscriptionFetch, isGrokSubscriptionBaseUrl, } from "./provider-grok.js";
 import { getChatGptFetch } from "./network/chatgpt-transport.js";
+import { createProviderFetch } from "./network/provider-transport.js";
+import { chatRequestShape, isSpaceBunnyUpstreamRejection, recoverableSpaceBunnyError } from "./provider-zen-errors.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
 import { isProviderResponseError, ProviderResponseError, RateLimitError, } from "./network/errors.js";
-import { isRetryableHttpStatus, ProviderStreamInterruptedError } from "./network/retry.js";
+import { computeRetryDelayMs, isRetryableHttpStatus, ProviderStreamInterruptedError, sleepBeforeRetry } from "./network/retry.js";
 import { assertProviderModelAllowed } from "./provider-model-policy.js";
 // Diagnostic logger for tool-args byte-loss investigation. Activate with
 //   BUBBLE_DEBUG_TOOL_ARGS=/path/to/log.jsonl   (any writable path)
@@ -90,6 +92,18 @@ export function createProviderInstance(options) {
         return createArkResponsesProvider(options);
     }
     if (protocol === "openai-responses") {
+        if (options.providerId === "opencode-zen") {
+            // Existing Zen profiles explicitly store Responses for Muse. Dispatch
+            // by model at send time: Space Bunny rejects /responses with 400
+            // ModelProtocolUnsupported and uses /chat/completions instead.
+            const responses = createOpenAIResponsesProvider(options);
+            const chat = createProviderInstance({ ...options, protocol: "openai-chat" });
+            const forModel = (model) => model === "space-bunny-free" ? chat : responses;
+            return {
+                streamChat: (messages, chatOptions) => forModel(chatOptions.model).streamChat(messages, chatOptions),
+                complete: (messages, chatOptions) => forModel(chatOptions?.model).complete(messages, chatOptions),
+            };
+        }
         return createOpenAIResponsesProvider(options);
     }
     if (protocol === "ai-sdk") {
@@ -117,6 +131,9 @@ export function createProviderInstance(options) {
         baseURL: options.baseURL,
         timeout: resolveRequestTimeoutMs(process.env.BUBBLE_PROVIDER_REQUEST_TIMEOUT_MS),
         ...(Object.keys(defaultHeaders).length > 0 ? { defaultHeaders } : {}),
+        ...(options.providerId === "opencode-zen" ? {
+            fetch: createProviderFetch({ providerName: "OpenCode Zen" }),
+        } : {}),
         ...(grokSubscription
             ? {
                 fetch: (options.grokAuth
@@ -175,6 +192,9 @@ export function createProviderInstance(options) {
                 });
             }
             catch (error) {
+                if (!chatOptions.abortSignal?.aborted && isSpaceBunnyUpstreamRejection(options.providerId, chatOptions.model, error)) {
+                    throw Object.assign(recoverableSpaceBunnyError(error), { requestShape: chatRequestShape(requestBody) });
+                }
                 if (error?.status === 429) {
                     const retryAfterHeader = error?.headers?.["retry-after"];
                     const retryAfterSeconds = Number(retryAfterHeader);
@@ -216,6 +236,9 @@ export function createProviderInstance(options) {
         catch (error) {
             if (chatOptions.abortSignal?.aborted)
                 throw error;
+            if (isSpaceBunnyUpstreamRejection(options.providerId, chatOptions.model, error)) {
+                throw Object.assign(recoverableSpaceBunnyError(error), { requestShape: chatRequestShape(body) });
+            }
             if (isProviderResponseError(error)) {
                 const rateLimited = error.status === 429 || error.errorType === "rate_limit_exceeded";
                 if (rateLimited && chatOptions.rateLimitPolicy === "defer") {
@@ -264,10 +287,17 @@ export function createProviderInstance(options) {
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
-        const response = await client.chat.completions.create(body, {
-            signal: chatOptions?.abortSignal,
-        });
-        return response.choices[0]?.message?.content ?? "";
+        for (let attempt = 0;; attempt++) {
+            try {
+                const response = await client.chat.completions.create(body, { signal: chatOptions?.abortSignal });
+                return response.choices[0]?.message?.content ?? "";
+            }
+            catch (error) {
+                if (chatOptions?.abortSignal?.aborted || attempt >= 2 || !isSpaceBunnyUpstreamRejection(options.providerId, body.model, error))
+                    throw error;
+                await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), chatOptions?.abortSignal);
+            }
+        }
     }
     return { streamChat, complete };
 }
@@ -301,6 +331,7 @@ function isMiniMaxOpenAICompatible(options) {
 function shouldRequestStreamUsage(options) {
     const providerId = (options.providerId || "").toLowerCase();
     return providerId === "openai"
+        || providerId === "opencode-zen"
         || providerId === "deepseek"
         || providerId === "moonshot-cn"
         || providerId === "moonshot-intl"

package/dist/sdk/index.d.ts

@@ -14,6 +14,7 @@
  * Runs under plain Node (>=20); nothing here touches the TUI layer.
  */
 import { type SessionSummary } from "../session.js";
+import { type RepoCapabilities } from "../permissions/trust.js";
 import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
 import { UserConfig } from "../config.js";
 import { ProviderRegistry } from "../provider-registry.js";
@@ -21,8 +22,13 @@ import type { ResolvedSubagentRoute } from "../agent/categories.js";
 import { type QuestionAnswer, type QuestionRequest } from "../question/controller.js";
 import { SkillRegistry } from "../skills/registry.js";
 import type { SkillSummary } from "../skills/types.js";
-import type { AgentEvent, AgentRunInput, ContentPart, Message, PermissionMode, Provider, ThinkingLevel } from "../types.js";
+import type { AgentEvent, AgentRunInput, ContentPart, Message, PermissionMode, Provider, ThinkingLevel, ToolRegistryEntry } from "../types.js";
 export interface BubbleSdkOptions {
+    /** Optional process-local replay window. Active readers never lose unread
+     * events. Older cursors fail explicitly; restore durable session history.
+     * Omit for unlimited replay (the public SDK compatibility default). The
+     * first opener sets the shared process-local window for that session. */
+    sessionEventRetention?: number;
     /** Fallback working directory for sessions created without an explicit cwd. */
     defaultCwd?: string;
     /**
@@ -52,15 +58,46 @@ export interface TurnHandlers {
     onQuestion?: (req: QuestionRequest) => Promise<QuestionAnswer[] | null>;
     /** Plan-mode proposal. Return true to approve executing the plan. */
     onPlanApproval?: (planMarkdown: string) => Promise<boolean>;
+    /**
+     * Folder trust (Kimi Code style): the session folder's `.bubble` settings
+     * would enable allow rules, MCP servers or LSP servers the user has not
+     * trusted. Return true to trust them. Asked at most once per folder per SDK
+     * instance; without a handler, or on false, they stay off.
+     */
+    onProjectTrust?: (request: {
+        cwd: string;
+        pending: RepoCapabilities;
+    }) => Promise<boolean>;
     /** Fired once per turn after provider/model/tools are resolved, before the first event. */
     onStart?: (info: TurnStartInfo) => void;
 }
 export interface RunTurnOptions extends TurnHandlers {
+    /**
+     * Turn-scoped host capabilities. Never cached globally or given to subagents;
+     * follow-up turns the SDK starts for this turn (queued input, pending steers)
+     * reuse this turn's options, these included.
+     */
+    hostTools?: ToolRegistryEntry[];
+    /**
+     * Extra skill directories for this turn, e.g. skills a host app ships with.
+     * Searched after the user's own roots, so a user skill of the same name wins.
+     * Like hostTools, follow-up turns the SDK starts for this turn reuse them.
+     */
+    skillPaths?: string[];
     /** Plain text, or content parts (text + base64 images) for attachments. */
     prompt: string | ContentPart[];
+    /** Preserve an admitted input if cancelled before initialization records it. */
+    preserveInterruptedInput?: boolean;
     /** "provider:model" or bare model id (resolved against the default provider). */
     model?: string;
     mode?: PermissionMode;
+    /**
+     * Mode the turn switches to when the user approves a plan (only relevant
+     * when `mode` is "plan"). Hosts pass the mode the user had selected before
+     * entering plan mode, so approving a plan does not silently downgrade
+     * bypassPermissions to default. Defaults to "default".
+     */
+    planExitMode?: Exclude<PermissionMode, "plan">;
     thinkingLevel?: ThinkingLevel;
     /**
      * Extra text appended to the built system prompt. Lets hosts (and the eval
@@ -113,21 +150,24 @@ export interface SdkSessionEvent {
     turnId: string;
     event: AgentEvent;
     /**
-     * Present only on the synthesized record that ends a turn abnormally.
-     * Replay subscribers use it to tell "turn failed" from "turn still running";
-     * the per-turn runTurn() iterator instead surfaces the thrown error.
+     * Marks a settled turn after cleanup and admission of any fallback steer.
+     * Successful turns mark agent_end; failures synthesize a turn_end record.
      */
     terminal?: SdkSessionTerminal;
 }
-export interface SdkSessionTerminal {
+export type SdkSessionTerminal = {
+    kind: "completed";
+} | {
     kind: "failed" | "cancelled";
     message: string;
-}
+};
 export interface SdkStopOptions {
     /** Match Claude-style interruption: queued messages survive by default. */
     cancelQueued?: boolean;
 }
 export interface SdkSessionHandle extends SdkSessionRef {
+    /** Current replay cursor; snapshot before send to observe only new work. */
+    readonly latestSequence: number;
     /** Events from every turn in this session. Opening another handle reconnects from sequence 1. */
     readonly events: AsyncIterable<SdkSessionEvent>;
     /** Reconnect after the last sequence the host durably processed. */
@@ -142,12 +182,17 @@ export declare class BubbleSdk {
     readonly registry: ProviderRegistry;
     private readonly defaultCwd;
     private readonly mcpEnabled;
+    private readonly sessionEventRetention;
     private readonly cwdBySession;
     private readonly bashAllowlists;
+    private readonly sessionGrants;
     private readonly turnCoordinator;
     private readonly turnRuntimes;
     private readonly lastTurnOptions;
     private readonly mcpToolsByCwd;
+    private readonly mcpManagersByCwd;
+    /** Folders whose trust question was already put to the host. */
+    private readonly projectTrustAsked;
     private readonly inputIdNonce;
     private nextTurnInputPrefix;
     private nextDetachedInputId;
@@ -161,9 +206,14 @@ export declare class BubbleSdk {
     }): SdkSessionRef;
     openSession(sessionId: string): SdkSessionHandle;
     getHistory(sessionId: string): Message[];
+    /** Preserve an accepted desktop input cancelled before runTurn was admitted. */
+    recordInterruptedInput(sessionId: string, prompt: string | ContentPart[]): void;
+    private persistInterruptedInput;
     deleteSession(sessionId: string): Promise<void>;
     /** Interrupt the active turn. Queued turns survive unless cancelQueued is true. */
     stop(sessionId: string, options?: SdkStopOptions): number;
+    /** Stop and wait for persistence, cleanup, and terminal event publication. */
+    stopAndWait(sessionId: string, options?: SdkStopOptions): Promise<number>;
     /** Cancel queued turns without interrupting the turn that owns the session slot. */
     clearQueue(sessionId: string): number;
     getSessionRunState(sessionId: string): SdkSessionRunState;
@@ -174,7 +224,13 @@ export declare class BubbleSdk {
     steer(sessionId: string, content: string): SdkSteerResult;
     enqueueTurn(sessionId: string, options: RunTurnOptions): AsyncGenerator<AgentEvent>;
     queueTurn(sessionId: string, options: RunTurnOptions): AsyncGenerator<AgentEvent>;
-    listSkills(cwd?: string): SkillSummary[];
+    listSkills(cwd?: string, skillPaths?: string[]): SkillSummary[];
+    /**
+     * Ask the host once per folder (onProjectTrust) before this turn loads the
+     * repository's allow rules, MCP servers and LSP servers. Trusting restarts
+     * the folder's MCP servers so newly trusted ones are available right away.
+     */
+    private resolveProjectTrust;
     /** Configured providers + default model, for a host's model picker. */
     getModelConfig(): {
         defaultProviderId: string;
@@ -205,13 +261,17 @@ export declare class BubbleSdk {
     private publishSessionEvent;
     private ownerForSession;
     private bashAllowlistFor;
+    private sessionGrantsFor;
     /**
      * Default cross-provider subagent factory over this SDK instance's own
      * registry — the same semantics as the TUI's createProviderForRoute. The
      * registry is reloaded first so a key added after construction works.
      */
     private defaultProviderFactory;
-    /** MCP servers are started lazily, once per cwd (McpManager has no stop). */
+    /**
+     * MCP servers are started lazily, once per cwd, and restarted only when the
+     * repository's settings get trusted (resolveProjectTrust).
+     */
     private mcpToolsFor;
     private resolveSession;
     private resolveProvider;
@@ -236,6 +296,7 @@ export { SessionManager, getSessionsDir, type SessionSummary, type UserTurn, typ
 export { PermissionAwareApprovalController } from "../approval/controller.js";
 export { BashAllowlist } from "../approval/session-cache.js";
 export type { ApprovalController, ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+export type { RepoCapabilities } from "../permissions/trust.js";
 export { createAllTools, buildToolPromptOptions, type PlanController } from "../tools/index.js";
 export { buildSystemPrompt } from "../system-prompt.js";
 export { FileStateTracker } from "../tools/file-state.js";