@bubblebrain-ai/bubble 0.0.46 → 0.0.47

package/dist/provider.js

@@ -102,13 +102,19 @@ export function createProviderInstance(options) {
     // CLI identity headers the proxy gates on, plus a fetch that keeps the
     // short-lived OAuth bearer fresh (and proxy-aware) across long sessions.
     const grokSubscription = options.providerId === "grok" || isGrokSubscriptionBaseUrl(options.baseURL);
+    // User-configured headers merge over the built-in identity headers so a
+    // config entry can override even the Grok defaults deliberately.
+    const defaultHeaders = {
+        ...(grokSubscription ? buildGrokSubscriptionHeaders() : {}),
+        ...(options.headers ?? {}),
+    };
     const client = new OpenAI({
         apiKey: options.apiKey,
         baseURL: options.baseURL,
         timeout: resolveRequestTimeoutMs(process.env.BUBBLE_PROVIDER_REQUEST_TIMEOUT_MS),
+        ...(Object.keys(defaultHeaders).length > 0 ? { defaultHeaders } : {}),
         ...(grokSubscription
             ? {
-                defaultHeaders: buildGrokSubscriptionHeaders(),
                 fetch: (options.grokAuth
                     ? createGrokSubscriptionFetch(options.grokAuth)
                     : getChatGptFetch()),
@@ -266,10 +272,16 @@ function shouldRequestStreamUsage(options) {
         || providerId === "deepseek"
         || providerId === "moonshot-cn"
         || providerId === "moonshot-intl"
+        // Verified 2026-08-04: this endpoint streams NO usage at all without the
+        // flag, so every coding-plan session was silently unpriced and left the
+        // context-budget anchor guessing.
+        || providerId === "kimi-for-coding"
         || providerId === "zhipuai"
         || providerId === "zhipuai-coding-plan"
         || providerId === "zai"
         || providerId === "zai-coding-plan"
+        // Bailian sends usage either way; ask explicitly so it stays guaranteed.
+        || providerId === "bailian-token-plan"
         || isMiniMaxOpenAICompatible(options);
 }
 function shouldUseNonStreamingToolCalls(options, tools, toolChoice) {

package/dist/sdk/index.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Bubble SDK — the programmatic embedding surface for external hosts.
+ *
+ * Two layers:
+ *  1. `BubbleSdk` — a high-level facade that owns config/provider resolution and
+ *     assembles a full agent turn (tools, approvals, questions, plan mode, MCP,
+ *     skills, hooks, session persistence) behind a single `runTurn()` async
+ *     iterator of `AgentEvent`s. This is what a host like an Electron app should
+ *     consume: wire the three interaction callbacks (approval / question / plan)
+ *     to its own UI and map the event stream to its own message format.
+ *  2. Curated re-exports of the underlying building blocks, for hosts that need
+ *     to assemble a custom loop the facade doesn't cover.
+ *
+ * Runs under plain Node (>=20); nothing here touches the TUI layer.
+ */
+import { type SessionSummary } from "../session.js";
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import { UserConfig } from "../config.js";
+import { ProviderRegistry } from "../provider-registry.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, ContentPart, Message, PermissionMode, ThinkingLevel } from "../types.js";
+export interface BubbleSdkOptions {
+    /** Fallback working directory for sessions created without an explicit cwd. */
+    defaultCwd?: string;
+    /**
+     * Load MCP servers from user/project settings (default true). Hermetic hosts
+     * (evals, tests) set false so runs never depend on ambient MCP config.
+     */
+    mcp?: boolean;
+}
+/** Resolved turn configuration, reported via onStart (e.g. for a host's system-init event). */
+export interface TurnStartInfo {
+    providerId: string;
+    model: string;
+    thinkingLevel: ThinkingLevel;
+    mode: PermissionMode;
+    tools: string[];
+    skills: string[];
+}
+/** Host-side interaction callbacks for one turn. All optional; missing handlers fail safe (reject). */
+export interface TurnHandlers {
+    /**
+     * Tool call needs user permission (bash / edit / write / …). When the turn is
+     * aborted, any still-pending request auto-resolves to reject — the host's
+     * promise may settle later and is then ignored.
+     */
+    onApproval?: (req: ApprovalRequest) => Promise<ApprovalDecision>;
+    /** Agent asked the user a structured question. Return answers, or null to decline. */
+    onQuestion?: (req: QuestionRequest) => Promise<QuestionAnswer[] | null>;
+    /** Plan-mode proposal. Return true to approve executing the plan. */
+    onPlanApproval?: (planMarkdown: string) => 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 {
+    /** Plain text, or content parts (text + base64 images) for attachments. */
+    prompt: string | ContentPart[];
+    /** "provider:model" or bare model id (resolved against the default provider). */
+    model?: string;
+    mode?: PermissionMode;
+    thinkingLevel?: ThinkingLevel;
+    /**
+     * Extra text appended to the built system prompt. Lets hosts (and the eval
+     * harness) A/B prompt variants without forking the prompt builder.
+     */
+    appendSystemPrompt?: string;
+    signal?: AbortSignal;
+}
+export interface SdkSessionRef {
+    id: string;
+    cwd: string;
+}
+export declare class BubbleSdk {
+    readonly userConfig: UserConfig;
+    readonly registry: ProviderRegistry;
+    private readonly defaultCwd;
+    private readonly mcpEnabled;
+    private readonly cwdBySession;
+    private readonly bashAllowlists;
+    private readonly activeTurns;
+    private readonly mcpToolsByCwd;
+    /** id -> {cwd,file} rebuilt from disk so sessions survive host restarts. */
+    private sessionIndex;
+    constructor(options?: BubbleSdkOptions);
+    listSessions(): SessionSummary[];
+    createSession(options?: {
+        cwd?: string;
+        id?: string;
+    }): SdkSessionRef;
+    getHistory(sessionId: string): Message[];
+    deleteSession(sessionId: string): void;
+    /** Abort the in-flight turn of a session, if any. */
+    stop(sessionId: string): void;
+    listSkills(cwd?: string): SkillSummary[];
+    /** Configured providers + default model, for a host's model picker. */
+    getModelConfig(): {
+        defaultProviderId: string;
+        defaultModel: string;
+        providers: Array<{
+            id: string;
+            baseURL?: string;
+            hasApiKey: boolean;
+        }>;
+    };
+    runTurn(sessionId: string, options: RunTurnOptions): AsyncGenerator<AgentEvent>;
+    private bashAllowlistFor;
+    /** MCP servers are started lazily, once per cwd (McpManager has no stop). */
+    private mcpToolsFor;
+    private resolveSession;
+    private resolveProvider;
+}
+/**
+ * Attach a `cost` field to turn_end events that carry usage, priced via the
+ * static pricing table. Pricing is an accounting concern, so it rides along
+ * here in the SDK rather than in the agent core. Multi-step turns emit several
+ * turn_end events; each cost covers only that step's usage, so hosts sum them.
+ * Events for unpriced models (or without usage) pass through untouched.
+ */
+export declare function attachTurnCost(event: AgentEvent, providerId: string, modelId: string): AgentEvent;
+/**
+ * If the prompt (or its first text part) is a "/<skill-name> <task>" skill
+ * invocation, rewrite it into the same explicit execution prompt the TUI
+ * sends. Non-matching prompts pass through untouched.
+ */
+export declare function rewriteSkillInvocationPrompt(prompt: string | ContentPart[], registry: SkillRegistry): string | ContentPart[];
+export { Agent, AgentAbortError, type AgentOptions, type AgentRunOptions } from "../agent.js";
+export { SessionManager, getSessionsDir, type SessionSummary, type UserTurn, type RewindResult, } from "../session.js";
+export { PermissionAwareApprovalController } from "../approval/controller.js";
+export { BashAllowlist } from "../approval/session-cache.js";
+export type { ApprovalController, ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+export { createAllTools, buildToolPromptOptions, type PlanController } from "../tools/index.js";
+export { buildSystemPrompt } from "../system-prompt.js";
+export { FileStateTracker } from "../tools/file-state.js";
+export { BudgetLedger } from "../agent/budget-ledger.js";
+export { UserConfig } from "../config.js";
+export { ProviderRegistry, encodeModel, decodeModel, displayModel, type ProviderProfile, type ModelInfo, } from "../provider-registry.js";
+export { createProviderInstance } from "../provider.js";
+export { getDefaultThinkingLevel } from "../variant/variant-resolver.js";
+export { QuestionController, QuestionRejectedError, type QuestionAnswer, type QuestionEvent, type QuestionRequest, } from "../question/controller.js";
+export { SkillRegistry } from "../skills/registry.js";
+export { parseSkillInvocation, type SkillInvocation } from "../skills/invocation.js";
+export type { SkillSummary } from "../skills/types.js";
+export { GoalStore } from "../goal/store.js";
+export { McpManager } from "../mcp/manager.js";
+export { loadMcpConfig } from "../mcp/config.js";
+export { ExternalHookController } from "../hooks/controller.js";
+export { calculateUsageCost, getModelPricing, type ModelPricing, type PricingCurrency, } from "../model-pricing.js";
+export { registry as slashCommandRegistry } from "../slash-commands/index.js";
+export type { SlashCommandContext } from "../slash-commands/types.js";
+export type { AgentEvent, ContentPart, Message, PermissionMode, Provider, ThinkingLevel, Todo, TokenUsage, UsageCost, ToolRegistryEntry, ToolResult, ToolUpdate, } from "../types.js";

package/dist/sdk/index.js

@@ -0,0 +1,400 @@
+/**
+ * Bubble SDK — the programmatic embedding surface for external hosts.
+ *
+ * Two layers:
+ *  1. `BubbleSdk` — a high-level facade that owns config/provider resolution and
+ *     assembles a full agent turn (tools, approvals, questions, plan mode, MCP,
+ *     skills, hooks, session persistence) behind a single `runTurn()` async
+ *     iterator of `AgentEvent`s. This is what a host like an Electron app should
+ *     consume: wire the three interaction callbacks (approval / question / plan)
+ *     to its own UI and map the event stream to its own message format.
+ *  2. Curated re-exports of the underlying building blocks, for hosts that need
+ *     to assemble a custom loop the facade doesn't cover.
+ *
+ * Runs under plain Node (>=20); nothing here touches the TUI layer.
+ */
+import os from "node:os";
+import { rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { Agent } from "../agent.js";
+import { SessionManager } from "../session.js";
+import { PermissionAwareApprovalController } from "../approval/controller.js";
+import { BashAllowlist } from "../approval/session-cache.js";
+import { createAllTools, buildToolPromptOptions } from "../tools/index.js";
+import { buildSystemPrompt } from "../system-prompt.js";
+import { FileStateTracker } from "../tools/file-state.js";
+import { BudgetLedger } from "../agent/budget-ledger.js";
+import { UserConfig } from "../config.js";
+import { ProviderRegistry, encodeModel, decodeModel, displayModel } from "../provider-registry.js";
+import { createProviderInstance } from "../provider.js";
+import { getDefaultThinkingLevel } from "../variant/variant-resolver.js";
+import { QuestionController } from "../question/controller.js";
+import { SkillRegistry } from "../skills/registry.js";
+import { parseSkillInvocation } from "../skills/invocation.js";
+import { GoalStore } from "../goal/store.js";
+import { McpManager } from "../mcp/manager.js";
+import { loadMcpConfig } from "../mcp/config.js";
+import { ExternalHookController } from "../hooks/controller.js";
+import { buildMemoryPrompt } from "../memory/store.js";
+import { calculateUsageCost } from "../model-pricing.js";
+import { purgeUnsafeMemorySources } from "../memory/session-policy.js";
+import { recordMemoryCitations } from "../memory/usage.js";
+// ── Facade ─────────────────────────────────────────────────────────────────
+export class BubbleSdk {
+    userConfig = new UserConfig();
+    registry = new ProviderRegistry(this.userConfig);
+    defaultCwd;
+    mcpEnabled;
+    cwdBySession = new Map();
+    bashAllowlists = new Map();
+    activeTurns = new Map();
+    mcpToolsByCwd = new Map();
+    /** id -> {cwd,file} rebuilt from disk so sessions survive host restarts. */
+    sessionIndex = new Map();
+    constructor(options = {}) {
+        this.defaultCwd = options.defaultCwd || process.env.BUBBLE_CWD || os.homedir();
+        this.mcpEnabled = options.mcp !== false;
+    }
+    // ── Sessions ─────────────────────────────────────────────────────────────
+    listSessions() {
+        const sessions = SessionManager.listAllSessions();
+        this.sessionIndex = new Map(sessions.map((s) => [s.name, { cwd: s.cwd ?? s.cwdLabel ?? this.defaultCwd, file: s.file }]));
+        return sessions;
+    }
+    createSession(options = {}) {
+        const cwd = options.cwd || this.defaultCwd;
+        const id = options.id || `sdk-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+        SessionManager.create(cwd, sessionFileName(id));
+        this.cwdBySession.set(id, cwd);
+        return { id, cwd };
+    }
+    getHistory(sessionId) {
+        return this.resolveSession(sessionId)?.manager.getMessages() ?? [];
+    }
+    deleteSession(sessionId) {
+        const resolved = this.resolveSession(sessionId);
+        if (resolved)
+            rmSync(resolved.manager.getSessionFile(), { force: true });
+        this.cwdBySession.delete(sessionId);
+        this.bashAllowlists.delete(sessionId);
+        this.sessionIndex.delete(sessionId);
+    }
+    /** Abort the in-flight turn of a session, if any. */
+    stop(sessionId) {
+        this.activeTurns.get(sessionId)?.abort();
+    }
+    // ── Discovery (composer pickers) ─────────────────────────────────────────
+    listSkills(cwd) {
+        const registry = new SkillRegistry({
+            cwd: cwd || this.defaultCwd,
+            skillPaths: this.userConfig.getSkillPaths(),
+        });
+        return registry.summaries();
+    }
+    /** Configured providers + default model, for a host's model picker. */
+    getModelConfig() {
+        const configured = this.registry.getConfigured().filter((p) => p.enabled);
+        return {
+            defaultProviderId: this.registry.getDefault()?.id ?? "",
+            defaultModel: this.userConfig.getDefaultModel() ?? "",
+            providers: configured.map((p) => ({ id: p.id, baseURL: p.baseURL, hasApiKey: Boolean(p.apiKey) })),
+        };
+    }
+    // ── The turn ─────────────────────────────────────────────────────────────
+    async *runTurn(sessionId, options) {
+        const resolved = this.resolveSession(sessionId);
+        if (!resolved)
+            throw new Error(`Unknown session: ${sessionId}`);
+        const { manager: session, cwd } = resolved;
+        const mode = options.mode ?? "default";
+        const abort = new AbortController();
+        if (options.signal) {
+            if (options.signal.aborted)
+                abort.abort();
+            else
+                options.signal.addEventListener("abort", () => abort.abort(), { once: true });
+        }
+        this.activeTurns.set(sessionId, abort);
+        let agentRef;
+        const hookController = new ExternalHookController({ cwd, sessionId });
+        // Settles as reject the moment the turn aborts, so a tool blocked on a
+        // host approval (or question) can never hang the abort path.
+        const abortedDecision = new Promise((resolve) => {
+            const decide = () => resolve({ action: "reject", feedback: "Turn aborted" });
+            if (abort.signal.aborted)
+                decide();
+            else
+                abort.signal.addEventListener("abort", decide, { once: true });
+        });
+        const approvalController = new PermissionAwareApprovalController({
+            getMode: () => agentRef?.mode ?? mode,
+            handlerRef: {
+                current: (req) => options.onApproval
+                    ? Promise.race([options.onApproval(req), abortedDecision])
+                    : Promise.resolve({
+                        action: "reject",
+                        feedback: "Host provided no approval handler",
+                    }),
+            },
+            bashAllowlist: this.bashAllowlistFor(sessionId),
+            cwd,
+            externalHooks: hookController,
+        });
+        const fileStateTracker = new FileStateTracker(cwd);
+        const planController = {
+            getMode: () => agentRef?.mode ?? mode,
+            requestApproval: async (plan) => {
+                const approved = options.onPlanApproval ? await options.onPlanApproval(plan) : false;
+                if (approved) {
+                    agentRef?.setMode("default");
+                    return { action: "approve", plan };
+                }
+                return { action: "reject", reason: "Plan rejected by host" };
+            },
+            setMode: (m) => agentRef?.setMode(m),
+        };
+        const questionController = new QuestionController();
+        const unsubscribeQuestions = questionController.subscribe((event) => {
+            if (event.type !== "asked")
+                return;
+            const request = event.request;
+            if (!options.onQuestion) {
+                questionController.reject(request.id);
+                return;
+            }
+            options.onQuestion(request).then((answers) => answers ? questionController.reply(request.id, answers) : questionController.reject(request.id), () => questionController.reject(request.id));
+        });
+        abort.signal.addEventListener("abort", () => questionController.rejectAll(), { once: true });
+        try {
+            const skillRegistry = new SkillRegistry({ cwd, skillPaths: this.userConfig.getSkillPaths() });
+            const tools = createAllTools(cwd, skillRegistry, {
+                approvalController,
+                fileStateTracker,
+                planController,
+                todoStore: {
+                    getTodos: () => agentRef?.getTodos() ?? [],
+                    setTodos: (todos) => agentRef?.setTodos(todos),
+                },
+                questionController,
+                goalStore: new GoalStore(),
+                checkpoints: () => session.getCheckpoints(),
+            });
+            tools.push(...(await this.mcpToolsFor(cwd)));
+            const promptCacheKey = session.getOrCreatePromptCacheKey();
+            session.updateMetadata({ cwd }); // recoverable by cwd after host restart
+            const { provider, providerId, model } = this.resolveProvider(promptCacheKey, options.model);
+            const thinkingLevel = options.thinkingLevel ??
+                this.userConfig.getDefaultThinkingLevel() ??
+                getDefaultThinkingLevel(providerId, decodeModel(model).modelId);
+            // Same ordering as the TUI: the provenance gate must run before memories
+            // enter the system prompt.
+            purgeUnsafeMemorySources(cwd);
+            const memoryPrompt = buildMemoryPrompt(cwd);
+            const builtSystemPrompt = buildSystemPrompt({
+                agentName: "Bubble",
+                configuredProvider: providerId || "none",
+                configuredModel: model ? displayModel(model) : "none",
+                configuredModelId: model || "none",
+                thinkingLevel,
+                mode,
+                workingDir: cwd,
+                ...buildToolPromptOptions(tools.filter((t) => !t.deferred)),
+                memoryPrompt,
+            });
+            const systemPrompt = options.appendSystemPrompt
+                ? `${builtSystemPrompt}\n\n${options.appendSystemPrompt.trim()}`
+                : builtSystemPrompt;
+            const agent = new Agent({
+                provider,
+                providerId,
+                model,
+                sessionID: session.getSessionFile(),
+                tools,
+                systemPrompt,
+                temperature: 0.2,
+                thinkingLevel,
+                mode,
+                todos: session.getTodos(),
+                budgetLedger: new BudgetLedger(),
+                fileStateTracker,
+                skills: skillRegistry.summaries(),
+                memoryPrompt,
+                externalHooks: hookController,
+                onMessageAppend: (message) => {
+                    if (message.role === "system" || message.role === "meta")
+                        return;
+                    session.appendMessage(message);
+                    if (message.role === "assistant")
+                        recordMemoryCitations(cwd, message.content);
+                },
+                onCompactionApplied: (summary) => {
+                    session.applyLLMCompaction(summary);
+                },
+                onTodosUpdate: (todos) => session.appendTodosSnapshot(todos),
+                onModeUpdate: (m) => session.appendMarker("mode_switch", m),
+            });
+            agentRef = agent;
+            const history = session.getMessages();
+            if (history.length > 0) {
+                agent.messages = [{ role: "system", content: systemPrompt }, ...history];
+            }
+            options.onStart?.({
+                providerId,
+                model,
+                thinkingLevel,
+                mode,
+                tools: tools.map((t) => t.name),
+                skills: skillRegistry.summaries().map((s) => s.name),
+            });
+            // Match the TUI: a leading "/<skill-name> <task>" becomes an explicit
+            // load-this-skill instruction, so invocation never depends on the model
+            // recognizing the slash syntax on its own.
+            const prompt = rewriteSkillInvocationPrompt(options.prompt, skillRegistry);
+            const bareModelId = decodeModel(model).modelId;
+            for await (const event of agent.run(prompt, cwd, { abortSignal: abort.signal })) {
+                yield attachTurnCost(event, providerId, bareModelId);
+                if (abort.signal.aborted)
+                    break;
+            }
+        }
+        finally {
+            // Also reached via generator.return() when the host stops consuming
+            // early: aborting here unblocks any tool still awaiting an approval.
+            abort.abort();
+            unsubscribeQuestions();
+            questionController.rejectAll();
+            if (this.activeTurns.get(sessionId) === abort)
+                this.activeTurns.delete(sessionId);
+        }
+    }
+    // ── Internals ────────────────────────────────────────────────────────────
+    bashAllowlistFor(sessionId) {
+        let allowlist = this.bashAllowlists.get(sessionId);
+        if (!allowlist) {
+            allowlist = new BashAllowlist();
+            this.bashAllowlists.set(sessionId, allowlist);
+        }
+        return allowlist;
+    }
+    /** MCP servers are started lazily, once per cwd (McpManager has no stop). */
+    mcpToolsFor(cwd) {
+        if (!this.mcpEnabled)
+            return Promise.resolve([]);
+        let cached = this.mcpToolsByCwd.get(cwd);
+        if (!cached) {
+            cached = (async () => {
+                const loaded = loadMcpConfig({ cwd });
+                if (loaded.servers.length === 0)
+                    return [];
+                const manager = new McpManager({ servers: loaded.servers });
+                await manager.start();
+                return manager.getToolEntries();
+            })().catch(() => []);
+            this.mcpToolsByCwd.set(cwd, cached);
+        }
+        return cached;
+    }
+    resolveSession(sessionId) {
+        const memCwd = this.cwdBySession.get(sessionId);
+        if (memCwd) {
+            // create() only resolves the path and loads iff the file exists, so this
+            // covers both fresh (lazily persisted, not yet on disk) and resumed sessions.
+            return { manager: SessionManager.create(memCwd, sessionFileName(sessionId)), cwd: memCwd };
+        }
+        if (this.sessionIndex.size === 0)
+            this.listSessions();
+        const entry = this.sessionIndex.get(sessionId);
+        if (!entry)
+            return undefined;
+        this.cwdBySession.set(sessionId, entry.cwd);
+        return { manager: new SessionManager(entry.file), cwd: entry.cwd };
+    }
+    resolveProvider(promptCacheKey, explicitModel) {
+        const configuredModel = explicitModel || this.userConfig.getDefaultModel();
+        const defaultProvider = this.registry.getDefault();
+        const fallbackProviderId = defaultProvider?.id ?? "";
+        const normalized = configuredModel
+            ? configuredModel.includes(":")
+                ? configuredModel
+                : fallbackProviderId
+                    ? encodeModel(fallbackProviderId, configuredModel)
+                    : ""
+            : "";
+        const { providerId: effId, modelId: effModelId } = normalized
+            ? decodeModel(normalized)
+            : { providerId: undefined, modelId: "" };
+        const activeProviderId = effId || fallbackProviderId;
+        const target = this.registry.getConfigured().find((p) => p.id === activeProviderId) || defaultProvider;
+        if (!target?.apiKey) {
+            throw new Error("No provider with an API key configured — run the Bubble CLI once to set one up");
+        }
+        const activeModel = effModelId ? encodeModel(activeProviderId, effModelId) : "";
+        const provider = createProviderInstance({
+            providerId: activeProviderId,
+            apiKey: target.apiKey,
+            baseURL: target.baseURL,
+            promptCacheKey,
+            protocol: target.protocol,
+            headers: target.headers,
+        });
+        return { provider, providerId: activeProviderId, model: activeModel };
+    }
+}
+function sessionFileName(sessionId) {
+    return sessionId.endsWith(".jsonl") ? sessionId : `${sessionId}.jsonl`;
+}
+/**
+ * Attach a `cost` field to turn_end events that carry usage, priced via the
+ * static pricing table. Pricing is an accounting concern, so it rides along
+ * here in the SDK rather than in the agent core. Multi-step turns emit several
+ * turn_end events; each cost covers only that step's usage, so hosts sum them.
+ * Events for unpriced models (or without usage) pass through untouched.
+ */
+export function attachTurnCost(event, providerId, modelId) {
+    if (event.type !== "turn_end" || !event.usage)
+        return event;
+    const cost = calculateUsageCost(providerId, modelId, event.usage);
+    return cost ? { ...event, cost } : event;
+}
+/**
+ * If the prompt (or its first text part) is a "/<skill-name> <task>" skill
+ * invocation, rewrite it into the same explicit execution prompt the TUI
+ * sends. Non-matching prompts pass through untouched.
+ */
+export function rewriteSkillInvocationPrompt(prompt, registry) {
+    if (typeof prompt === "string") {
+        return parseSkillInvocation(prompt, registry)?.actualPrompt ?? prompt;
+    }
+    const index = prompt.findIndex((part) => part.type === "text");
+    if (index === -1)
+        return prompt;
+    const part = prompt[index];
+    const rewritten = parseSkillInvocation(part.text, registry)?.actualPrompt;
+    if (!rewritten)
+        return prompt;
+    const next = prompt.slice();
+    next[index] = { ...part, text: rewritten };
+    return next;
+}
+// ── Building blocks (escape hatch for custom hosts) ────────────────────────
+export { Agent, AgentAbortError } from "../agent.js";
+export { SessionManager, getSessionsDir, } from "../session.js";
+export { PermissionAwareApprovalController } from "../approval/controller.js";
+export { BashAllowlist } from "../approval/session-cache.js";
+export { createAllTools, buildToolPromptOptions } from "../tools/index.js";
+export { buildSystemPrompt } from "../system-prompt.js";
+export { FileStateTracker } from "../tools/file-state.js";
+export { BudgetLedger } from "../agent/budget-ledger.js";
+export { UserConfig } from "../config.js";
+export { ProviderRegistry, encodeModel, decodeModel, displayModel, } from "../provider-registry.js";
+export { createProviderInstance } from "../provider.js";
+export { getDefaultThinkingLevel } from "../variant/variant-resolver.js";
+export { QuestionController, QuestionRejectedError, } from "../question/controller.js";
+export { SkillRegistry } from "../skills/registry.js";
+export { parseSkillInvocation } from "../skills/invocation.js";
+export { GoalStore } from "../goal/store.js";
+export { McpManager } from "../mcp/manager.js";
+export { loadMcpConfig } from "../mcp/config.js";
+export { ExternalHookController } from "../hooks/controller.js";
+export { calculateUsageCost, getModelPricing, } from "../model-pricing.js";
+export { registry as slashCommandRegistry } from "../slash-commands/index.js";

package/dist/session.js

@@ -4,6 +4,7 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { isInternalBlockOnlyContent } from "./agent/internal-reminder-sanitizer.js";
 import { getBubbleHome } from "./bubble-home.js";
 import { CheckpointStore } from "./checkpoints.js";
 import { buildCompactedEntries, compactSessionEntries, planOldMessages, planSessionCompaction, } from "./context/compact.js";
@@ -237,6 +238,10 @@ export class SessionManager {
             const entry = entries[i];
             if (entry.type !== "user_message")
                 continue;
+            // Harness-injected turns (goal kicks, task wakes) are internal blocks —
+            // not rewind anchors, and their markup must never render in the picker.
+            if (isInternalBlockOnlyContent(entry.message.content))
+                continue;
             const text = messageText(entry.message);
             turns.push({
                 id: entry.id,
@@ -354,8 +359,11 @@ function firstUserEntryAfterLatestClear(entries) {
     const startIndex = latestClearIndex(entries) + 1;
     for (let i = startIndex; i < entries.length; i++) {
         const entry = entries[i];
-        if (entry.type === "user_message")
+        // Skip harness-injected internal blocks (goal kicks, task wakes): they
+        // must not become the /resume preview or the deterministic title.
+        if (entry.type === "user_message" && !isInternalBlockOnlyContent(entry.message.content)) {
             return entry;
+        }
     }
     return undefined;
 }