@averyyy/pi-coding-agent 0.99.1-piclient.1 → 1.0.0-piclient.2

package/dist/core/model-runtime.js

@@ -1,5 +1,5 @@
 import { dirname, join } from "node:path";
-import { clampThinkingLevel, createModels, lazyStream, ModelsError, normalizeContext, } from "@earendil-works/pi-ai";
+import { clampThinkingLevel, createModels, isModelType, lazyStream, ModelsError, normalizeContext, } from "@earendil-works/pi-ai";
 import * as builtinProviderCatalog from "@earendil-works/pi-ai/providers/all";
 import { assertChatModel, assertClassifierModel, assertImageModel, classifierErrorResult, imageErrorResult, } from "@earendil-works/pi-ai/utils/model-operations";
 import { getAgentDir } from "../config.js";
@@ -7,6 +7,7 @@ import { operationSignal, raceWithAbortSignal } from "../utils/abort.js";
 import { AuthStorage as DefaultAuthStorage } from "./auth-storage.js";
 import { ModelConfig } from "./model-config.js";
 import { FileModelsStore, InMemoryCodingAgentModelsStore } from "./models-store.js";
+import { cancelDeferredPiServer, classifyPiServer, fetchDeferredPiServer, fetchPiServerModels, generateImagesPiServer, streamPiServer, streamRawPiServer, } from "./pi-server-client.js";
 import { composeModelProvider, configuredRequestAuthStatus, resolveCompatibilityRequestConfig, resolveConfiguredModelHeaders, validateExtensionProvider, } from "./provider-composer.js";
 import { withRemoteCatalog } from "./remote-catalog-provider.js";
 import { RuntimeCredentials } from "./runtime-credentials.js";
