@bubblebrain-ai/bubble 0.0.1

package/dist/provider-registry.js

@@ -0,0 +1,244 @@
+/**
+ * Multi-provider registry.
+ *
+ * Supports OpenAI-compatible providers with dynamic or static model lists.
+ * Reads provider configuration from models.json first, then falls back to config.json.
+ */
+import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinProvider, listBuiltinModels, } from "./model-catalog.js";
+import { ModelConfig } from "./model-config.js";
+import { AuthStorage } from "./oauth/index.js";
+import { fetchOpenAICodexModels } from "./provider-openai-codex.js";
+import { refreshOpenAICodex } from "./oauth/openai-codex.js";
+export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
+export const USER_VISIBLE_PROVIDER_IDS = BUILTIN_PROVIDERS
+    .filter((provider) => provider.id !== "openrouter" && provider.id !== "openai-codex")
+    .map((provider) => provider.id);
+export function isUserVisibleProvider(providerId) {
+    return USER_VISIBLE_PROVIDER_IDS.includes(providerId);
+}
+export class ProviderRegistry {
+    config;
+    modelConfig;
+    authStorage;
+    constructor(config) {
+        this.config = config;
+        this.modelConfig = new ModelConfig();
+        this.authStorage = new AuthStorage();
+    }
+    getModelConfig() {
+        return this.modelConfig;
+    }
+    getAuthStorage() {
+        return this.authStorage;
+    }
+    supportsOAuth(providerId) {
+        return !!getBuiltinProvider(providerId)?.supportsOAuth;
+    }
+    resolveOAuthAuthKey(providerId) {
+        if (providerId === "openai" && !this.authStorage.has("openai") && this.authStorage.has("openai-codex")) {
+            return "openai-codex";
+        }
+        return providerId;
+    }
+    getDefaultModel(providerId, authType = "api") {
+        const customModels = this.modelConfig.getCustomModels(providerId);
+        if (customModels.length > 0) {
+            return customModels[0].id;
+        }
+        if (providerId === "openai" && authType === "oauth") {
+            return listBuiltinModels("openai-codex")[0]?.id;
+        }
+        return listBuiltinModels(providerId)[0]?.id;
+    }
+    async prepareProvider(providerId) {
+        const authKey = this.resolveOAuthAuthKey(providerId);
+        if (providerId === "openai" && this.authStorage.isExpired(authKey)) {
+            const creds = this.authStorage.get(authKey);
+            if (creds?.refreshToken) {
+                const refreshed = await refreshOpenAICodex(creds.refreshToken);
+                this.authStorage.set("openai", {
+                    type: "oauth",
+                    accessToken: refreshed.accessToken,
+                    refreshToken: refreshed.refreshToken,
+                    expiresAt: refreshed.expiresAt,
+                    idToken: refreshed.idToken,
+                    accountId: refreshed.accountId,
+                });
+            }
+        }
+    }
+    getConfigured() {
+        // 1. Try models.json first
+        const modelsJsonProviders = this.modelConfig.getAllProviders();
+        const keys = Object.keys(modelsJsonProviders);
+        let providers = [];
+        if (keys.length > 0) {
+            providers = keys.map((id) => {
+                const builtin = getBuiltinProvider(id);
+                const cfg = modelsJsonProviders[id];
+                return {
+                    id,
+                    name: builtin?.name || id,
+                    baseURL: cfg.baseURL || builtin?.baseURL || "",
+                    apiKey: cfg.apiKey || "",
+                    enabled: true,
+                    authType: "api",
+                };
+            });
+        }
+        else {
+            // 2. Fall back to config.json providers (interactive TUI style)
+            providers = this.config.getProviders();
+        }
+        // 3. Inject OAuth access tokens
+        for (const p of providers) {
+            const authKey = this.resolveOAuthAuthKey(p.id);
+            if (this.authStorage.has(authKey)) {
+                const token = this.authStorage.getAccessToken(authKey);
+                if (token) {
+                    p.apiKey = token;
+                    p.authType = "oauth";
+                    if (p.id === "openai") {
+                        p.baseURL = "https://chatgpt.com/backend-api";
+                    }
+                }
+            }
+        }
+        // 4. Auto-include built-in OAuth providers that have credentials
+        const configuredIds = new Set(providers.map((p) => p.id));
+        for (const builtin of BUILTIN_PROVIDERS) {
+            if (builtin.id === "openai-codex")
+                continue;
+            if (configuredIds.has(builtin.id))
+                continue;
+            const authKey = this.resolveOAuthAuthKey(builtin.id);
+            if (this.authStorage.has(authKey)) {
+                const token = this.authStorage.getAccessToken(authKey);
+                providers.push({
+                    ...builtin,
+                    apiKey: token || "",
+                    enabled: !!token,
+                    authType: "oauth",
+                    ...(builtin.id === "openai" ? { baseURL: "https://chatgpt.com/backend-api" } : {}),
+                });
+            }
+        }
+        return providers;
+    }
+    getEnabled() {
+        return this.getConfigured().filter((p) => p.enabled && p.apiKey);
+    }
+    getDefault() {
+        const enabled = this.getEnabled();
+        if (enabled.length === 0)
+            return undefined;
+        const defaultId = this.config.getDefaultProvider();
+        const preferred = enabled.filter((provider) => isUserVisibleProvider(provider.id));
+        return preferred.find((p) => p.id === defaultId)
+            || preferred[0]
+            || enabled.find((p) => p.id === defaultId)
+            || enabled[0];
+    }
+    setDefault(id) {
+        this.config.setDefaultProvider(id);
+    }
+    addProvider(id, apiKey) {
+        const builtin = getBuiltinProvider(id);
+        if (!builtin)
+            return false;
+        const providers = this.config.getProviders();
+        const idx = providers.findIndex((p) => p.id === id);
+        const profile = { ...builtin, apiKey, enabled: true };
+        if (idx >= 0) {
+            providers[idx] = profile;
+        }
+        else {
+            providers.push(profile);
+        }
+        this.config.setProviders(providers);
+        return true;
+    }
+    removeProvider(id) {
+        const providers = this.config.getProviders().filter((p) => p.id !== id);
+        this.config.setProviders(providers);
+    }
+    updateProviderKey(id, apiKey) {
+        const providers = this.config.getProviders();
+        const p = providers.find((x) => x.id === id);
+        if (p) {
+            p.apiKey = apiKey;
+            this.config.setProviders(providers);
+        }
+    }
+    async listModels(provider) {
+        // 1. Custom models from models.json always take precedence
+        const customModels = this.modelConfig.getCustomModels(provider.id);
+        if (customModels.length > 0) {
+            return customModels;
+        }
+        // 2. Built-in provider dynamic/static lists
+        if (provider.id === "openrouter") {
+            try {
+                const res = await fetch("https://openrouter.ai/api/v1/models");
+                const data = (await res.json());
+                const models = data.data || [];
+                return models.map((m) => ({
+                    id: m.id,
+                    name: m.name || m.id,
+                    providerId: provider.id,
+                }));
+            }
+            catch {
+                // fall through to static
+            }
+        }
+        if (provider.id === "openai" && provider.authType === "oauth" && provider.apiKey) {
+            try {
+                const models = await fetchOpenAICodexModels({
+                    baseURL: provider.baseURL,
+                    accessToken: provider.apiKey,
+                });
+                if (models.length > 0) {
+                    return models.map((id) => ({ id, name: id, providerId: provider.id }));
+                }
+            }
+            catch {
+                // fall through to static
+            }
+            return listBuiltinModels("openai-codex").map((model) => ({
+                id: model.id,
+                name: model.name,
+                providerId: provider.id,
+            }));
+        }
+        return listBuiltinModels(provider.id).map((model) => ({
+            id: model.id,
+            name: model.name,
+            providerId: provider.id,
+        }));
+    }
+}
+/** Encode a model selection as "providerId:modelId". */
+export function encodeModel(providerId, modelId) {
+    return `${providerId}:${modelId}`;
+}
+/** Decode "providerId:modelId" or legacy plain modelId. */
+export function decodeModel(value) {
+    if (value.includes(":")) {
+        const [providerId, ...rest] = value.split(":");
+        return { providerId, modelId: rest.join(":") };
+    }
+    return { modelId: value };
+}
+/** Strip provider prefix for concise display. */
+export function displayModel(model) {
+    const { modelId } = decodeModel(model);
+    return modelId;
+}
+/** Normalize user input to provider:model format when possible. */
+export function normalizeModel(model, defaultProvider = "openai") {
+    const { providerId, modelId } = decodeModel(model);
+    if (providerId)
+        return model;
+    return encodeModel(defaultProvider, modelId);
+}

