@eliotstocker/open-harness-plugin-openai-compatible-auto 0.0.0-development

package/dist/index.js

@@ -0,0 +1,376 @@
+import { Integration, Model, Plugin, Provider } from "@opencode/plugin";
+import { refreshLiteLLMTokens, startLiteLLMInteractive } from "./core/auth.js";
+import { fetchDiscoveredModels, fetchGatewayUserInfo, rootURL, v1URL, } from "./core/discovery.js";
+const PLUGIN_ID = "openai-auto";
+const INTEGRATION_ID = "openai-auto";
+const LITELLM_METHOD_ID = "litellm-cli";
+const OPENAI_COMPAT_PKG = "@opencode/ai/providers/openai-compatible";
+const REFRESH_TTL_MS = 5 * 60 * 1000;
+const ALLOWED_INPUTS = new Set(["text", "image", "audio", "video", "pdf"]);
+const COMPATIBLE_PACKAGES = new Set([
+    OPENAI_COMPAT_PKG,
+    "@opencode/ai/providers/openai-compatible/responses",
+    "@ai-sdk/openai-compatible",
+]);
+function asRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function readStr(v) {
+    return typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined;
+}
+function readHeaders(v) {
+    const out = {};
+    for (const [k, val] of Object.entries(asRecord(v))) {
+        if (typeof val === "string")
+            out[k] = val;
+    }
+    return out;
+}
+function withAppHeader(headers) {
+    const hasApp = Object.keys(headers).some((k) => k.toLowerCase() === "x-prov-application");
+    return hasApp ? headers : { "X-Prov-Application": "opencode", ...headers };
+}
+function formatUserBadge(baseName, user) {
+    if (!user?.email)
+        return baseName;
+    const spend = user.effectiveSpendUsd !== undefined && user.monthlyCapUsd !== undefined
+        ? ` · $${user.effectiveSpendUsd.toFixed(2)}/$${user.monthlyCapUsd.toFixed(0)}`
+        : "";
+    return `${baseName} (${user.email}${spend})`;
+}
+function toOAuth(methodID, token) {
+    return {
+        type: "oauth",
+        methodID: Integration.MethodID.make(methodID),
+        access: token.access,
+        refresh: token.refresh,
+        expires: token.expires,
+        metadata: token.metadata,
+    };
+}
+async function authorizeOpenCode(baseURL, methodID, meta) {
+    const session = await startLiteLLMInteractive(baseURL, { ...meta, clientName: "opencode" });
+    if (session.mode === "auto") {
+        const callback = session.waitForToken().then((tok) => toOAuth(methodID, tok));
+        callback.catch(() => { });
+        return {
+            mode: "auto",
+            url: session.url,
+            instructions: session.instructions,
+            expiresAt: session.expiresAt,
+            callback,
+        };
+    }
+    return {
+        mode: "code",
+        url: session.url,
+        instructions: session.instructions,
+        callback: async (code) => toOAuth(methodID, await session.exchangeCode(code)),
+    };
+}
+async function discoverOpenCodeModels(providerID, baseURL, apiKey, extraHeaders) {
+    const [discovered, userInfo] = await Promise.all([
+        fetchDiscoveredModels(baseURL, apiKey, extraHeaders),
+        fetchGatewayUserInfo(baseURL, apiKey, extraHeaders),
+    ]);
+    const pid = Provider.ID.make(providerID);
+    const models = discovered.map((m) => {
+        const defaults = Model.Info.default(pid, Model.ID.make(m.id));
+        const input = (m.inputModalities ?? ["text"]).filter((x) => ALLOWED_INPUTS.has(x));
+        const variants = m.reasoningEfforts?.map((effort) => ({
+            id: Model.VariantID.make(effort),
+            body: { reasoning_effort: effort },
+        })) ?? [];
+        return {
+            ...defaults,
+            name: m.name,
+            limit: {
+                context: m.contextWindow ?? defaults.limit.context,
+                output: m.maxTokens ?? defaults.limit.output,
+            },
+            capabilities: {
+                ...defaults.capabilities,
+                tools: m.supportsTools ?? defaults.capabilities.tools,
+                input: input.length > 0 ? input : defaults.capabilities.input,
+            },
+            ...(m.cost
+                ? {
+                    cost: [
+                        {
+                            input: m.cost.input,
+                            output: m.cost.output,
+                            cache: {
+                                read: m.cost.cacheRead,
+                                write: m.cost.cacheWrite,
+                            },
+                        },
+                    ],
+                }
+                : {}),
+            ...(m.reasoning
+                ? {
+                    compatibility: {
+                        reasoningField: "reasoning_content",
+                        ...(m.reasoningEfforts?.length ? { supportsEffortUpdates: true } : {}),
+                    },
+                }
+                : {}),
+            ...(variants.length > 0 ? { variants } : {}),
+        };
+    });
+    return { models, userInfo };
+}
+function credentialKey(cred) {
+    if (cred?.type === "key")
+        return cred.key;
+    if (cred?.type === "oauth" && cred.methodID === LITELLM_METHOD_ID)
+        return cred.access;
+    return undefined;
+}
+async function readConnection(ctx, integrationID = INTEGRATION_ID) {
+    try {
+        const active = await ctx.integration.connection.active(integrationID);
+        if (!active)
+            return undefined;
+        const cred = await ctx.integration.connection.resolve(active);
+        const apiKey = credentialKey(cred);
+        if (!cred || !apiKey)
+            return undefined;
+        const answers = asRecord(cred.metadata);
+        return {
+            apiKey,
+            baseURL: readStr(answers.baseURL),
+            providerID: readStr(answers.providerID),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTargetProvider(p, options) {
+    const settings = asRecord(p.settings);
+    if (settings.autoModels === false)
+        return false;
+    if (p.id === readStr(options.providerID) || p.id === PLUGIN_ID)
+        return true;
+    return COMPATIBLE_PACKAGES.has(p.package) && typeof settings.baseURL === "string";
+}
+export default Plugin.define({
+    id: PLUGIN_ID,
+    async setup(ctx) {
+        if (!ctx.provider)
+            return;
+        const opts = asRecord(ctx.options);
+        const sources = new Map();
+        await ctx.integration.transform((editor) => {
+            editor.update(INTEGRATION_ID, (i) => {
+                i.name = "OpenAI-Compatible (Auto)";
+            });
+            editor.method.update({
+                integrationID: INTEGRATION_ID,
+                method: {
+                    type: "key",
+                    label: "API Key",
+                    form: [
+                        {
+                            key: "baseURL",
+                            type: "string",
+                            format: "uri",
+                            title: "Base URL",
+                            description: "OpenAI-compatible endpoint URL (e.g. https://llm.example.com/v1)",
+                            placeholder: "https://llm.example.com/v1",
+                        },
+                        {
+                            key: "providerID",
+                            type: "string",
+                            title: "Provider ID",
+                            default: PLUGIN_ID,
+                        },
+                    ],
+                },
+            });
+            editor.method.update({
+                integrationID: INTEGRATION_ID,
+                method: {
+                    id: LITELLM_METHOD_ID,
+                    type: "oauth",
+                    label: "LiteLLM CLI Code Flow (Browser)",
+                    form: [
+                        {
+                            key: "baseURL",
+                            type: "string",
+                            format: "uri",
+                            title: "Base URL",
+                            description: "LiteLLM proxy URL (leave empty to use configured provider URL or LITELLM_BASE_URL)",
+                            placeholder: "https://llm.example.com",
+                        },
+                        {
+                            key: "providerID",
+                            type: "string",
+                            title: "Provider ID",
+                            default: PLUGIN_ID,
+                        },
+                        {
+                            key: "team",
+                            type: "string",
+                            title: "Team (optional)",
+                        },
+                    ],
+                },
+                authorize: async (answer) => {
+                    const providerID = readStr(answer.providerID) ?? readStr(opts.providerID) ?? PLUGIN_ID;
+                    const providers = (await ctx.provider.list()).data;
+                    const target = providers.find((p) => p.id === providerID);
+                    const targetSettings = asRecord(target?.settings);
+                    const baseURL = readStr(answer.baseURL) ??
+                        readStr(targetSettings.baseURL) ??
+                        readStr(opts.baseURL) ??
+                        readStr(process.env.LITELLM_BASE_URL);
+                    if (!baseURL) {
+                        throw new Error("Enter a Base URL or configure providers.<id>.settings.baseURL");
+                    }
+                    const headers = withAppHeader({ ...readHeaders(opts.headers), ...readHeaders(target?.headers) });
+                    return authorizeOpenCode(baseURL, LITELLM_METHOD_ID, {
+                        providerID,
+                        team: readStr(answer.team),
+                        headers,
+                    });
+                },
+                refresh: async (cred) => {
+                    const tok = await refreshLiteLLMTokens(cred, withAppHeader(readHeaders(opts.headers)));
+                    return { ...cred, ...tok };
+                },
+            });
+        });
+        const syncSources = async (force = false) => {
+            let changed = false;
+            const conn = await readConnection(ctx);
+            const list = (await ctx.provider.list().catch(() => ({ data: [] }))).data;
+            const candidates = list.filter((p) => isTargetProvider(p, opts));
+            for (const p of candidates) {
+                const settings = asRecord(p.settings);
+                const connMatch = conn && (!conn.providerID || conn.providerID === p.id) ? conn : undefined;
+                const baseURL = readStr(settings.baseURL) ?? connMatch?.baseURL ?? readStr(opts.baseURL);
+                if (!baseURL)
+                    continue;
+                const apiKey = readStr(settings.apiKey) ?? connMatch?.apiKey ?? readStr(opts.apiKey);
+                const headers = withAppHeader({ ...readHeaders(opts.headers), ...readHeaders(p.headers) });
+                const existing = sources.get(p.id);
+                if (!force && existing && Date.now() - existing.lastFetchedAt < REFRESH_TTL_MS && existing.baseURL === rootURL(baseURL) && existing.apiKey === apiKey) {
+                    continue;
+                }
+                try {
+                    const { models, userInfo } = await discoverOpenCodeModels(p.id, baseURL, apiKey, headers);
+                    sources.set(p.id, {
+                        id: p.id,
+                        name: p.name || p.id,
+                        baseURL: rootURL(baseURL),
+                        apiKey,
+                        headers,
+                        pkg: p.package || OPENAI_COMPAT_PKG,
+                        fromConfig: true,
+                        usesConnection: !readStr(settings.apiKey) && Boolean(connMatch?.apiKey),
+                        models,
+                        userInfo,
+                        ownedIds: existing?.ownedIds ?? new Set(),
+                        lastFetchedAt: Date.now(),
+                    });
+                    changed = true;
+                }
+                catch (err) {
+                    console.warn(`[${PLUGIN_ID}] Model discovery failed for "${p.id}": ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            const fallbackURL = conn?.baseURL ?? readStr(opts.baseURL) ?? readStr(process.env.LITELLM_BASE_URL);
+            const fallbackID = conn?.providerID ?? readStr(opts.providerID) ?? PLUGIN_ID;
+            if (fallbackURL && !candidates.some((p) => p.id === fallbackID)) {
+                const apiKey = conn?.apiKey ?? readStr(opts.apiKey) ?? readStr(process.env.LITELLM_API_KEY);
+                const headers = withAppHeader(readHeaders(opts.headers));
+                const existing = sources.get(fallbackID);
+                if (force || !existing || Date.now() - existing.lastFetchedAt >= REFRESH_TTL_MS || existing.apiKey !== apiKey || existing.baseURL !== rootURL(fallbackURL)) {
+                    try {
+                        const { models, userInfo } = await discoverOpenCodeModels(fallbackID, fallbackURL, apiKey, headers);
+                        sources.set(fallbackID, {
+                            id: fallbackID,
+                            name: formatUserBadge("OpenAI-Compatible (Auto)", userInfo),
+                            baseURL: rootURL(fallbackURL),
+                            apiKey,
+                            headers,
+                            pkg: OPENAI_COMPAT_PKG,
+                            fromConfig: false,
+                            usesConnection: Boolean(conn?.apiKey),
+                            models,
+                            userInfo,
+                            ownedIds: existing?.ownedIds ?? new Set(),
+                            lastFetchedAt: Date.now(),
+                        });
+                        changed = true;
+                    }
+                    catch (err) {
+                        console.warn(`[${PLUGIN_ID}] Model discovery failed for "${fallbackID}": ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            return changed;
+        };
+        await syncSources(true);
+        await ctx.provider.transform((editor) => {
+            for (const src of sources.values()) {
+                const current = editor.get(src.id);
+                if (current) {
+                    editor.update(src.id, (p) => {
+                        if (!p.package)
+                            p.package = src.pkg;
+                        if (src.usesConnection)
+                            p.integrationID = Integration.ID.make(INTEGRATION_ID);
+                        p.headers = withAppHeader({ ...p.headers, ...src.headers });
+                        const settings = { ...(p.settings ?? {}), baseURL: v1URL(src.baseURL) };
+                        if (src.usesConnection)
+                            delete settings.apiKey;
+                        p.settings = settings;
+                    });
+                    const discoveredIds = new Set(src.models.map((m) => m.id));
+                    const kept = [...current.models.values()].filter((m) => !src.ownedIds.has(m.id) || discoveredIds.has(m.id));
+                    const existingIds = new Set(kept.map((m) => m.id));
+                    const added = src.models.filter((m) => !existingIds.has(m.id));
+                    src.ownedIds = new Set([...src.ownedIds].filter((id) => discoveredIds.has(id)).concat(added.map((m) => String(m.id))));
+                    editor.models.set(src.id, [...kept, ...added]);
+                }
+                else {
+                    src.ownedIds = new Set(src.models.map((m) => m.id));
+                    editor.add({
+                        info: {
+                            ...Provider.Info.empty(Provider.ID.make(src.id)),
+                            name: src.name,
+                            activation: "enabled",
+                            package: src.pkg,
+                            settings: {
+                                baseURL: v1URL(src.baseURL),
+                                ...(!src.usesConnection && src.apiKey ? { apiKey: src.apiKey } : {}),
+                            },
+                            headers: src.headers,
+                            ...(src.usesConnection ? { integrationID: Integration.ID.make(INTEGRATION_ID) } : {}),
+                        },
+                        models: src.models,
+                    });
+                }
+            }
+        });
+        const controller = new AbortController();
+        void (async () => {
+            for await (const event of ctx.event.subscribe({
+                types: ["provider.updated", "credential.switched", "session.created"],
+                signal: controller.signal,
+            })) {
+                // Only force-bypass the TTL cache on credential switches; provider.updated is emitted by our own reload().
+                const force = event.type === "credential.switched";
+                if (await syncSources(force)) {
+                    await ctx.provider.reload().catch((err) => {
+                        console.warn(`[${PLUGIN_ID}] provider.reload failed:`, err);
+                    });
+                }
+            }
+        })().catch(() => { });
+        return () => controller.abort();
+    },
+});

package/dist/pi.d.ts

@@ -0,0 +1,8 @@
+import { type Provider } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type GatewayUserInfo } from "./core/discovery.js";
+export declare function createOpenAIAutoPiProvider(): {
+    provider: Provider<"openai-completions">;
+    getUserInfo: () => GatewayUserInfo | undefined;
+};
+export default function openaiAutoPiExtension(pi: ExtensionAPI): void;

package/dist/pi.js

@@ -0,0 +1,272 @@
+import { isModelType, } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { refreshLiteLLMTokens, runLiteLLMLogin } from "./core/auth.js";
+import { fetchDiscoveredModels, fetchGatewayUserInfo, rootURL, v1URL, } from "./core/discovery.js";
+const PROVIDER_ID = "openai-auto";
+const PROVIDER_NAME = "OpenAI-Compatible (Auto)";
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+const APP_HEADERS = { "X-Prov-Application": "pi" };
+function asRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function readStr(v) {
+    return typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined;
+}
+function oauthBaseURL(cred) {
+    const rec = asRecord(cred);
+    const meta = asRecord(rec.metadata);
+    return (readStr(rec.baseURL) ??
+        readStr(meta.baseURL) ??
+        readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+        readStr(process.env.LITELLM_BASE_URL));
+}
+function buildThinkingLevelMap(efforts) {
+    if (!efforts || efforts.length === 0)
+        return undefined;
+    const set = new Set(efforts.map((e) => e.toLowerCase()));
+    const map = {};
+    const pick = (preferred) => preferred.find((p) => set.has(p)) ?? null;
+    map.minimal = pick(["minimal", "low"]);
+    map.low = pick(["low", "minimal", "medium", "high"]);
+    map.medium = pick(["medium", "high", "low"]);
+    map.high = pick(["high", "medium"]);
+    map.xhigh = pick(["max", "xhigh", "high"]);
+    return map;
+}
+function toPiModel(m, baseUrl) {
+    const reasoning = m.reasoning ?? false;
+    const thinkingLevelMap = reasoning ? buildThinkingLevelMap(m.reasoningEfforts) : undefined;
+    const supportsEffort = Boolean(m.reasoningEfforts && m.reasoningEfforts.length > 0);
+    return {
+        id: m.id,
+        name: m.name,
+        api: "openai-completions",
+        provider: PROVIDER_ID,
+        baseUrl: v1URL(baseUrl),
+        reasoning,
+        ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+        input: m.supportsVision ? ["text", "image"] : ["text"],
+        cost: m.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: m.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+        maxTokens: m.maxTokens ?? DEFAULT_MAX_TOKENS,
+        compat: {
+            supportsStore: false,
+            supportsUsageInStreaming: true,
+            supportsReasoningEffort: reasoning && supportsEffort,
+        },
+    };
+}
+async function resolveFromCredential(credential, fallbackBaseUrl) {
+    if (credential?.type === "oauth") {
+        const base = oauthBaseURL(credential) ?? fallbackBaseUrl;
+        return { baseUrl: base ? v1URL(base) : undefined, apiKey: credential.access };
+    }
+    if (credential?.type === "api_key") {
+        const base = readStr(credential.env?.OPENAI_AUTO_BASE_URL) ??
+            readStr(credential.env?.LITELLM_BASE_URL) ??
+            fallbackBaseUrl ??
+            readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+            readStr(process.env.LITELLM_BASE_URL);
+        const apiKey = readStr(credential.key) ??
+            readStr(process.env.OPENAI_AUTO_API_KEY) ??
+            readStr(process.env.LITELLM_API_KEY);
+        return { baseUrl: base ? v1URL(base) : undefined, apiKey };
+    }
+    const base = fallbackBaseUrl ??
+        readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+        readStr(process.env.LITELLM_BASE_URL);
+    const apiKey = readStr(process.env.OPENAI_AUTO_API_KEY) ?? readStr(process.env.LITELLM_API_KEY);
+    return { baseUrl: base ? v1URL(base) : undefined, apiKey };
+}
+export function createOpenAIAutoPiProvider() {
+    let models = [];
+    let lastUserInfo;
+    const completionsApi = () => openAICompletionsApi();
+    const oauth = {
+        name: "LiteLLM CLI Code Flow (Browser)",
+        loginLabel: "LiteLLM CLI Code Flow (Browser)",
+        login: async (interaction) => {
+            const placeholder = readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+                readStr(process.env.LITELLM_BASE_URL) ??
+                "https://llm.example.com";
+            const enteredUrl = await interaction.prompt({
+                type: "text",
+                message: "LiteLLM proxy URL",
+                placeholder,
+            });
+            const baseURL = readStr(enteredUrl) ??
+                readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+                readStr(process.env.LITELLM_BASE_URL);
+            if (!baseURL) {
+                throw new Error("Base URL is required");
+            }
+            const team = readStr(await interaction.prompt({
+                type: "text",
+                message: "Team (optional)",
+                placeholder: "Leave blank if not required",
+            }));
+            const tok = await runLiteLLMLogin(baseURL, { providerID: PROVIDER_ID, team, headers: APP_HEADERS, clientName: "pi" }, {
+                signal: interaction.signal,
+                onAuth: (url, instructions) => {
+                    interaction.notify({ type: "auth_url", url, instructions });
+                },
+                onPrompt: (message, p) => interaction.prompt({ type: "manual_code", message, placeholder: p }),
+            });
+            lastUserInfo = await fetchGatewayUserInfo(baseURL, tok.access, APP_HEADERS, interaction.signal);
+            return {
+                type: "oauth",
+                access: tok.access,
+                refresh: tok.refresh,
+                expires: tok.expires,
+                baseURL: rootURL(baseURL),
+                metadata: { ...tok.metadata, ...(lastUserInfo?.email ? { userEmail: lastUserInfo.email } : {}) },
+            };
+        },
+        refresh: async (credential, signal) => {
+            const tok = await refreshLiteLLMTokens({
+                access: credential.access,
+                refresh: credential.refresh,
+                expires: credential.expires,
+                metadata: asRecord(credential.metadata),
+            }, APP_HEADERS, signal);
+            return {
+                ...credential,
+                ...tok,
+                type: "oauth",
+            };
+        },
+        toAuth: async (credential) => {
+            const baseURL = oauthBaseURL(credential);
+            return {
+                apiKey: credential.access,
+                headers: APP_HEADERS,
+                ...(baseURL ? { baseUrl: v1URL(baseURL) } : {}),
+            };
+        },
+    };
+    const apiKey = {
+        name: "OpenAI-Compatible API Key",
+        login: async (interaction) => {
+            const placeholder = readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+                readStr(process.env.LITELLM_BASE_URL) ??
+                "https://llm.example.com/v1";
+            const enteredUrl = await interaction.prompt({
+                type: "text",
+                message: "OpenAI-compatible Base URL",
+                placeholder,
+            });
+            const baseURL = readStr(enteredUrl) ??
+                readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+                readStr(process.env.LITELLM_BASE_URL);
+            if (!baseURL) {
+                throw new Error("Base URL is required");
+            }
+            const enteredKey = await interaction.prompt({
+                type: "secret",
+                message: "API key (optional for local endpoints)",
+                placeholder: "sk-...",
+            });
+            const key = readStr(enteredKey);
+            await fetchDiscoveredModels(baseURL, key, APP_HEADERS, interaction.signal);
+            lastUserInfo = await fetchGatewayUserInfo(baseURL, key, APP_HEADERS, interaction.signal);
+            return {
+                type: "api_key",
+                ...(key ? { key } : {}),
+                env: { OPENAI_AUTO_BASE_URL: v1URL(baseURL) },
+            };
+        },
+        check: async ({ ctx, credential }) => {
+            const base = readStr(credential?.env?.OPENAI_AUTO_BASE_URL) ??
+                readStr(await ctx.env("OPENAI_AUTO_BASE_URL")) ??
+                readStr(await ctx.env("LITELLM_BASE_URL"));
+            return base ? { type: "api_key", source: credential ? "stored credential" : "env" } : undefined;
+        },
+        resolve: async ({ ctx, credential }) => {
+            const base = readStr(credential?.env?.OPENAI_AUTO_BASE_URL) ??
+                readStr(await ctx.env("OPENAI_AUTO_BASE_URL")) ??
+                readStr(await ctx.env("LITELLM_BASE_URL"));
+            if (!base)
+                return undefined;
+            const resolvedKey = readStr(credential?.key) ??
+                readStr(await ctx.env("OPENAI_AUTO_API_KEY")) ??
+                readStr(await ctx.env("LITELLM_API_KEY")) ??
+                "local";
+            return {
+                auth: { apiKey: resolvedKey, baseUrl: v1URL(base), headers: APP_HEADERS },
+                env: { ...credential?.env, OPENAI_AUTO_BASE_URL: v1URL(base) },
+                source: credential ? "stored credential" : "env",
+            };
+        },
+    };
+    const provider = {
+        id: PROVIDER_ID,
+        name: PROVIDER_NAME,
+        baseUrl: v1URL(readStr(process.env.OPENAI_AUTO_BASE_URL) ??
+            readStr(process.env.LITELLM_BASE_URL) ??
+            "http://localhost:4000"),
+        headers: APP_HEADERS,
+        auth: { oauth, apiKey },
+        getModels: () => models,
+        refreshModels: async (context) => {
+            if (context.stored) {
+                const restored = context.stored.models.filter((m) => m.provider === PROVIDER_ID && isModelType(m, "chat") && m.api === "openai-completions");
+                if (!(await context.publish({ update: () => { models = restored; } }))) {
+                    return;
+                }
+            }
+            if (!context.allowNetwork || context.signal.aborted)
+                return;
+            const { baseUrl, apiKey: resolvedKey } = await resolveFromCredential(context.credential, context.baseUrl);
+            if (!baseUrl)
+                return;
+            const [discovered, userInfo] = await Promise.all([
+                fetchDiscoveredModels(baseUrl, resolvedKey, APP_HEADERS, context.signal),
+                fetchGatewayUserInfo(baseUrl, resolvedKey, APP_HEADERS, context.signal),
+            ]);
+            if (context.signal.aborted)
+                return;
+            lastUserInfo = userInfo;
+            const refreshed = discovered.map((m) => toPiModel(m, baseUrl));
+            await context.publish({
+                persist: { models: refreshed, checkedAt: Date.now() },
+                update: () => {
+                    models = refreshed;
+                },
+            });
+        },
+        stream: (model, context, options) => completionsApi().stream(model, context, options),
+        streamSimple: (model, context, options) => completionsApi().streamSimple(model, context, options),
+    };
+    return { provider, getUserInfo: () => lastUserInfo };
+}
+function formatStatus(info) {
+    if (!info?.email)
+        return undefined;
+    if (info.effectiveSpendUsd !== undefined && info.monthlyCapUsd !== undefined) {
+        return `${info.email} ($${info.effectiveSpendUsd.toFixed(2)}/$${info.monthlyCapUsd.toFixed(0)})`;
+    }
+    return info.email;
+}
+export default function openaiAutoPiExtension(pi) {
+    const { provider, getUserInfo } = createOpenAIAutoPiProvider();
+    pi.registerProvider(provider);
+    const syncStatus = async (ctx) => {
+        if (!ctx.hasUI)
+            return;
+        if (ctx.model?.provider !== PROVIDER_ID) {
+            ctx.ui.setStatus(PROVIDER_ID, undefined);
+            return;
+        }
+        let info = getUserInfo();
+        if (!info) {
+            const auth = await ctx.modelRegistry.getProviderAuth(PROVIDER_ID).catch(() => undefined);
+            if (auth?.auth.baseUrl && auth.auth.apiKey) {
+                info = await fetchGatewayUserInfo(auth.auth.baseUrl, auth.auth.apiKey, APP_HEADERS);
+            }
+        }
+        ctx.ui.setStatus(PROVIDER_ID, formatStatus(info));
+    };
+    pi.on("session_start", (_event, ctx) => void syncStatus(ctx));
+    pi.on("model_select", (_event, ctx) => void syncStatus(ctx));
+}