@ashx-j/lunr 0.1.0

package/dist/core/model-runtime.js

@@ -0,0 +1,640 @@
+import { dirname, join } from "node:path";
+import { createModels, lazyStream, ModelsError, } from "@earendil-works/pi-ai";
+import * as builtinProviderCatalog from "@earendil-works/pi-ai/providers/all";
+import { getAgentDir } from "../config.js";
+import { AuthStorage as DefaultAuthStorage } from "./auth-storage.js";
+import { CatalogOverlaySource, knownModelKeys, withCatalogOverlay } from "./catalog-merge.js";
+import { buildLiveOverlay, fetchLiveProviderModels, isLiveListProvider, LIVE_LIST_PROVIDER_IDS, } from "./live-catalog.js";
+import { ModelConfig } from "./model-config.js";
+import { FileModelsStore, InMemoryCodingAgentModelsStore } from "./models-store.js";
+import { loadOfficialCatalog, officialCatalogCachePath, officialEntryToModel, officialModelKeys, } from "./official-catalog.js";
+import { composeModelProvider, configuredRequestAuthStatus, resolveCompatibilityRequestConfig, resolveConfiguredModelHeaders, validateExtensionProvider, } from "./provider-composer.js";
+import { RuntimeCredentials } from "./runtime-credentials.js";
+import { SubscriptionManager } from "./subscriptions.js";
+import { UserModelsStore, userEntryToModel, userModelsPath } from "./user-models.js";
+function mergeHeaders(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = { ...base };
+    for (const [name, value] of Object.entries(override ?? {})) {
+        const lowerName = name.toLowerCase();
+        for (const existingName of Object.keys(merged)) {
+            if (existingName.toLowerCase() === lowerName)
+                delete merged[existingName];
+        }
+        merged[name] = value;
+    }
+    return merged;
+}
+/** Configured pi-ai Models collection used by coding-agent and SDK consumers. */
+export class ModelRuntime {
+    models;
+    credentials;
+    /** lunr: per-provider subscription-key pools; rotation mirrors the active key into the credential store. */
+    subscriptionManager;
+    defaultBuiltins;
+    builtins = new Map();
+    extensionProviders = new Map();
+    compositionErrors = new Map();
+    modelsPath;
+    allowModelNetwork;
+    config;
+    snapshot = {
+        all: [],
+        available: [],
+        configuredProviders: new Set(),
+        storedProviders: new Set(),
+        auth: new Map(),
+    };
+    availabilityRefresh;
+    availabilityError;
+    modelsStore;
+    overlay = new CatalogOverlaySource();
+    userModels;
+    officialCachePath;
+    lastCatalogRefresh = { aborted: false, errors: new Map(), live: [], incomplete: [] };
+    constructor(credentials, config, modelsPath, modelsStore, providers, allowModelNetwork, subscriptionManager, catalogDir) {
+        this.credentials = credentials;
+        this.config = config;
+        this.modelsPath = modelsPath;
+        this.modelsStore = modelsStore;
+        this.allowModelNetwork = allowModelNetwork;
+        this.subscriptionManager = subscriptionManager;
+        this.userModels = new UserModelsStore(catalogDir ? userModelsPath(catalogDir) : undefined);
+        this.officialCachePath = catalogDir ? officialCatalogCachePath(catalogDir) : undefined;
+        this.defaultBuiltins = new Map(providers.map((provider) => [provider.id, provider]));
+        for (const [providerId, provider] of this.defaultBuiltins)
+            this.builtins.set(providerId, provider);
+        this.models = createModels({ credentials, modelsStore });
+        this.rebuildProviders();
+    }
+    static async create(options = {}) {
+        // lunr: keep the underlying store — the SubscriptionManager mirrors rotated
+        // keys into it directly, NOT through the RuntimeCredentials overlay (a runtime
+        // --api-key override would shadow the mirror there).
+        const baseStore = options.credentials ?? DefaultAuthStorage.create(options.authPath);
+        const credentials = new RuntimeCredentials(baseStore);
+        // Pool persistence: subscriptions.json next to auth.json. A custom credential
+        // store without an authPath (tests, SDK embeddings) gets a process-local pool
+        // so nothing leaks into the real agent dir.
+        const subscriptionManager = options.subscriptions ??
+            (options.credentials && !options.authPath
+                ? SubscriptionManager.inMemory(baseStore)
+                : SubscriptionManager.create(baseStore, options.authPath ? join(dirname(options.authPath), "subscriptions.json") : undefined));
+        const modelsPath = options.modelsPath === null ? undefined : (options.modelsPath ?? join(getAgentDir(), "models.json"));
+        const config = await ModelConfig.load(modelsPath);
+        const modelsStore = options.modelsStore ??
+            (modelsPath
+                ? new FileModelsStore(options.modelsStorePath ?? join(dirname(modelsPath), "models-store.json"))
+                : new InMemoryCodingAgentModelsStore());
+        const providers = builtinProviderCatalog.builtinProviders();
+        const catalogDir = modelsPath ? dirname(modelsPath) : options.authPath ? dirname(options.authPath) : undefined;
+        const runtime = new ModelRuntime(credentials, config, modelsPath, modelsStore, providers, options.allowModelNetwork ?? process.env.PI_OFFLINE === undefined, subscriptionManager, catalogDir);
+        runtime.configureRadiusProviders();
+        runtime.rebuildProviders();
+        // lunr: create() must not wait on GitHub / provider /v1/models / a dead NIC.
+        // Disk cache + baked-in + bundled official overlay are enough to start;
+        // /refresh and the model picker still do a live refresh.
+        await runtime.refresh({ allowNetwork: false });
+        return runtime;
+    }
+    configureRadiusProviders() {
+        this.builtins.clear();
+        for (const [providerId, provider] of this.defaultBuiltins)
+            this.builtins.set(providerId, provider);
+        for (const providerId of this.config.getProviderIds()) {
+            const config = this.config.getProvider(providerId);
+            if (config?.oauth !== "radius" || !config.baseUrl)
+                continue;
+            this.builtins.set(providerId, builtinProviderCatalog.radiusProvider({
+                id: providerId,
+                name: config.name ?? providerId,
+                gateway: config.baseUrl.replace(/\/v1\/?$/u, ""),
+            }));
+        }
+    }
+    providerIds() {
+        return new Set([...this.builtins.keys(), ...this.config.getProviderIds(), ...this.extensionProviders.keys()]);
+    }
+    recomposeProvider(providerId) {
+        const base = this.builtins.get(providerId);
+        const extension = this.extensionProviders.get(providerId);
+        if (!base && !this.config.getProvider(providerId) && !extension) {
+            this.models.deleteProvider(providerId);
+            this.compositionErrors.delete(providerId);
+            return;
+        }
+        if (base && !this.config.getProvider(providerId) && !extension) {
+            // No models.json/extension overlays: keep builtin auth/stream exact, then apply catalog layers.
+            this.models.setProvider(this.withLocalCatalog(base));
+            this.compositionErrors.delete(providerId);
+            return;
+        }
+        try {
+            this.models.setProvider(this.withLocalCatalog(composeModelProvider(providerId, base, this.config, extension)));
+            this.compositionErrors.delete(providerId);
+        }
+        catch (error) {
+            this.compositionErrors.set(providerId, error instanceof Error ? error.message : String(error));
+            if (base)
+                this.models.setProvider(this.withLocalCatalog(base));
+            else
+                this.models.deleteProvider(providerId);
+        }
+    }
+    withLocalCatalog(provider) {
+        return isLiveListProvider(provider.id) ? withCatalogOverlay(provider, this.overlay) : provider;
+    }
+    bakedInModels(providerId) {
+        return [...(this.defaultBuiltins.get(providerId)?.getModels() ?? [])];
+    }
+    rebuildProviders() {
+        this.models.clearProviders();
+        this.compositionErrors.clear();
+        for (const providerId of this.providerIds())
+            this.recomposeProvider(providerId);
+        this.updateModelSnapshot();
+    }
+    updateModelSnapshot() {
+        const all = [...this.models.getModels()];
+        this.snapshot = {
+            ...this.snapshot,
+            all,
+            available: all.filter((model) => this.snapshot.configuredProviders.has(model.provider)),
+        };
+    }
+    async listStoredProviderIds() {
+        const credentials = await this.credentials.list();
+        return new Set(credentials.map((entry) => entry.providerId));
+    }
+    /** `/model` lists stored creds + models.json/extension keys, never ambient envApiKeyAuth. */
+    configuredProviderIds(storedProviders) {
+        const configured = new Set(storedProviders);
+        for (const provider of this.models.getProviders()) {
+            if (configuredRequestAuthStatus(this.config.getProvider(provider.id), this.extensionProviders.get(provider.id))
+                ?.configured) {
+                configured.add(provider.id);
+            }
+        }
+        return configured;
+    }
+    userModelsForStoredProviders(storedProviders) {
+        return this.userModels
+            .list()
+            .filter((row) => storedProviders.has(row.provider))
+            .map(userEntryToModel);
+    }
+    async runAvailabilityRefresh() {
+        const providers = this.models.getProviders();
+        const [available, checks, storedProviders] = await Promise.all([
+            this.models.getAvailable(),
+            Promise.all(providers.map(async (provider) => [
+                provider.id,
+                await this.models.checkAuth(provider.id),
+            ])),
+            this.listStoredProviderIds(),
+        ]);
+        const auth = new Map(checks);
+        const configuredProviders = this.configuredProviderIds(storedProviders);
+        this.snapshot = {
+            all: [...this.models.getModels()],
+            available: available.filter((model) => configuredProviders.has(model.provider)),
+            configuredProviders,
+            storedProviders,
+            auth,
+        };
+        this.availabilityError = undefined;
+    }
+    queueAvailabilityRefresh(after) {
+        const refresh = (after ?? Promise.resolve()).catch(() => { }).then(() => this.runAvailabilityRefresh());
+        const recorded = refresh.catch((error) => {
+            this.availabilityError = error instanceof Error ? error.message : String(error);
+            throw error;
+        });
+        const tracked = recorded.finally(() => {
+            if (this.availabilityRefresh === tracked)
+                this.availabilityRefresh = undefined;
+        });
+        this.availabilityRefresh = tracked;
+        return tracked;
+    }
+    /** Coalesce concurrent readers onto the pending refresh. */
+    refreshAvailability() {
+        return this.availabilityRefresh ?? this.queueAvailabilityRefresh(undefined);
+    }
+    /** Mutations must not observe an in-flight refresh started before them. */
+    forceRefreshAvailability() {
+        return this.queueAvailabilityRefresh(this.availabilityRefresh);
+    }
+    getProviders() {
+        return this.models.getProviders();
+    }
+    getProvider(providerId) {
+        return this.models.getProvider(providerId);
+    }
+    getModels(providerId) {
+        return this.models.getModels(providerId);
+    }
+    getModel(providerId, modelId) {
+        return this.models.getModel(providerId, modelId);
+    }
+    async checkAuth(providerId) {
+        return this.models.checkAuth(providerId);
+    }
+    async getAvailable(providerId) {
+        if (providerId) {
+            if (this.availabilityRefresh) {
+                await this.availabilityRefresh;
+                return this.snapshot.available.filter((model) => model.provider === providerId);
+            }
+            try {
+                return await this.models.getAvailable(providerId);
+            }
+            catch (error) {
+                this.availabilityError = error instanceof Error ? error.message : String(error);
+                throw error;
+            }
+        }
+        await this.refreshAvailability();
+        return this.snapshot.available;
+    }
+    getAvailableSnapshot() {
+        return this.snapshot.available;
+    }
+    getError() {
+        const errors = [];
+        const configError = this.config.getError();
+        if (configError)
+            errors.push(configError);
+        for (const [providerId, error] of this.compositionErrors) {
+            errors.push(`Provider "${providerId}": ${error}`);
+        }
+        if (this.availabilityError)
+            errors.push(`Availability refresh: ${this.availabilityError}`);
+        return errors.length > 0 ? errors.join("\n\n") : undefined;
+    }
+    getRegisteredProviderConfig(providerId) {
+        return this.extensionProviders.get(providerId);
+    }
+    getRegisteredProviderIds() {
+        return [...this.extensionProviders.keys()];
+    }
+    /** @internal Compatibility fallback for ModelRegistry when provider auth is unconfigured. */
+    getCompatibilityRequestConfig(model) {
+        return resolveCompatibilityRequestConfig(model, this.config.getProvider(model.provider), this.extensionProviders.get(model.provider));
+    }
+    isUsingOAuth(providerId) {
+        return this.snapshot.auth.get(providerId)?.type === "oauth";
+    }
+    hasConfiguredAuth(providerId) {
+        return this.snapshot.configuredProviders.has(providerId);
+    }
+    async getAuth(providerOrModel, overrides = {}) {
+        if (typeof providerOrModel === "string")
+            return this.models.getAuth(providerOrModel, overrides);
+        const resolution = await this.models.getAuth(providerOrModel, overrides);
+        if (!resolution)
+            return undefined;
+        const configuredHeaders = resolveConfiguredModelHeaders(providerOrModel, this.config.getProvider(providerOrModel.provider), this.extensionProviders.get(providerOrModel.provider), { ...(resolution.env ?? {}), ...(overrides.env ?? {}) });
+        return {
+            ...resolution,
+            auth: {
+                ...resolution.auth,
+                headers: mergeHeaders(resolution.auth.headers, configuredHeaders),
+            },
+        };
+    }
+    /** lunr: whether a runtime --api-key override is active for the provider (it shadows auth.json). */
+    hasRuntimeApiKey(providerId) {
+        return this.credentials.hasRuntimeApiKey(providerId);
+    }
+    async setRuntimeApiKey(providerId, apiKey) {
+        this.credentials.setRuntimeApiKey(providerId, apiKey);
+        const auth = new Map(this.snapshot.auth).set(providerId, { type: "api_key", source: "runtime API key" });
+        const configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId);
+        const storedProviders = new Set(this.snapshot.storedProviders).add(providerId);
+        this.snapshot = {
+            ...this.snapshot,
+            auth,
+            configuredProviders,
+            storedProviders,
+            available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider)),
+        };
+        await this.refresh({ allowNetwork: this.allowModelNetwork });
+    }
+    async removeRuntimeApiKey(providerId) {
+        this.credentials.removeRuntimeApiKey(providerId);
+        await this.refresh({ allowNetwork: this.allowModelNetwork });
+    }
+    /** lunr: whether network model-catalog fetches are allowed (offline mode disables them). */
+    isNetworkAllowed() {
+        return this.allowModelNetwork;
+    }
+    listCredentials() {
+        return this.credentials.list();
+    }
+    getProviderAuthStatus(providerId) {
+        if (this.credentials.hasRuntimeApiKey(providerId))
+            return { configured: true, source: "runtime" };
+        if (this.snapshot.storedProviders.has(providerId))
+            return { configured: true, source: "stored" };
+        const configured = configuredRequestAuthStatus(this.config.getProvider(providerId), this.extensionProviders.get(providerId));
+        if (configured)
+            return configured;
+        const check = this.snapshot.auth.get(providerId);
+        return check ? { configured: true, source: "environment", label: check.source } : { configured: false };
+    }
+    async prepareRequest(model, options) {
+        const provider = this.models.getProvider(model.provider);
+        if (!provider)
+            throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
+        const resolution = await this.getAuth(model, { apiKey: options?.apiKey, env: options?.env });
+        if (!resolution)
+            throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
+        const { transformHeaders, ...providerOptions } = options ?? {};
+        let headers = mergeHeaders(resolution.auth.headers, providerOptions.headers);
+        if (transformHeaders)
+            headers = await transformHeaders(headers ?? {});
+        const env = resolution.env || providerOptions.env
+            ? { ...(resolution.env ?? {}), ...(providerOptions.env ?? {}) }
+            : undefined;
+        return {
+            provider,
+            model: resolution.auth.baseUrl ? { ...model, baseUrl: resolution.auth.baseUrl } : model,
+            options: {
+                ...providerOptions,
+                apiKey: providerOptions.apiKey ?? resolution.auth.apiKey,
+                headers,
+                env,
+            },
+        };
+    }
+    stream(model, context, options) {
+        return lazyStream(model, async () => {
+            const prepared = await this.prepareRequest(model, options);
+            return prepared.provider.stream(prepared.model, context, prepared.options);
+        });
+    }
+    complete(model, context, options) {
+        return this.stream(model, context, options).result();
+    }
+    streamSimple(model, context, options) {
+        return lazyStream(model, async () => {
+            const prepared = await this.prepareRequest(model, options);
+            return prepared.provider.streamSimple(prepared.model, context, prepared.options);
+        });
+    }
+    completeSimple(model, context, options) {
+        return this.streamSimple(model, context, options).result();
+    }
+    async login(providerId, type, interaction) {
+        const credential = await this.models.login(providerId, type, interaction);
+        await this.refresh({ allowNetwork: this.allowModelNetwork });
+        return credential;
+    }
+    async logout(providerId) {
+        await this.models.logout(providerId);
+        await this.modelsStore.delete(providerId);
+        this.userModels.evictProvider(providerId);
+        this.overlay.setLive(providerId, []);
+        // Reset credential-dependent compatibility projections before the unconfigured provider is skipped by refresh.
+        this.recomposeProvider(providerId);
+        await this.refresh({ allowNetwork: this.allowModelNetwork });
+    }
+    async reloadConfig() {
+        this.config = await ModelConfig.load(this.modelsPath);
+        this.configureRadiusProviders();
+        this.rebuildProviders();
+        await this.refresh({ allowNetwork: this.allowModelNetwork });
+    }
+    async refresh(options = {}) {
+        const refreshOptions = {
+            ...options,
+            allowNetwork: options.allowNetwork ?? this.allowModelNetwork,
+        };
+        const official = await this.refreshOfficialCatalog(refreshOptions.allowNetwork, refreshOptions.signal);
+        const live = refreshOptions.allowNetwork
+            ? await this.refreshLiveCatalogs(official ? officialModelKeys(official.catalog) : new Set(), refreshOptions.signal)
+            : await this.restoreLiveCatalogs();
+        // Radius / local-provider / extension refreshModels hooks. Live-list
+        // providers have no refreshModels, so this does not hit pi.dev.
+        const result = (await this.models.refresh(refreshOptions)) ?? {
+            aborted: refreshOptions.signal?.aborted ?? false,
+            errors: new Map(),
+        };
+        const errors = new Map(result.errors);
+        for (const entry of live) {
+            if (entry.status === "error" || entry.status === "timeout") {
+                errors.set(entry.providerId, new Error(entry.error ?? entry.status));
+            }
+        }
+        this.updateModelSnapshot();
+        try {
+            await this.forceRefreshAvailability();
+        }
+        catch {
+            // Availability errors are recorded by forceRefreshAvailability; refreshed models remain usable.
+        }
+        const catalogResult = {
+            aborted: result.aborted,
+            errors,
+            official,
+            live,
+            incomplete: live.flatMap((entry) => entry.incomplete),
+        };
+        this.lastCatalogRefresh = catalogResult;
+        return catalogResult;
+    }
+    getLastCatalogRefresh() {
+        return this.lastCatalogRefresh;
+    }
+    persistUserModels(rows) {
+        this.userModels.upsert(rows);
+        this.overlay.setUser(this.userModelsForStoredProviders(this.snapshot.storedProviders));
+        this.updateModelSnapshot();
+    }
+    async refreshOfficialCatalog(allowNetwork, signal) {
+        const storedProviders = await this.listStoredProviderIds();
+        const loaded = await loadOfficialCatalog({
+            allowNetwork,
+            cachePath: this.officialCachePath,
+            signal,
+            providerIds: [...storedProviders],
+        });
+        const evicted = this.userModels.evictOfficial(officialModelKeys(loaded.catalog));
+        const templateByProvider = new Map();
+        const officialModels = loaded.catalog.models.map((entry) => {
+            if (!templateByProvider.has(entry.provider)) {
+                templateByProvider.set(entry.provider, this.bakedInModels(entry.provider)[0]);
+            }
+            return officialEntryToModel(entry, templateByProvider.get(entry.provider));
+        });
+        this.overlay.setOfficial(officialModels);
+        this.overlay.setUser(this.userModelsForStoredProviders(storedProviders));
+        return { ...loaded, evictedUserRows: evicted.length };
+    }
+    async restoreLiveCatalogs() {
+        const storedProviders = await this.listStoredProviderIds();
+        const results = [];
+        for (const providerId of LIVE_LIST_PROVIDER_IDS) {
+            const stored = storedProviders.has(providerId) ? await this.modelsStore.read(providerId) : undefined;
+            if (stored?.models)
+                this.overlay.setLive(providerId, stored.models);
+            else
+                this.overlay.setLive(providerId, []);
+            results.push({
+                providerId,
+                status: "skipped",
+                discoveries: [],
+                added: 0,
+                total: stored?.models.length ?? 0,
+                incomplete: [],
+            });
+        }
+        return results;
+    }
+    async refreshLiveCatalogs(officialKeys, signal) {
+        const storedProviders = await this.listStoredProviderIds();
+        const known = knownModelKeys(LIVE_LIST_PROVIDER_IDS.flatMap((id) => this.bakedInModels(id)), officialKeys, this.userModels.keys());
+        const results = await Promise.all(LIVE_LIST_PROVIDER_IDS.map(async (providerId) => {
+            if (!storedProviders.has(providerId)) {
+                this.overlay.setLive(providerId, []);
+                return {
+                    providerId,
+                    status: "skipped",
+                    discoveries: [],
+                    added: 0,
+                    total: 0,
+                    incomplete: [],
+                };
+            }
+            const stored = await this.modelsStore.read(providerId);
+            if (stored?.models)
+                this.overlay.setLive(providerId, stored.models);
+            if (signal?.aborted) {
+                return {
+                    providerId,
+                    status: "skipped",
+                    discoveries: [],
+                    added: 0,
+                    total: stored?.models.length ?? 0,
+                    incomplete: [],
+                    error: "aborted",
+                };
+            }
+            const bakedIn = this.bakedInModels(providerId);
+            const provider = this.models.getProvider(providerId) ?? this.defaultBuiltins.get(providerId);
+            const baseUrl = provider?.baseUrl ?? bakedIn[0]?.baseUrl;
+            if (!baseUrl) {
+                return {
+                    providerId,
+                    status: "skipped",
+                    discoveries: [],
+                    added: 0,
+                    total: 0,
+                    incomplete: [],
+                };
+            }
+            let credential;
+            try {
+                credential = await this.refreshCredentialFor(providerId);
+            }
+            catch (error) {
+                return {
+                    providerId,
+                    status: "error",
+                    discoveries: [],
+                    added: 0,
+                    total: stored?.models.length ?? 0,
+                    incomplete: [],
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            if (!credential) {
+                return {
+                    providerId,
+                    status: "skipped",
+                    discoveries: [],
+                    added: 0,
+                    total: stored?.models.length ?? 0,
+                    incomplete: [],
+                };
+            }
+            const result = await fetchLiveProviderModels({
+                providerId,
+                baseUrl,
+                bakedIn,
+                credential,
+                knownKeys: known,
+                signal,
+            });
+            if (result.status === "ok") {
+                const overlayModels = buildLiveOverlay(bakedIn, result.discoveries);
+                this.overlay.setLive(providerId, overlayModels);
+                try {
+                    await this.modelsStore.write(providerId, { models: overlayModels, checkedAt: Date.now() });
+                }
+                catch {
+                    // Store write is best-effort.
+                }
+            }
+            return result;
+        }));
+        return results;
+    }
+    async refreshCredentialFor(providerId) {
+        const stored = await this.credentials.read(providerId);
+        // Same lock + persist path as chat. Returning stored OAuth here skips
+        // refresh and sends expired SuperGrok tokens to GET /models (HTTP 403).
+        const resolved = await this.getAuth(providerId);
+        if (resolved?.auth.apiKey)
+            return { type: "api_key", key: resolved.auth.apiKey, env: resolved.env };
+        if (stored?.type === "oauth" && stored.access)
+            return stored;
+        if (stored?.type === "api_key" && stored.key)
+            return stored;
+        return undefined;
+    }
+    registerProvider(providerId, config) {
+        // Validate the incoming registration on its own, like the legacy registry:
+        // a broken re-registration must throw without touching the stored config.
+        validateExtensionProvider(providerId, this.builtins.get(providerId), this.config.getProvider(providerId), config);
+        // Re-registration merges defined values over the previous registration and
+        // preserves undefined ones, matching the legacy ModelRegistry contract.
+        const previous = this.extensionProviders.get(providerId);
+        const effective = { ...previous };
+        for (const [key, value] of Object.entries(config)) {
+            if (value !== undefined)
+                effective[key] = value;
+        }
+        this.extensionProviders.set(providerId, effective);
+        this.recomposeProvider(providerId);
+        this.updateModelSnapshot();
+        if (this.snapshot.storedProviders.has(providerId) ||
+            configuredRequestAuthStatus(this.config.getProvider(providerId), effective)?.configured) {
+            const configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId);
+            const auth = new Map(this.snapshot.auth);
+            // Provisional entry until the async refresh lands; never clobber a real check result.
+            if (!auth.get(providerId)) {
+                auth.set(providerId, {
+                    type: effective.oauth && !effective.apiKey ? "oauth" : "api_key",
+                    source: "configured provider",
+                });
+            }
+            this.snapshot = {
+                ...this.snapshot,
+                auth,
+                configuredProviders,
+                available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider)),
+            };
+        }
+        void this.refresh({ allowNetwork: false });
+    }
+    unregisterProvider(providerId) {
+        this.extensionProviders.delete(providerId);
+        this.recomposeProvider(providerId);
+        this.updateModelSnapshot();
+        void this.refresh({ allowNetwork: false });
+    }
+}
+//# sourceMappingURL=model-runtime.js.map