package/dist/provider-transform.d.ts

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

package/dist/provider-transform.js

@@ -0,0 +1,69 @@
+import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
+const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
+const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
+export function resolveProviderRequestConfig(providerId, modelId, requestedLevel) {
+    const supportedLevels = getAvailableThinkingLevels(providerId, modelId);
+    const effectiveThinkingLevel = normalizeThinkingLevel(requestedLevel, supportedLevels);
+    // ChatGPT OAuth via openai-codex currently rejects explicit reasoning params for this account path.
+    // Keep the session/UI state, but don't send reasoning flags on this provider until the protocol is clearer.
+    if (providerId === "openai-codex") {
+        return { effectiveThinkingLevel };
+    }
+    if (providerId === "deepseek" && (modelId === "deepseek-v4-flash" || modelId === "deepseek-v4-pro")) {
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "all",
+            extraBody: {
+                thinking: { type: "enabled" },
+                reasoning_effort: effectiveThinkingLevel,
+            },
+        };
+    }
+    // Zhipu/Z.AI OpenAI-compatible endpoints expose reasoning via a provider-specific
+    // `thinking` block rather than OpenAI's `reasoning_effort` shape.
+    if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {
+        return {
+            effectiveThinkingLevel,
+            extraBody: effectiveThinkingLevel === "off"
+                ? undefined
+                : {
+                    thinking: {
+                        type: "enabled",
+                        clear_thinking: false,
+                    },
+                },
+        };
+    }
+    // Moonshot / Kimi: kimi-k2.5 family (incl. k2.6-code-preview, kimi-k2.6) locks
+    // temperature/top_p/n/penalties and exposes thinking via extra_body.thinking;
+    // kimi-k2-thinking family locks temperature=1.
+    if (MOONSHOT_PROVIDER_IDS.has(providerId)) {
+        if (KIMI_K25_FAMILY.has(modelId)) {
+            return {
+                effectiveThinkingLevel,
+                omitTemperature: true,
+                reasoningContentEcho: "tool_calls",
+                extraBody: {
+                    thinking: { type: effectiveThinkingLevel === "off" ? "disabled" : "enabled" },
+                },
+            };
+        }
+        if (KIMI_THINKING_FAMILY.has(modelId)) {
+            return { effectiveThinkingLevel, omitTemperature: true };
+        }
+        return { effectiveThinkingLevel };
+    }
+    if (providerId === "openai"
+        || providerId === "openrouter"
+        || providerId === "google"
+        || providerId === "azure"
+        || providerId === "openai-compatible") {
+        return {
+            effectiveThinkingLevel,
+            reasoningEffort: effectiveThinkingLevel === "off" ? undefined : effectiveThinkingLevel,
+        };
+    }
+    return { effectiveThinkingLevel };
+}

