@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/question/controller.d.ts

@@ -0,0 +1,22 @@
+import type { QuestionAnswer, QuestionEvent, QuestionPrompt, QuestionRequest, QuestionToolRef } from "./types.js";
+import { QuestionRejectedError } from "./types.js";
+export interface QuestionAskInput {
+    sessionID?: string;
+    questions: QuestionPrompt[];
+    tool?: QuestionToolRef;
+}
+export declare class QuestionController {
+    private pending;
+    private listeners;
+    private counter;
+    ask(input: QuestionAskInput): Promise<QuestionAnswer[]>;
+    reply(requestID: string, answers: QuestionAnswer[]): boolean;
+    reject(requestID: string): boolean;
+    list(sessionID?: string): QuestionRequest[];
+    subscribe(listener: (event: QuestionEvent) => void): () => void;
+    rejectAll(): void;
+    private emit;
+    private nextID;
+}
+export type { QuestionAnswer, QuestionEvent, QuestionPrompt, QuestionRequest };
+export { QuestionRejectedError };

package/dist/question/controller.js

@@ -0,0 +1,98 @@
+import { QuestionRejectedError } from "./types.js";
+import { normalizeQuestionInlineText } from "./normalize.js";
+export class QuestionController {
+    pending = new Map();
+    listeners = new Set();
+    counter = 0;
+    ask(input) {
+        const request = {
+            id: this.nextID(),
+            sessionID: input.sessionID,
+            questions: input.questions.map(normalizePrompt),
+            tool: input.tool,
+            createdAt: Date.now(),
+        };
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(request.id, {
+                request,
+                resolve,
+                reject,
+            });
+        });
+        this.emit({ type: "asked", request });
+        return promise.finally(() => {
+            this.pending.delete(request.id);
+        });
+    }
+    reply(requestID, answers) {
+        const pending = this.pending.get(requestID);
+        if (!pending)
+            return false;
+        const normalized = normalizeAnswers(pending.request.questions.length, answers);
+        this.pending.delete(requestID);
+        this.emit({ type: "replied", request: pending.request, answers: normalized });
+        pending.resolve(normalized);
+        return true;
+    }
+    reject(requestID) {
+        const pending = this.pending.get(requestID);
+        if (!pending)
+            return false;
+        this.pending.delete(requestID);
+        this.emit({ type: "rejected", request: pending.request });
+        pending.reject(new QuestionRejectedError());
+        return true;
+    }
+    list(sessionID) {
+        const items = Array.from(this.pending.values(), (entry) => entry.request);
+        return sessionID === undefined ? items : items.filter((request) => request.sessionID === sessionID);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    rejectAll() {
+        for (const id of [...this.pending.keys()]) {
+            this.reject(id);
+        }
+    }
+    emit(event) {
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                console.error("[question] listener failed", err);
+            }
+        }
+    }
+    nextID() {
+        this.counter += 1;
+        return `question_${Date.now().toString(36)}_${this.counter.toString(36)}`;
+    }
+}
+function normalizePrompt(input) {
+    return {
+        header: normalizeQuestionInlineText(input.header),
+        question: normalizeQuestionInlineText(input.question),
+        options: Array.isArray(input.options)
+            ? input.options.map((option) => ({
+                label: normalizeQuestionInlineText(option?.label),
+                description: normalizeQuestionInlineText(option?.description),
+            }))
+            : [],
+        multiple: input.multiple === true,
+        custom: input.custom === false ? false : undefined,
+    };
+}
+function normalizeAnswers(count, answers) {
+    return Array.from({ length: count }, (_, index) => {
+        const answer = answers[index];
+        if (!Array.isArray(answer))
+            return [];
+        return answer.map((item) => String(item).trim()).filter(Boolean);
+    });
+}
+export { QuestionRejectedError };

package/dist/question/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./controller.js";

package/dist/question/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./controller.js";

package/dist/question/normalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Structured-question fields are rendered as single terminal rows. Models can
+ * still return embedded CR/LF/tab whitespace, so collapse it at the question
+ * boundary instead of letting terminal control characters reach a renderer.
+ */
+export declare function normalizeQuestionInlineText(value: unknown): string;

package/dist/question/normalize.js

@@ -0,0 +1,11 @@
+/**
+ * Structured-question fields are rendered as single terminal rows. Models can
+ * still return embedded CR/LF/tab whitespace, so collapse it at the question
+ * boundary instead of letting terminal control characters reach a renderer.
+ */
+export function normalizeQuestionInlineText(value) {
+    return String(value ?? "")
+        .replace(/\s+/gu, " ")
+        .replace(/\s+([,.;:!?，。；：！？、）)\]}])/gu, "$1")
+        .trim();
+}

package/dist/question/types.d.ts