@@ -43,6 +44,7 @@ export class ModelRuntime {
     models;
     credentials;
     defaultBuiltins;
+    nativeCatalogProviders;
     builtins = new Map();
     nativeExtensionProviders = new Map();
     extensionProviders = new Map();
@@ -51,6 +53,19 @@ export class ModelRuntime {
     compositionErrors = new Map();
     modelsPath;
     modelNetworkEnabled;
+    piServerMode = process.env.PI_SERVER_MODE === "true";
+    remoteCatalog = {
+        models: [],
+        available: [],
+    };
+    remoteProviderCapabilities = [];
+    remoteCatalogError;
+    registrationRefresh = Promise.resolve();
+    registrationRefreshErrors = new Map();
+    remoteCatalogRefreshSeq = 0;
+    remoteCatalogLoaded = false;
+    localOperationAvailable = [];
+    remoteProjection;
     config;
     snapshot = {
         all: [],
@@ -64,11 +79,12 @@ export class ModelRuntime {
     providerAvailabilitySeq = new Map();
     availabilityError;
     credentialOperations = new Map();
-    constructor(credentials, config, modelsPath, modelsStore, providers, modelNetworkEnabled) {
+    constructor(credentials, config, modelsPath, modelsStore, providers, modelNetworkEnabled, nativeCatalogProviders) {
         this.credentials = credentials;
         this.config = config;
         this.modelsPath = modelsPath;
         this.modelNetworkEnabled = modelNetworkEnabled;
+        this.nativeCatalogProviders = nativeCatalogProviders;
         this.defaultBuiltins = new Map(providers.map((provider) => [provider.id, provider]));
         for (const [providerId, provider] of this.defaultBuiltins)
             this.builtins.set(providerId, provider);
@@ -84,12 +100,11 @@ export class ModelRuntime {
                 ? new FileModelsStore(options.modelsStorePath ?? join(dirname(modelsPath), "models-store.json"))
                 : new InMemoryCodingAgentModelsStore());
         const builtinModelDataGeneratedAt = builtinProviderCatalog.getBuiltinModelDataGeneratedAt();
-        const providers = builtinProviderCatalog
-            .builtinProviders()
-            .map((provider) => provider.refreshModels !== undefined
+        const builtinProviders = builtinProviderCatalog.builtinProviders();
+        const providers = builtinProviders.map((provider) => provider.refreshModels !== undefined
             ? provider
             : withRemoteCatalog(provider, options.catalogBaseUrl, builtinModelDataGeneratedAt));
-        const runtime = new ModelRuntime(credentials, config, modelsPath, modelsStore, providers, process.env.PI_OFFLINE === undefined);
+        const runtime = new ModelRuntime(credentials, config, modelsPath, modelsStore, providers, process.env.PI_OFFLINE === undefined, new Set(builtinProviders.filter((provider) => provider.refreshModels !== undefined).map((provider) => provider.id)));
         runtime.configureRadiusProviders();
         runtime.rebuildProviders();
         const refreshFromNetwork = runtime.modelNetworkEnabled && options.allowModelNetwork === true;
@@ -102,7 +117,12 @@ export class ModelRuntime {
             : options.signal;
         try {
             if (options.refreshOnCreate !== false) {
-                await runtime.refresh({ allowNetwork: refreshFromNetwork, signal });
+                const result = await runtime.refresh({ allowNetwork: refreshFromNetwork, signal });
+                const remoteError = result.errors.get("pi-server");
+                if (remoteError)
+                    throw remoteError;
+                if (runtime.piServerMode && result.aborted)
+                    signal?.throwIfAborted();
             }
         }
         finally {
@@ -174,6 +194,7 @@ export class ModelRuntime {
         this.updateModelSnapshot();
     }
     updateModelSnapshot() {
+        this.remoteProjection = undefined;
         const all = [...this.models.getModels()];
         this.snapshot = {
             ...this.snapshot,
@@ -183,8 +204,8 @@ export class ModelRuntime {
     }
     async runAvailabilityRefresh(seq, errorSeq, signal) {
         const providers = this.models.getProviders();
-        const [available, checks, credentials] = await Promise.all([
-            this.models.getAvailable(undefined, { signal }),
+        const [allAvailable, checks, credentials] = await Promise.all([
+            this.models.getAllAvailable(undefined, { signal }),
             Promise.all(providers.map(async (provider) => [
                 provider.id,
                 await this.models.checkAuth(provider.id, { signal }),
@@ -193,13 +214,15 @@ export class ModelRuntime {
         ]);
         if (seq !== this.availabilityRefreshSeq)
             return;
+        this.localOperationAvailable = allAvailable;
+        this.remoteProjection = undefined;
         const auth = new Map(checks);
         const configuredProviders = new Set(checks
             .filter((entry) => entry[1] !== undefined)
             .map(([providerId]) => providerId));
         this.snapshot = {
             all: [...this.models.getModels()],
-            available: [...available],
+            available: allAvailable.filter((model) => isModelType(model, "chat")),
             configuredProviders,
             storedProviders: new Set(credentials.map((entry) => entry.providerId)),
             auth,
@@ -228,14 +251,20 @@ export class ModelRuntime {
         this.providerAvailabilitySeq.set(providerId, providerSeq);
         const errorSeq = ++this.availabilityErrorSeq;
         try {
-            const [available, auth, credential] = await Promise.all([
-                this.models.getAvailable(providerId, { signal }),
+            const [allAvailable, auth, credential] = await Promise.all([
+                this.models.getAllAvailable(providerId, { signal }),
                 this.models.checkAuth(providerId, { signal }),
                 this.credentials.read(providerId, { signal }),
             ]);
             signal.throwIfAborted();
             if (this.providerAvailabilitySeq.get(providerId) !== providerSeq)
                 return;
+            this.localOperationAvailable = [
+                ...this.localOperationAvailable.filter((model) => model.provider !== providerId),
+                ...allAvailable,
+            ];
+            this.remoteProjection = undefined;
+            const available = allAvailable.filter((model) => isModelType(model, "chat"));
             const configuredProviders = new Set(this.snapshot.configuredProviders);
             const storedProviders = new Set(this.snapshot.storedProviders);
             const authByProvider = new Map(this.snapshot.auth);
@@ -276,36 +305,167 @@ export class ModelRuntime {
         }
     }
     getProviders() {
+        if (this.piServerMode) {
+            const ids = new Set([
+                ...this.models.getProviders().map((provider) => provider.id),
+                ...this.getAllModels().map((model) => model.provider),
+            ]);
+            return [...ids].flatMap((id) => this.getProvider(id) ?? []);
+        }
         return this.models.getProviders();
     }
     getProvider(providerId) {
-        return this.models.getProvider(providerId);
+        const local = this.models.getProvider(providerId);
+        if (!this.piServerMode)
+            return local;
+        const catalog = this.getAllModels(providerId);
+        if (!local && catalog.length === 0)
+            return undefined;
+        const capabilities = this.remoteProviderCapabilities.find((provider) => provider.id === providerId);
+        return {
+            ...local,
+            id: providerId,
+            name: local?.name ?? providerId,
+            auth: local?.auth ?? {},
+            getModels: () => this.getModels(providerId),
+            getAllModels: () => this.getAllModels(providerId),
+            stream: (model, context, options) => this.stream(model, context, options),
+            streamSimple: (model, context, options) => this.streamSimple(model, context, options),
+            generateImages: local?.generateImages || catalog.some((model) => isModelType(model, "image"))
+                ? (model, context, options) => this.generateImages(model, context, options)
+                : undefined,
+            classify: local?.classify || catalog.some((model) => isModelType(model, "classifier"))
+                ? (model, context, options) => this.classify(model, context, options)
+                : undefined,
+            fetchDeferred: local?.fetchDeferred || capabilities?.fetchDeferred
+                ? (model, handle, options) => this.streamDeferred(model, handle, options)
+                : undefined,
+            cancelDeferred: local?.cancelDeferred || capabilities?.cancelDeferred
+                ? (model, handle, options) => this.cancelDeferred(model, handle, options)
+                : undefined,
+        };
     }
     getModels(providerId) {
+        if (this.piServerMode)
+            return this.getModelsOfType("chat", providerId);
         return this.models.getModels(providerId);
     }
     getModel(providerId, modelId) {
+        if (this.piServerMode)
+            return this.getModelOfType("chat", providerId, modelId);
         return this.models.getModel(providerId, modelId);
     }
     getModelsOfType(type, providerId) {
+        if (this.piServerMode)
+            return this.getRemoteModels(false, providerId).filter((model) => isModelType(model, type));
         return this.models.getModelsOfType(type, providerId);
     }
     getModelOfType(type, providerId, modelId) {
+        if (this.piServerMode)
+            return this.getModelsOfType(type, providerId).find((model) => model.id === modelId);
         return this.models.getModelOfType(type, providerId, modelId);
     }
     getAllModels(providerId) {
+        if (this.piServerMode)
+            return this.getRemoteModels(false, providerId);
         return this.models.getAllModels(providerId);
     }
-    getAvailableOfType(type, providerId, options) {
+    async getAvailableOfType(type, providerId, options) {
+        if (this.piServerMode) {
+            options?.signal?.throwIfAborted();
+            await raceWithAbortSignal(this.registrationRefresh, options?.signal);
+            if (!this.remoteCatalogLoaded)
+                await this.refreshRemoteCatalog(options?.signal);
+            return this.getRemoteModels(true, providerId).filter((model) => isModelType(model, type));
+        }
         return this.models.getAvailableOfType(type, providerId, options);
     }
-    getAllAvailable(providerId, options) {
+    async getAllAvailable(providerId, options) {
+        if (this.piServerMode) {
+            options?.signal?.throwIfAborted();
+            await raceWithAbortSignal(this.registrationRefresh, options?.signal);
+            if (!this.remoteCatalogLoaded)
+                await this.refreshRemoteCatalog(options?.signal);
+            return this.getRemoteModels(true, providerId);
+        }
         return this.models.getAllAvailable(providerId, options);
     }
+    getRemoteModels(available, providerId) {
+        if (this.remoteProjection) {
+            const models = available ? this.remoteProjection.available : this.remoteProjection.models;
+            return providerId === undefined ? models : models.filter((model) => model.provider === providerId);
+        }
+        const catalog = new Map(this.remoteCatalog.models.map((model) => [`${model.type ?? "chat"}\0${model.provider}\0${model.id}`, model]));
+        for (const model of this.localOperationAvailable) {
+            const key = `${model.type ?? "chat"}\0${model.provider}\0${model.id}`;
+            if (!catalog.has(key))
+                catalog.set(key, model);
+        }
+        const localAvailableKeys = new Set(this.localOperationAvailable.map((model) => `${model.type ?? "chat"}\0${model.provider}\0${model.id}`));
+        for (const id of this.nativeCatalogProviders) {
+            for (const model of this.models.getAllModels(id)) {
+                const key = `${model.type ?? "chat"}\0${model.provider}\0${model.id}`;
+                if (!catalog.has(key) || localAvailableKeys.has(key))
+                    catalog.set(key, model);
+            }
+        }
+        const availableKeys = new Set(this.remoteCatalog.available.map((model) => `${model.type ?? "chat"}\0${model.provider}\0${model.id}`));
+        for (const model of this.localOperationAvailable) {
+            availableKeys.add(`${model.type ?? "chat"}\0${model.provider}\0${model.id}`);
+        }
+        const overlayProviders = new Set([...this.config.getProviderIds(), ...this.getRegisteredProviderIds()]);
+        for (const id of overlayProviders) {
+            const native = this.nativeExtensionProviders.get(id);
+            const base = native ?? this.builtins.get(id);
+            const baseModels = native
+                ? (native.getAllModels?.() ?? native.getModels())
+                : [...catalog.values()].filter((model) => model.provider === id);
+            const provider = composeModelProvider(id, base && {
+                ...base,
+                getModels: () => baseModels.filter((model) => isModelType(model, "chat")),
+                getAllModels: () => baseModels,
+            }, this.config, this.extensionProviders.get(id));
+            for (const [key, model] of catalog)
+                if (model.provider === id)
+                    catalog.delete(key);
+            for (const model of provider.getAllModels?.() ?? provider.getModels()) {
+                catalog.set(`${model.type ?? "chat"}\0${model.provider}\0${model.id}`, model);
+            }
+        }
+        const models = [...catalog.values()];
+        const availableProviders = new Set(models
+            .filter((model) => availableKeys.has(`${model.type ?? "chat"}\0${model.provider}\0${model.id}`))
+            .map((model) => model.provider));
+        const virtualModels = [...this.virtualModels.values()].flatMap((models) => [...models.values()].map((entry) => entry.model));
+        const virtualIds = new Set(virtualModels.map((model) => `${model.provider}\0${model.id}`));
+        const physical = models.filter((model) => !isModelType(model, "chat") || !virtualIds.has(`${model.provider}\0${model.id}`));
+        const eligibleVirtual = virtualModels.filter((model) => !models.some((entry) => entry.provider === model.provider) || availableProviders.has(model.provider));
+        this.remoteProjection = {
+            models: [...physical, ...virtualModels],
+            available: [
+                ...physical.filter((model) => availableKeys.has(`${model.type ?? "chat"}\0${model.provider}\0${model.id}`)),
+                ...eligibleVirtual,
+            ],
+        };
+        return this.getRemoteModels(available, providerId);
+    }
+    async refreshRemoteCatalog(signal) {
+        const seq = ++this.remoteCatalogRefreshSeq;
+        const catalog = await fetchPiServerModels({ signal });
+        if (seq !== this.remoteCatalogRefreshSeq)
+            return;
+        this.remoteCatalog = catalog;
+        this.remoteProviderCapabilities = catalog.providers;
+        this.remoteCatalogLoaded = true;
+        this.remoteCatalogError = undefined;
+        this.remoteProjection = undefined;
+    }
     async checkAuth(providerId, options) {
         return this.models.checkAuth(providerId, options);
     }
     async getAvailable(providerId, options) {
+        if (this.piServerMode)
+            return this.getAvailableOfType("chat", providerId, options);
         if (providerId) {
             const errorSeq = ++this.availabilityErrorSeq;
             try {
@@ -325,6 +485,8 @@ export class ModelRuntime {
         return this.snapshot.available;
     }
     getAvailableSnapshot() {
+        if (this.piServerMode)
+            return this.getRemoteModels(true).filter((model) => isModelType(model, "chat"));
         return this.snapshot.available;
     }
     getError() {
@@ -337,6 +499,10 @@ export class ModelRuntime {
         }
         if (this.availabilityError)
             errors.push(`Availability refresh: ${this.availabilityError}`);
+        if (this.remoteCatalogError)
+            errors.push(`pi-server model catalog: ${this.remoteCatalogError}`);
+        for (const [providerId, error] of this.registrationRefreshErrors)
+            errors.push(`Provider "${providerId}" refresh: ${error}`);
         return errors.length > 0 ? errors.join("\n\n") : undefined;
     }
     getRegisteredProviderConfig(providerId) {
@@ -359,6 +525,8 @@ export class ModelRuntime {
         return this.isUsingOAuth(providerId) && this.models.getProvider(providerId)?.auth.oauth?.isSubscription === true;
     }
     hasConfiguredAuth(providerId) {
+        if (this.piServerMode)
+            return this.getRemoteModels(true, providerId).length > 0;
         return this.snapshot.configuredProviders.has(providerId);
     }
     async getAuth(providerOrModel, overrides = {}) {
@@ -475,11 +643,52 @@ export class ModelRuntime {
             },
         };
     }
+    async prepareRemoteRequest(model, options) {
+        if (options?.fetch !== undefined)
+            throw new ModelsError("stream", "pi-server does not support custom fetch implementations");
+        if (options &&
+            "transformPreparedStreamOptions" in options &&
+            options.transformPreparedStreamOptions !== undefined)
+            throw new ModelsError("stream", "pi-server does not support client prepared stream option transforms");
+        const resolution = this.models.getProvider(model.provider)
+            ? await this.getAuth(model, { apiKey: options?.apiKey, env: options?.env, signal: options?.signal })
+            : undefined;
+        let headers = mergeHeaders(mergeHeaders(model.headers, resolution?.auth.headers), options?.headers);
+        const { transformHeaders, ...remoteOptions } = options ?? {};
+        if (transformHeaders)
+            headers = await transformHeaders(headers ?? {});
+        return {
+            model: resolution?.auth.baseUrl ? { ...model, baseUrl: resolution.auth.baseUrl } : model,
+            options: {
+                ...remoteOptions,
+                apiKey: options?.apiKey ?? resolution?.auth.apiKey,
+                headers,
+                env: resolution?.env || options?.env ? { ...resolution?.env, ...options?.env } : undefined,
+            },
+        };
+    }
+    async prepareStreamRequest(model, options) {
+        const { transformPreparedStreamOptions, ...authOptions } = options ?? {};
+        const prepared = await this.prepareRequest(model, authOptions);
+        return {
+            provider: prepared.provider,
+            model: prepared.model,
+            options: transformPreparedStreamOptions
+                ? await transformPreparedStreamOptions(prepared.options, prepared.model)
+                : prepared.options,
+        };
+    }
     stream(model, context, options) {
         const transcript = normalizeContext(context);
         return lazyStream(model, async () => {
             assertChatModel(model);
-            const prepared = await this.prepareRequest(model, options);
+            if (this.piServerMode) {
+                if (isVirtualModel(model))
+                    throw new ModelsError("stream", `Virtual model ${model.provider}/${model.id} must be routed before streaming`);
+                const prepared = await this.prepareRemoteRequest(model, options);
+                return streamRawPiServer(prepared.model, transcript, prepared.options);
+            }
+            const prepared = await this.prepareStreamRequest(model, options);
             return prepared.provider.stream(prepared.model, transcript, prepared.options);
         });
     }
@@ -509,7 +718,11 @@ export class ModelRuntime {
         }
         return lazyStream(model, async () => {
             assertChatModel(model);
-            const prepared = await this.prepareRequest(model, options);
+            if (this.piServerMode) {
+                const prepared = await this.prepareRemoteRequest(model, options);
+                return streamPiServer(prepared.model, transcript, prepared.options);
+            }
+            const prepared = await this.prepareStreamRequest(model, options);
             return prepared.provider.streamSimple(prepared.model, transcript, prepared.options);
         });
     }
@@ -519,7 +732,11 @@ export class ModelRuntime {
     streamDeferred(model, handle, options) {
         return lazyStream(model, async () => {
             assertChatModel(model);
-            const prepared = await this.prepareRequest(model, options);
+            if (this.piServerMode) {
+                const prepared = await this.prepareRemoteRequest(model, options);
+                return fetchDeferredPiServer(prepared.model, handle, prepared.options);
+            }
+            const prepared = await this.prepareStreamRequest(model, options);
             if (!prepared.provider.fetchDeferred) {
                 throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
             }
@@ -531,6 +748,11 @@ export class ModelRuntime {
     }
     async cancelDeferred(model, handle, options) {
         assertChatModel(model);
+        if (this.piServerMode) {
+            const prepared = await this.prepareRemoteRequest(model, options);
+            await cancelDeferredPiServer(prepared.model, handle, prepared.options);
+            return;
+        }
         const prepared = await this.prepareRequest(model, options);
         if (!prepared.provider.cancelDeferred) {
             throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
@@ -540,6 +762,10 @@ export class ModelRuntime {
     async generateImages(model, context, options) {
         try {
             assertImageModel(model);
+            if (this.piServerMode) {
+                const prepared = await this.prepareRemoteRequest(model, options);
+                return await generateImagesPiServer(prepared.model, context, prepared.options);
+            }
             const prepared = await this.prepareRequest(model, options);
             if (!prepared.provider.generateImages) {
                 throw new ModelsError("provider", `Provider ${model.provider} does not support image generation`);
@@ -553,6 +779,10 @@ export class ModelRuntime {
     async classify(model, context, options) {
         try {
             assertClassifierModel(model);
+            if (this.piServerMode) {
+                const prepared = await this.prepareRemoteRequest(model, options);
+                return await classifyPiServer(prepared.model, context, prepared.options);
+            }
             const prepared = await this.prepareRequest(model, options);
             if (!prepared.provider.classify) {
                 throw new ModelsError("provider", `Provider ${model.provider} does not support classification`);
@@ -579,6 +809,60 @@ export class ModelRuntime {
         });
     }
     async refresh(options = {}) {
+        if (options.signal?.aborted)
+            return { aborted: true, errors: new Map() };
+        try {
+            await raceWithAbortSignal(this.registrationRefresh, options.signal);
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                return { aborted: true, errors: new Map() };
+            throw error;
+        }
+        if (this.piServerMode) {
+            this.config = await ModelConfig.load(this.modelsPath);
+            this.configureRadiusProviders();
+            this.rebuildProviders();
+            let result = await this.models.refresh({ ...options, allowNetwork: false });
+            const nativeProviders = [
+                ...new Set([...this.nativeCatalogProviders, ...this.nativeExtensionProviders.keys()]),
+            ].filter((id) => options.providers === undefined || options.providers.includes(id));
+            if ((options.allowNetwork ?? this.modelNetworkEnabled) && nativeProviders.length > 0) {
+                const nativeResult = await this.models.refresh({
+                    ...options,
+                    providers: nativeProviders,
+                    allowNetwork: true,
+                });
+                result = {
+                    aborted: result.aborted || nativeResult.aborted,
+                    errors: new Map([...result.errors, ...nativeResult.errors]),
+                };
+            }
+            const errors = new Map(result.errors);
+            try {
+                await this.queueAvailabilityRefresh(options.signal);
+            }
+            catch (error) {
+                if (!options.signal?.aborted)
+                    errors.set("availability", error instanceof Error ? error : new Error(String(error)));
+            }
+            try {
+                if (!options.signal?.aborted)
+                    await this.refreshRemoteCatalog(options.signal);
+            }
+            catch (error) {
+                if (!options.signal?.aborted) {
+                    const remoteError = error instanceof Error ? error : new Error(String(error));
+                    this.remoteCatalogError = remoteError.message;
+                    errors.set("pi-server", remoteError);
+                }
+            }
+            for (const id of this.registrationRefreshErrors.keys()) {
+                if (!errors.has(id) && (options.providers === undefined || options.providers.includes(id)))
+                    this.registrationRefreshErrors.delete(id);
+            }
+            return { aborted: result.aborted || options.signal?.aborted === true, errors };
+        }
         this.config = await ModelConfig.load(this.modelsPath);
         this.configureRadiusProviders();
         if (options.providers) {
@@ -593,12 +877,7 @@ export class ModelRuntime {
             ...options,
             allowNetwork: options.allowNetwork ?? this.modelNetworkEnabled,
         };
-        // Published pi-ai builds before ModelsStore returned void and accepted a provider ID.
-        // The fallback keeps source-mode CLI tests working without rebuilding workspace dependencies.
-        const result = (await this.models.refresh(refreshOptions)) ?? {
-            aborted: refreshOptions.signal?.aborted ?? false,
-            errors: new Map(),
-        };
+        const result = await this.models.refresh(refreshOptions);
         const errors = new Map(result.errors);
         this.updateModelSnapshot();
         if (options.providers) {
@@ -623,6 +902,21 @@ export class ModelRuntime {
         }
         return { aborted: result.aborted || (options.signal?.aborted ?? false), errors };
     }
+    queueRegistrationRefresh(providerId) {
+        this.registrationRefresh = this.registrationRefresh
+            .then(async () => {
+            const result = await this.models.refresh({ allowNetwork: false, providers: [providerId] });
+            const error = result.errors.get(providerId);
+            if (error)
+                throw error;
+            this.updateModelSnapshot();
+            await this.refreshProviderAvailability(providerId, operationSignal());
+            this.registrationRefreshErrors.delete(providerId);
+        })
+            .catch((error) => {
+            this.registrationRefreshErrors.set(providerId, error instanceof Error ? error.message : String(error));
+        });
+    }
     registerNativeProvider(provider) {
         if (!provider.id.trim())
             throw new Error("Provider id must not be empty.");
@@ -630,7 +924,28 @@ export class ModelRuntime {
         this.nativeExtensionProviders.set(provider.id, provider);
         this.recomposeProvider(provider.id);
         this.updateModelSnapshot();
-        void this.refresh({ allowNetwork: false });
+        this.markProvisionallyConfigured(provider.id, configuredRequestAuthStatus(this.config.getProvider(provider.id), undefined), provider.auth.oauth && !provider.auth.apiKey ? "oauth" : "api_key");
+        this.queueRegistrationRefresh(provider.id);
+    }
+    /**
+     * Mark a newly registered provider as configured when it has a stored credential or a configured
+     * API key. Availability checks run asynchronously, and callers such as initial model selection
+     * read the snapshot before they finish. The next availability pass replaces this entry.
+     */
+    markProvisionallyConfigured(providerId, configuredStatus, type) {
+        if (!this.snapshot.storedProviders.has(providerId) && !configuredStatus?.configured)
+            return;
+        const configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId);
+        const auth = new Map(this.snapshot.auth);
+        // Never clobber a real check result.
+        if (!auth.get(providerId))
+            auth.set(providerId, { type, source: "configured provider" });
+        this.snapshot = {
+            ...this.snapshot,
+            auth,
+            configuredProviders,
+            available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider)),
+        };
     }
     registerProvider(providerId, config) {
         // Validate the incoming registration on its own, like the legacy registry:
@@ -648,32 +963,15 @@ export class ModelRuntime {
         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 });
+        this.markProvisionallyConfigured(providerId, configuredRequestAuthStatus(this.config.getProvider(providerId), effective), effective.oauth && !effective.apiKey ? "oauth" : "api_key");
+        this.queueRegistrationRefresh(providerId);
     }
     unregisterProvider(providerId) {
         this.extensionProviders.delete(providerId);
         this.nativeExtensionProviders.delete(providerId);
         this.recomposeProvider(providerId);
         this.updateModelSnapshot();
-        void this.refresh({ allowNetwork: false });
+        this.queueRegistrationRefresh(providerId);
     }
     /**
      * Register a virtual model under `definition.provider`, which may also list physical models or
@@ -684,7 +982,7 @@ export class ModelRuntime {
         const { provider: providerId, id } = definition;
         if (!providerId.trim() || !id.trim())
             throw new Error("Virtual model provider and id must not be empty.");
-        const existing = this.models.getModel(providerId, id);
+        const existing = this.getModel(providerId, id);
         if (existing && !isVirtualModel(existing)) {
             throw new Error(`Virtual model ${providerId}/${id} conflicts with a physical model.`);
         }
@@ -699,7 +997,7 @@ export class ModelRuntime {
             this.snapshot = { ...this.snapshot, auth, configuredProviders };
         }
         this.updateModelSnapshot();
-        void this.refresh({ allowNetwork: false });
+        this.queueRegistrationRefresh(providerId);
     }
     unregisterVirtualModel(providerId, id) {
         const models = this.virtualModels.get(providerId);
@@ -709,7 +1007,7 @@ export class ModelRuntime {
             this.virtualModels.delete(providerId);
         this.recomposeProvider(providerId);
         this.updateModelSnapshot();
-        void this.refresh({ allowNetwork: false });
+        this.queueRegistrationRefresh(providerId);
     }
     /**
      * Ask a virtual model's router for the model and thinking level of one request. The router must
@@ -747,7 +1045,7 @@ export class ModelRuntime {
     }
     /** A catalog chat model that is not virtual. */
     getPhysicalModel(providerId, modelId) {
-        const model = this.models.getModel(providerId, modelId);
+        const model = this.getModel(providerId, modelId);
         return model && !isVirtualModel(model) ? model : undefined;
     }
 }