package/dist/provider.d.ts

@@ -0,0 +1,31 @@
+/**
+ * OpenAI-compatible Provider implementation.
+ *
+ * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
+ */
+import type { Message, Provider, StreamChunk, ThinkingLevel } from "./types.js";
+type ReasoningContentEcho = "tool_calls" | "all";
+export declare function toChatCompletionsMessage(message: Message, options?: {
+    reasoningContentEcho?: ReasoningContentEcho;
+}): Record<string, unknown>;
+export interface ProviderInstanceOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL: string;
+    /** Requested thinking level */
+    thinkingLevel?: ThinkingLevel;
+}
+export declare function createUnavailableProvider(message: string): Provider;
+export declare function createProviderInstance(options: ProviderInstanceOptions): Provider;
+export declare function normalizeToolArgs(raw: string): string;
+/**
+ * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
+ *
+ * Multi-tool-call streams are buffered by `index` and emitted in index order at
+ * `finish_reason === "tool_calls"`, so the agent layer always sees a clean
+ * (isStart -> args -> isEnd) sequence per call. This matters for providers like
+ * Kimi K2.5 that emit several parallel tool calls per assistant turn -- the
+ * previous single-slot implementation silently dropped every call but the last.
+ */
+export declare function translateOpenAIStream(stream: AsyncIterable<any>): AsyncIterable<StreamChunk>;
+export {};

package/dist/provider.js