@@ -0,0 +1,42 @@
+export interface QuestionOption {
+    label: string;
+    description: string;
+}
+export interface QuestionPrompt {
+    /** Very short label used in tabs for multi-question prompts. */
+    header: string;
+    /** Complete user-facing question text. */
+    question: string;
+    /** Fixed choices shown to the user. */
+    options: QuestionOption[];
+    /** Allow selecting more than one option. Defaults to false. */
+    multiple?: boolean;
+    /** Allow a custom free-form answer. Defaults to true. */
+    custom?: boolean;
+}
+export type QuestionAnswer = string[];
+export interface QuestionToolRef {
+    messageID?: string;
+    callID: string;
+}
+export interface QuestionRequest {
+    id: string;
+    sessionID?: string;
+    questions: QuestionPrompt[];
+    tool?: QuestionToolRef;
+    createdAt: number;
+}
+export type QuestionEvent = {
+    type: "asked";
+    request: QuestionRequest;
+} | {
+    type: "replied";
+    request: QuestionRequest;
+    answers: QuestionAnswer[];
+} | {
+    type: "rejected";
+    request: QuestionRequest;
+};
+export declare class QuestionRejectedError extends Error {
+    constructor(message?: string);
+}

package/dist/question/types.js

@@ -0,0 +1,6 @@
+export class QuestionRejectedError extends Error {
+    constructor(message = "The user dismissed this question") {
+        super(message);
+        this.name = "QuestionRejectedError";
+    }
+}

package/dist/reasoning-debug.d.ts

@@ -0,0 +1,7 @@
+export interface DebugTextSummary {
+    length: number;
+    hash: string;
+    preview?: string;
+}
+export declare function summarizeDebugText(value: unknown): DebugTextSummary | undefined;
+export declare function debugReasoningStream(event: Record<string, unknown>): void;

package/dist/reasoning-debug.js

@@ -0,0 +1,33 @@
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
+const DEBUG_PATH = process.env.BUBBLE_DEBUG_REASONING_STREAM?.trim();
+const INCLUDE_PREVIEW = process.env.BUBBLE_DEBUG_REASONING_PREVIEW !== "0";
+const INCLUDE_RAW_PREVIEW = ["1", "true", "yes", "on"].includes(process.env.BUBBLE_DEBUG_REASONING_RAW?.trim().toLowerCase() ?? "");
+const PREVIEW_CHARS = 180;
+let sequence = 0;
+export function summarizeDebugText(value) {
+    if (!DEBUG_PATH)
+        return undefined;
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    const hash = createHash("sha256").update(value).digest("hex").slice(0, 16);
+    const summary = { length: value.length, hash };
+    if (INCLUDE_PREVIEW) {
+        const previewValue = INCLUDE_RAW_PREVIEW ? value : sanitizeInternalReminderBlocks(value);
+        summary.preview = previewValue.replace(/\s+/g, " ").slice(0, PREVIEW_CHARS);
+    }
+    return summary;
+}
+export function debugReasoningStream(event) {
+    if (!DEBUG_PATH)
+        return;
+    try {
+        mkdirSync(dirname(DEBUG_PATH), { recursive: true });
+        appendFileSync(DEBUG_PATH, JSON.stringify({ t: Date.now(), seq: ++sequence, ...event }) + "\n", "utf-8");
+    }
+    catch {
+        // Debug logging must never affect an agent run.
+    }
+}

package/dist/rewind.d.ts

@@ -0,0 +1,20 @@
+import type { CheckpointRestoreResult } from "./checkpoints.js";
+import type { SessionManager, UserTurn } from "./session.js";
+import type { Message } from "./types.js";
+export type RewindScope = "all" | "chat" | "code";
+export interface RewindAgentState {
+    messages: Message[];
+    resetContextUsageAnchor(): void;
+}
+export interface RewindExecutionResult {
+    target: UserTurn;
+    scope: RewindScope;
+    files: CheckpointRestoreResult;
+    removedEntries: number;
+}
+/**
+ * Apply the persistent rewind exactly once. Renderers layer their own visual
+ * transaction around this function, but the session log and Agent transcript
+ * always move together here.
+ */
+export declare function executeRewind(session: SessionManager, agent: RewindAgentState, targetId: string, scope: RewindScope): Promise<RewindExecutionResult>;

package/dist/rewind.js

