@bubblebrain-ai/bubble 0.0.1

package/dist/prompt/runtime.d.ts

@@ -0,0 +1,12 @@
+import type { PermissionMode, ThinkingLevel } from "../types.js";
+export interface RuntimePromptOptions {
+    thinkingLevel?: ThinkingLevel;
+    /**
+     * Kept for API compatibility. Agent mode is no longer baked into the static
+     * system prompt — mode changes are signalled via <system-reminder> injections
+     * (see src/prompt/reminders.ts) so the base prompt stays stable for caching.
+     */
+    mode?: PermissionMode;
+    guidelines?: string[];
+}
+export declare function buildRuntimePrompt(options?: RuntimePromptOptions): string;

package/dist/prompt/runtime.js

@@ -0,0 +1,31 @@
+const defaultGuidelines = [
+    "Before editing or writing files, read them first if they exist",
+    "Use edit for targeted changes to existing files; use write for creating new files",
+    "Be concise in your responses",
+    "Show file paths clearly when working with files",
+    "Prefer structured search tools over bash for repository searches whenever possible",
+    "Do not repeat near-identical searches when they are not producing new evidence",
+    "When investigating configuration or security questions, stop once the relevant load path, storage path, and exposure path are identified",
+    "Use the task tool for bounded investigative subproblems instead of letting the main loop churn on repeated exploratory searches",
+];
+export function buildRuntimePrompt(options = {}) {
+    const thinkingLevel = options.thinkingLevel ?? "off";
+    const guidelines = dedupe(defaultGuidelines, options.guidelines ?? []);
+    return `Current thinking level: ${thinkingLevel}
+
+Guidelines:
+${guidelines.map((item) => `- ${item}`).join("\n")}`;
+}
+function dedupe(...groups) {
+    const seen = new Set();
+    const result = [];
+    for (const group of groups) {
+        for (const item of group) {
+            if (!seen.has(item)) {
+                seen.add(item);
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}

package/dist/prompt/skills.d.ts

@@ -0,0 +1,2 @@
+import type { SkillSummary } from "../skills/types.js";
+export declare function buildSkillsPrompt(skills?: SkillSummary[]): string;

package/dist/prompt/skills.js

@@ -0,0 +1,4 @@
+import { formatSkillsPrompt } from "../skills/format.js";
+export function buildSkillsPrompt(skills = []) {
+    return formatSkillsPrompt(skills);
+}

package/dist/provider-openai-codex.d.ts

@@ -0,0 +1,14 @@
+import type { Provider, ThinkingLevel } from "./types.js";
+export declare function isOpenAICodexBaseUrl(baseURL: string): boolean;
+export declare function getOpenAICodexFallbackModels(): string[];
+export declare function extractChatGptAccountId(accessToken: string): string | undefined;
+export declare function createOpenAICodexProvider(options: {
+    providerId?: string;
+    apiKey: string;
+    baseURL: string;
+    thinkingLevel?: ThinkingLevel;
+}): Provider;
+export declare function fetchOpenAICodexModels(options: {
+    baseURL: string;
+    accessToken: string;
+}): Promise<string[]>;

package/dist/provider-openai-codex.js

@@ -0,0 +1,409 @@
+import { listBuiltinModels } from "./model-catalog.js";
+import { resolveProviderRequestConfig } from "./provider-transform.js";
+const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const OPENAI_BETA_RESPONSES = "responses=experimental";
+const CODEX_CLIENT_VERSION = "0.121.0";
+const MODEL_DISCOVERY_PATHS = [
+    `/codex/models?client_version=${CODEX_CLIENT_VERSION}`,
+    "/models",
+];
+export function isOpenAICodexBaseUrl(baseURL) {
+    const normalized = baseURL.trim().replace(/\/+$/, "");
+    return normalized === DEFAULT_CODEX_BASE_URL || normalized.startsWith(`${DEFAULT_CODEX_BASE_URL}/`);
+}
+export function getOpenAICodexFallbackModels() {
+    return listBuiltinModels("openai-codex").map((model) => model.id);
+}
+export function extractChatGptAccountId(accessToken) {
+    try {
+        const parts = accessToken.split(".");
+        if (parts.length !== 3)
+            return undefined;
+        const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
+        const auth = payload["https://api.openai.com/auth"];
+        if (typeof auth?.chatgpt_account_id === "string" && auth.chatgpt_account_id) {
+            return auth.chatgpt_account_id;
+        }
+        if (typeof auth?.account_id === "string" && auth.account_id) {
+            return auth.account_id;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createOpenAICodexProvider(options) {
+    const sessionId = globalThis.crypto?.randomUUID?.() ?? `bubble_${Date.now()}`;
+    async function* streamChat(messages, chatOptions) {
+        const requestConfig = resolveProviderRequestConfig("openai-codex", chatOptions.model, chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off");
+        const accountId = extractChatGptAccountId(options.apiKey);
+        if (!accountId) {
+            throw new Error("Failed to extract chatgpt_account_id from ChatGPT OAuth token.");
+        }
+        const response = await fetch(resolveCodexUrl(options.baseURL), {
+            method: "POST",
+            headers: buildSseHeaders(options.apiKey, accountId, sessionId),
+            body: JSON.stringify(buildRequestBody(messages, {
+                model: chatOptions.model,
+                tools: chatOptions.tools,
+                reasoningEffort: requestConfig.reasoningEffort,
+                sessionId,
+            })),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            throw new Error(`${response.status} status code${errorText ? `: ${errorText}` : " (no body)"}`);
+        }
+        let currentToolCall;
+        for await (const event of parseSse(response)) {
+            const type = typeof event.type === "string" ? event.type : undefined;
+            if (!type)
+                continue;
+            if (type === "error") {
+                const message = typeof event.message === "string" ? event.message : JSON.stringify(event);
+                throw new Error(message);
+            }
+            if (type === "response.failed") {
+                const message = typeof event.response?.error?.message === "string"
+                    ? event.response.error.message
+                    : "Codex response failed";
+                throw new Error(message);
+            }
+            if (type === "response.output_item.added") {
+                const item = event.item;
+                if (item?.type === "function_call" && typeof item.call_id === "string" && typeof item.name === "string") {
+                    currentToolCall = {
+                        id: item.call_id,
+                        name: item.name,
+                        args: typeof item.arguments === "string" ? item.arguments : "",
+                        started: true,
+                    };
+                    yield {
+                        type: "tool_call",
+                        id: currentToolCall.id,
+                        name: currentToolCall.name,
+                        arguments: "",
+                        isStart: true,
+                        isEnd: false,
+                    };
+                }
+                continue;
+            }
+            if (type === "response.output_text.delta" || type === "response.refusal.delta") {
+                const delta = typeof event.delta === "string" ? event.delta : "";
+                if (delta) {
+                    yield { type: "text", content: delta };
+                }
+                continue;
+            }
+            if (type === "response.reasoning_summary_text.delta") {
+                const delta = typeof event.delta === "string" ? event.delta : "";
+                if (delta) {
+                    yield { type: "reasoning_delta", content: delta };
+                }
+                continue;
+            }
+            if (type === "response.function_call_arguments.delta" && currentToolCall) {
+                const delta = typeof event.delta === "string" ? event.delta : "";
+                if (delta) {
+                    currentToolCall.args += delta;
+                    yield {
+                        type: "tool_call",
+                        id: currentToolCall.id,
+                        name: currentToolCall.name,
+                        arguments: delta,
+                        isStart: false,
+                        isEnd: false,
+                    };
+                }
+                continue;
+            }
+            if (type === "response.function_call_arguments.done" && currentToolCall) {
+                const finalArgs = typeof event.arguments === "string" ? event.arguments : currentToolCall.args;
+                if (finalArgs.startsWith(currentToolCall.args)) {
+                    const tail = finalArgs.slice(currentToolCall.args.length);
+                    if (tail) {
+                        currentToolCall.args = finalArgs;
+                        yield {
+                            type: "tool_call",
+                            id: currentToolCall.id,
+                            name: currentToolCall.name,
+                            arguments: tail,
+                            isStart: false,
+                            isEnd: false,
+                        };
+                    }
+                }
+                else {
+                    currentToolCall.args = finalArgs;
+                }
+                continue;
+            }
+            if (type === "response.output_item.done" && currentToolCall) {
+                const item = event.item;
+                if (item?.type === "function_call" && item.call_id === currentToolCall.id) {
+                    yield {
+                        type: "tool_call",
+                        id: currentToolCall.id,
+                        name: currentToolCall.name,
+                        arguments: "",
+                        isStart: false,
+                        isEnd: true,
+                    };
+                    currentToolCall = undefined;
+                }
+                continue;
+            }
+            if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+                const usage = event.response?.usage;
+                if (usage) {
+                    yield {
+                        type: "usage",
+                        usage: {
+                            promptTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+                            completionTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
+                            reasoningTokens: typeof usage.output_tokens_details?.reasoning_tokens === "number"
+                                ? usage.output_tokens_details.reasoning_tokens
+                                : undefined,
+                            totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : undefined,
+                        },
+                    };
+                }
+                continue;
+            }
+        }
+        yield { type: "done" };
+    }
+    async function complete(messages, chatOptions) {
+        let content = "";
+        for await (const chunk of streamChat(messages, {
+            model: chatOptions?.model ?? "gpt-5.4",
+            temperature: chatOptions?.temperature,
+            thinkingLevel: chatOptions?.thinkingLevel,
+        })) {
+            if (chunk.type === "text") {
+                content += chunk.content;
+            }
+        }
+        return content;
+    }
+    return { streamChat, complete };
+}
+export async function fetchOpenAICodexModels(options) {
+    const accountId = extractChatGptAccountId(options.accessToken);
+    if (!accountId) {
+        return [];
+    }
+    for (const path of MODEL_DISCOVERY_PATHS) {
+        const response = await fetch(resolveRelativeUrl(options.baseURL, path), {
+            method: "GET",
+            headers: buildBaseHeaders(options.accessToken, accountId, globalThis.crypto?.randomUUID?.() ?? `bubble_${Date.now()}`, { accept: "application/json" }),
+        }).catch(() => undefined);
+        if (!response?.ok)
+            continue;
+        const payload = await response.json().catch(() => undefined);
+        const ids = extractModelIds(payload);
+        if (ids.length > 0) {
+            return sortCodexModelIds(ids);
+        }
+    }
+    return [];
+}
+function buildRequestBody(messages, options) {
+    const instructions = messages
+        .filter((message) => message.role === "system")
+        .map((message) => message.content)
+        .join("\n\n");
+    const input = messages.flatMap((message) => convertMessage(message));
+    const body = {
+        model: options.model,
+        store: false,
+        stream: true,
+        instructions: instructions || undefined,
+        input,
+        include: ["reasoning.encrypted_content"],
+        prompt_cache_key: options.sessionId,
+        tool_choice: "auto",
+        parallel_tool_calls: true,
+        text: { verbosity: "medium" },
+    };
+    if (options.tools && options.tools.length > 0) {
+        body.tools = options.tools.map((tool) => ({
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+    }
+    return body;
+}
+function convertMessage(message) {
+    if (message.role === "system") {
+        return [];
+    }
+    if (message.role === "user") {
+        if (typeof message.content === "string") {
+            return [{
+                    role: "user",
+                    content: [{ type: "input_text", text: message.content }],
+                }];
+        }
+        return [{
+                role: "user",
+                content: message.content.map((part) => {
+                    if (part.type === "text") {
+                        return { type: "input_text", text: part.text };
+                    }
+                    return { type: "input_image", detail: "auto", image_url: part.image_url.url };
+                }),
+            }];
+    }
+    if (message.role === "assistant") {
+        const items = [];
+        if (message.content) {
+            items.push({
+                type: "message",
+                role: "assistant",
+                status: "completed",
+                content: [{ type: "output_text", text: message.content, annotations: [] }],
+            });
+        }
+        if (message.toolCalls) {
+            for (const toolCall of message.toolCalls) {
+                items.push({
+                    type: "function_call",
+                    call_id: toolCall.id,
+                    name: toolCall.name,
+                    arguments: toolCall.arguments || "{}",
+                });
+            }
+        }
+        return items;
+    }
+    return [{
+            type: "function_call_output",
+            call_id: message.toolCallId,
+            output: message.content,
+        }];
+}
+async function* parseSse(response) {
+    if (!response.body)
+        return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let boundary = buffer.indexOf("\n\n");
+            while (boundary >= 0) {
+                const chunk = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = chunk
+                    .split("\n")
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice(5).trim())
+                    .join("\n")
+                    .trim();
+                if (data && data !== "[DONE]") {
+                    try {
+                        yield JSON.parse(data);
+                    }
+                    catch {
+                        // Ignore malformed events.
+                    }
+                }
+                boundary = buffer.indexOf("\n\n");
+            }
+        }
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Ignore cleanup errors.
+        }
+    }
+}
+function buildBaseHeaders(accessToken, accountId, sessionId, extraHeaders) {
+    const headers = new Headers(extraHeaders);
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    headers.set("ChatGPT-Account-Id", accountId);
+    headers.set("originator", "bubble");
+    headers.set("User-Agent", "bubble");
+    headers.set("session_id", sessionId);
+    return headers;
+}
+function buildSseHeaders(accessToken, accountId, sessionId) {
+    const headers = buildBaseHeaders(accessToken, accountId, sessionId, {
+        accept: "text/event-stream",
+        "content-type": "application/json",
+    });
+    headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES);
+    return headers;
+}
+function resolveCodexUrl(baseURL) {
+    const normalized = (baseURL.trim() || DEFAULT_CODEX_BASE_URL).replace(/\/+$/, "");
+    if (normalized.endsWith("/codex/responses"))
+        return normalized;
+    if (normalized.endsWith("/codex"))
+        return `${normalized}/responses`;
+    return `${normalized}/codex/responses`;
+}
+function resolveRelativeUrl(baseURL, path) {
+    const normalized = (baseURL.trim() || DEFAULT_CODEX_BASE_URL).replace(/\/+$/, "");
+    return `${normalized}${path}`;
+}
+function extractModelIds(payload) {
+    const ids = [];
+    const seen = new Set();
+    const maybeAdd = (value) => {
+        if (typeof value !== "string")
+            return;
+        if (!/^gpt-|^codex-/i.test(value))
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        ids.push(value);
+    };
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (!value || typeof value !== "object") {
+            maybeAdd(value);
+            return;
+        }
+        const record = value;
+        maybeAdd(record.id);
+        maybeAdd(record.slug);
+        maybeAdd(record.model);
+        maybeAdd(record.model_slug);
+        for (const child of Object.values(record)) {
+            if (child !== record.id && child !== record.slug && child !== record.model && child !== record.model_slug) {
+                visit(child);
+            }
+        }
+    };
+    visit(payload);
+    return ids;
+}
+function sortCodexModelIds(ids) {
+    const preferredModels = getOpenAICodexFallbackModels();
+    const preferred = new Map(preferredModels.map((id, index) => [id, index]));
+    return [...ids].sort((left, right) => {
+        const leftRank = preferred.get(left) ?? Number.MAX_SAFE_INTEGER;
+        const rightRank = preferred.get(right) ?? Number.MAX_SAFE_INTEGER;
+        if (leftRank !== rightRank)
+            return leftRank - rightRank;
+        return left.localeCompare(right);
+    });
+}

package/dist/provider-registry.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 type { UserConfig } from "./config.js";
+import { ModelConfig } from "./model-config.js";
+import { AuthStorage } from "./oauth/index.js";
+export interface ProviderProfile {
+    id: string;
+    name: string;
+    baseURL: string;
+    apiKey: string;
+    enabled: boolean;
+    authType?: "api" | "oauth";
+}
+export interface ModelInfo {
+    id: string;
+    name: string;
+    providerId: string;
+}
+export declare const BUILTIN_PROVIDERS: import("./model-catalog.js").BuiltinProviderDefinition[];
+export declare const USER_VISIBLE_PROVIDER_IDS: string[];
+export declare function isUserVisibleProvider(providerId: string): boolean;
+export declare class ProviderRegistry {
+    private config;
+    private modelConfig;
+    private authStorage;
+    constructor(config: UserConfig);
+    getModelConfig(): ModelConfig;
+    getAuthStorage(): AuthStorage;
+    supportsOAuth(providerId: string): boolean;
+    private resolveOAuthAuthKey;
+    getDefaultModel(providerId: string, authType?: ProviderProfile["authType"]): string | undefined;
+    prepareProvider(providerId: string): Promise<void>;
+    getConfigured(): ProviderProfile[];
+    getEnabled(): ProviderProfile[];
+    getDefault(): ProviderProfile | undefined;
+    setDefault(id: string): void;
+    addProvider(id: string, apiKey: string): boolean;
+    removeProvider(id: string): void;
+    updateProviderKey(id: string, apiKey: string): void;
+    listModels(provider: ProviderProfile): Promise<ModelInfo[]>;
+}
+/** Encode a model selection as "providerId:modelId". */
+export declare function encodeModel(providerId: string, modelId: string): string;
+/** Decode "providerId:modelId" or legacy plain modelId. */
+export declare function decodeModel(value: string): {
+    providerId?: string;
+    modelId: string;
+};
+/** Strip provider prefix for concise display. */
+export declare function displayModel(model: string): string;
+/** Normalize user input to provider:model format when possible. */
+export declare function normalizeModel(model: string, defaultProvider?: string): string;