@@ -0,0 +1,269 @@
+/**
+ * OpenAI-compatible Provider implementation.
+ *
+ * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
+ */
+import OpenAI from "openai";
+import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
+import { resolveProviderRequestConfig } from "./provider-transform.js";
+export function toChatCompletionsMessage(message, options = {}) {
+    const reasoningContentEcho = options.reasoningContentEcho ?? "tool_calls";
+    if (message.role === "assistant") {
+        const out = {
+            role: "assistant",
+            content: message.content || null,
+        };
+        if (reasoningContentEcho === "all") {
+            // DeepSeek thinking mode requires every assistant message to echo the
+            // provider field, even when the original value is an empty string.
+            out.reasoning_content = message.reasoning ?? "";
+        }
+        if (message.toolCalls && message.toolCalls.length > 0) {
+            out.tool_calls = message.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: tc.arguments || "{}" },
+            }));
+            // Kimi-k2.5 with thinking enabled requires reasoning_content to be echoed
+            // back on assistant messages that carry tool_calls.
+            if (message.reasoning && reasoningContentEcho === "tool_calls") {
+                out.reasoning_content = message.reasoning;
+            }
+        }
+        return out;
+    }
+    if (message.role === "tool") {
+        return { role: "tool", tool_call_id: message.toolCallId, content: message.content };
+    }
+    return { role: message.role, content: message.content };
+}
+export function createUnavailableProvider(message) {
+    async function* streamChat() {
+        throw new Error(message);
+    }
+    async function complete() {
+        throw new Error(message);
+    }
+    return { streamChat, complete };
+}
+export function createProviderInstance(options) {
+    if (isOpenAICodexBaseUrl(options.baseURL)) {
+        return createOpenAICodexProvider({ ...options, providerId: options.providerId || "openai-codex" });
+    }
+    const client = new OpenAI({
+        apiKey: options.apiKey,
+        baseURL: options.baseURL,
+    });
+    const fallbackModel = "gpt-4o";
+    async function* streamChat(messages, chatOptions) {
+        const requestConfig = resolveProviderRequestConfig(options.providerId || "", chatOptions.model, chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off");
+        const tools = chatOptions.tools?.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+        const body = {
+            model: chatOptions.model,
+            messages: messages.map((message) => toChatCompletionsMessage(message, {
+                reasoningContentEcho: requestConfig.reasoningContentEcho ?? "tool_calls",
+            })),
+            tools: tools && tools.length > 0 ? tools : undefined,
+            tool_choice: tools && tools.length > 0 ? "auto" : undefined,
+            stream: true,
+        };
+        // DeepSeek only emits final usage in streaming mode when this flag is set.
+        if (options.providerId === "deepseek") {
+            body.stream_options = { include_usage: true };
+        }
+        if (!requestConfig.omitTemperature) {
+            body.temperature = chatOptions.temperature ?? 0.2;
+        }
+        if (requestConfig.extraBody) {
+            Object.assign(body, requestConfig.extraBody);
+        }
+        if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
+            body.reasoning = { enabled: true };
+        }
+        const stream = (await client.chat.completions.create(body));
+        yield* translateOpenAIStream(stream);
+        yield { type: "done" };
+    }
+    async function complete(messages, chatOptions) {
+        const requestConfig = resolveProviderRequestConfig(options.providerId || "", chatOptions?.model ?? fallbackModel, chatOptions?.thinkingLevel ?? options.thinkingLevel ?? "off");
+        const body = {
+            model: chatOptions?.model ?? fallbackModel,
+            messages: messages.map((message) => toChatCompletionsMessage(message, {
+                reasoningContentEcho: requestConfig.reasoningContentEcho ?? "tool_calls",
+            })),
+        };
+        if (!requestConfig.omitTemperature) {
+            body.temperature = chatOptions?.temperature ?? 0.2;
+        }
+        if (requestConfig.extraBody) {
+            Object.assign(body, requestConfig.extraBody);
+        }
+        if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
+            body.reasoning = { enabled: true };
+        }
+        const response = await client.chat.completions.create(body);
+        return response.choices[0]?.message?.content ?? "";
+    }
+    return { streamChat, complete };
+}
+// Some providers (notably Fireworks-hosted Kimi) stream tool-call arguments
+// as repeated full snapshots in each delta instead of incremental chunks, so
+// a naive `+=` produces `{"x":1}{"x":1}` — not valid JSON. Parse the raw
+// stream; if it doesn't parse but contains a balanced `{…}` prefix or suffix
+// that does, use that. Empty or unsalvageable input becomes `"{}"` so the
+// downstream echo to the model is always valid JSON.
+export function normalizeToolArgs(raw) {
+    const s = (raw ?? "").trim();
+    if (!s)
+        return "{}";
+    try {
+        JSON.parse(s);
+        return s;
+    }
+    catch { }
+    const firstBrace = extractBalancedJson(s, 0);
+    if (firstBrace) {
+        try {
+            JSON.parse(firstBrace);
+        }
+        catch {
+            return "{}";
+        }
+        // If the content after the first balanced object is another valid object
+        // with the same parse, we've got a snapshot duplication — keep one copy.
+        const rest = s.slice(firstBrace.length).trim();
+        if (!rest)
+            return firstBrace;
+        try {
+            JSON.parse(rest);
+            return firstBrace;
+        }
+        catch { }
+        return firstBrace;
+    }
+    return "{}";
+}
+function extractBalancedJson(s, start) {
+    if (s[start] !== "{")
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let escape = false;
+    for (let i = start; i < s.length; i++) {
+        const c = s[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (c === "\\" && inStr) {
+            escape = true;
+            continue;
+        }
+        if (c === '"') {
+            inStr = !inStr;
+            continue;
+        }
+        if (inStr)
+            continue;
+        if (c === "{")
+            depth++;
+        else if (c === "}") {
+            depth--;
+            if (depth === 0)
+                return s.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
+ *
+ * Multi-tool-call streams are buffered by `index` and emitted in index order at
+ * `finish_reason === "tool_calls"`, so the agent layer always sees a clean
+ * (isStart -> args -> isEnd) sequence per call. This matters for providers like
+ * Kimi K2.5 that emit several parallel tool calls per assistant turn -- the
+ * previous single-slot implementation silently dropped every call but the last.
+ */
+export async function* translateOpenAIStream(stream) {
+    const toolCalls = new Map();
+    function* flushToolCalls() {
+        if (toolCalls.size === 0)
+            return;
+        const sorted = [...toolCalls.entries()].sort(([a], [b]) => a - b);
+        for (const [, entry] of sorted) {
+            if (!entry.id || !entry.name)
+                continue;
+            const args = normalizeToolArgs(entry.args);
+            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
+            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: args, isStart: false, isEnd: false };
+            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: false, isEnd: true };
+        }
+        toolCalls.clear();
+    }
+    for await (const chunk of stream) {
+        const delta = chunk.choices?.[0]?.delta;
+        const usage = chunk.usage;
+        if (usage) {
+            yield {
+                type: "usage",
+                usage: {
+                    promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+                    completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+                    promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number" ? usage.prompt_cache_hit_tokens : undefined,
+                    promptCacheMissTokens: typeof usage.prompt_cache_miss_tokens === "number" ? usage.prompt_cache_miss_tokens : undefined,
+                    reasoningTokens: typeof usage.completion_tokens_details?.reasoning_tokens === "number"
+                        ? usage.completion_tokens_details.reasoning_tokens
+                        : undefined,
+                    totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : undefined,
+                },
+            };
+        }
+        const reasoning = delta?.reasoning ?? delta?.thinking ?? delta?.reasoning_content;
+        if (reasoning) {
+            yield { type: "reasoning_delta", content: reasoning };
+        }
+        if (delta?.content) {
+            const thinkMatch = delta.content.match(/<think>([\s\S]*?)<\/think>/);
+            if (thinkMatch) {
+                if (thinkMatch[1]) {
+                    yield { type: "reasoning_delta", content: thinkMatch[1] };
+                }
+                const remaining = delta.content.replace(/<think>[\s\S]*?<\/think>/, "");
+                if (remaining) {
+                    yield { type: "text", content: remaining };
+                }
+            }
+            else {
+                yield { type: "text", content: delta.content };
+            }
+        }
+        if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+                const idx = typeof tc.index === "number" ? tc.index : 0;
+                let entry = toolCalls.get(idx);
+                if (!entry) {
+                    entry = { id: "", name: "", args: "" };
+                    toolCalls.set(idx, entry);
+                }
+                if (tc.id)
+                    entry.id = tc.id;
+                if (tc.function?.name)
+                    entry.name = tc.function.name;
+                if (typeof tc.function?.arguments === "string")
+                    entry.args += tc.function.arguments;
+            }
+        }
+        const finishReason = chunk.choices?.[0]?.finish_reason;
+        if (finishReason === "tool_calls") {
+            yield* flushToolCalls();
+        }
+    }
+    yield* flushToolCalls();
+}

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 };