@@ -0,0 +1,29 @@
+const EMPTY_FILE_RESULT = {
+    restored: [],
+    deleted: [],
+    failed: [],
+};
+/**
+ * Apply the persistent rewind exactly once. Renderers layer their own visual
+ * transaction around this function, but the session log and Agent transcript
+ * always move together here.
+ */
+export async function executeRewind(session, agent, targetId, scope) {
+    const target = session.listUserTurns().find((turn) => turn.id === targetId);
+    if (!target)
+        throw new Error("The selected rewind point is no longer available.");
+    const files = scope === "chat"
+        ? { ...EMPTY_FILE_RESULT, restored: [], deleted: [], failed: [] }
+        : await session.getCheckpoints().restoreTo(target.id);
+    let removedEntries = 0;
+    if (scope !== "code") {
+        const rewound = session.rewindToEntry(target.id);
+        if (!rewound)
+            throw new Error("The selected rewind point is no longer available.");
+        removedEntries = rewound.removedEntries;
+        const head = agent.messages.filter((message) => message.role === "system" || message.role === "meta");
+        agent.messages = [...head, ...session.getMessages()];
+        agent.resetContextUsageAnchor();
+    }
+    return { target, scope, files, removedEntries };
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,319 @@
+/**
+ * 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 RepoCapabilities } from "../permissions/trust.js";
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import { UserConfig } from "../config.js";
+import { ProviderRegistry } from "../provider-registry.js";
+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, 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;
+    /**
+     * 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>;
+    /**
+     * 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
+     * harness) A/B prompt variants without forking the prompt builder.
+     */
+    appendSystemPrompt?: string;
+    /**
+     * Creates the provider instance for a subagent route whose provider differs
+     * from the turn's provider (e.g. spawn_agent with `model: "provider:model"`).
+     * When omitted the SDK builds a default factory over its own registry —
+     * same semantics as the TUI's createProviderForRoute (OAuth prepare, then
+     * configured+enabled+keyed profile lookup). Pass your own to override.
+     */
+    providerFactory?: (route: ResolvedSubagentRoute) => Provider | Promise<Provider>;
+    signal?: AbortSignal;
+}
+export interface SdkSessionRef {
+    id: string;
+    cwd: string;
+}
+export interface SdkSessionRunState {
+    /** A turn owns the session slot, including setup and teardown. */
+    active: boolean;
+    queuedTurns: number;
+    pendingSteers: number;
+    phase: "idle" | "reserved" | "starting" | "active" | "stopping" | "deleted";
+}
+export type SdkSteerOutcome = Extract<AgentEvent, {
+    type: "input_applied" | "input_queued" | "input_rejected";
+}>;
+export type SdkSteerResult = {
+    accepted: true;
+    disposition: "steered";
+    input: AgentRunInput;
+    outcome: Promise<SdkSteerOutcome>;
+} | {
+    accepted: true;
+    disposition: "queued";
+    input: AgentRunInput;
+    turnId: string;
+    outcome: Promise<SdkSteerOutcome>;
+} | {
+    accepted: false;
+    disposition: "rejected";
+    reason: "unknown_session" | "session_deleted" | "ownership_conflict";
+};
+export interface SdkSessionEvent {
+    sequence: number;
+    sessionId: string;
+    turnId: string;
+    event: AgentEvent;
+    /**
+     * 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 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. */
+    eventsFrom(afterSequence: number): AsyncIterable<SdkSessionEvent>;
+    send(options: RunTurnOptions): AsyncGenerator<AgentEvent>;
+    steer(content: string): SdkSteerResult;
+    stop(options?: SdkStopOptions): number;
+    close(): void;
+}
+export declare class BubbleSdk {
+    readonly userConfig: UserConfig;
+    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;
+    /** 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;
+    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;
+    /**
+     * Add text to the turn that currently owns the session slot. Every accepted
+     * input exposes an outcome promise, independent of event-stream consumption.
+     */
+    steer(sessionId: string, content: string): SdkSteerResult;
+    enqueueTurn(sessionId: string, options: RunTurnOptions): AsyncGenerator<AgentEvent>;
+    queueTurn(sessionId: string, options: RunTurnOptions): AsyncGenerator<AgentEvent>;
+    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;
+        defaultModel: string;
+        providers: Array<{
+            id: string;
+            baseURL?: string;
+            hasApiKey: boolean;
+        }>;
+    };
+    /**
+     * Reserve and start a session turn immediately. Execution is driven by the
+     * SDK's own pump, not by consumption of the returned iterator: the iterator
+     * is a replay subscription, so a host may drop it (or reconnect later via
+     * `openSession`) without stalling or cancelling the turn. Cancel with
+     * `stop()`, the options signal, or `deleteSession()`.
+     */
+    runTurn(sessionId: string, options: RunTurnOptions): AsyncGenerator<AgentEvent>;
+    private startOwnedTurn;
+    private pumpTurn;
+    private runReservedTurn;
+    private runtimesForSession;
+    private settleSteerFromEvent;
+    private handleSteerEvent;
+    private rejectOutstandingSteers;
+    private queuePendingSteer;
+    private queueDetachedInput;
+    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, and restarted only when the
+     * repository's settings get trusted (resolveProjectTrust).
+     */
+    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, at?: Date): 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 { AgentRunInputQueue } from "../agent/input-controller.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 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";
+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, AgentInputController, AgentRunInput, ContentPart, Message, PermissionMode, Provider, ThinkingLevel, TokenUsage, UsageCost, ToolRegistryEntry, ToolResult, ToolUpdate, } from "../types.js";