@selesai/code 0.13.40 → 0.14.3

package/dist/core/model-registry.d.ts

@@ -1,12 +1,14 @@
-import type { Api, AssistantMessage, AssistantMessageEventStream, AuthResult, Context, Model, ModelsSimpleStreamOptions, Provider } from "@earendil-works/pi-ai";
+import type { Api, AssistantImages, AssistantMessage, AssistantMessageEventStream, AuthOperationOptions, AuthResult, ClassifierApi, ClassifierContext, ClassifierModel, ClassifierResult, Context, ImageApi, ImageModel, ImagesContext, Model, ModelsApiStreamOptions, ModelsClassifierOptions, ModelsImagesOptions, ModelsRefreshOptions, ModelsRefreshResult, ModelsSimpleStreamOptions, ModelType, ModelTypeMap, Provider, ProviderHeaders } from "@earendil-works/pi-ai";
 import type { AuthStorage } from "./auth-storage.ts";
 import type { ModelRuntime } from "./model-runtime.ts";
 import type { AuthStatus, ProviderConfigInput } from "./provider-composer.ts";
+import type { VirtualModelDefinition } from "./virtual-models.ts";
 export type { ProviderConfigInput } from "./provider-composer.ts";
 export type ResolvedRequestAuth = {
     ok: true;
     apiKey?: string;
-    headers?: Record<string, string>;
+    headers?: ProviderHeaders;
+    baseUrl?: string;
     env?: Record<string, string>;
 } | {
     ok: false;
@@ -23,27 +25,31 @@ export declare class ModelRegistry {
     /** Legacy extension access to the default auth.json store. */
     get authStorage(): AuthStorage;
     /** Reload models.json asynchronously. Await before making synchronous registry reads. */
-    refresh(): Promise<void>;
+    refresh(options?: ModelsRefreshOptions): Promise<ModelsRefreshResult>;
     getError(): string | undefined;
     getAll(): Model<Api>[];
     getAvailable(): Model<Api>[];
     find(provider: string, modelId: string): Model<Api> | undefined;
+    /** Find a model of a non-chat type, e.g. `findOfType("classifier", "typesafe", "jev-latest")`. */
+    findOfType<TType extends ModelType>(type: TType, provider: string, modelId: string): ModelTypeMap[TType] | undefined;
     hasConfiguredAuth(model: Model<Api>): boolean;
     getApiKeyAndHeaders(model: Model<Api>): Promise<ResolvedRequestAuth>;
     getProviderAuthStatus(provider: string): AuthStatus;
-    /**
-     * Run a request through the composed provider layer — the same path the agent
-     * uses, so a provider's `streamSimple` override, auth resolution, base-URL
-     * overrides, and header transforms all apply.
-     *
-     * Extensions that call a model directly should use this instead of pi-ai's
-     * compat dispatch, which knows nothing about the providers this runtime
-     * composes (a provider override registered here is invisible to it).
-     */
-    streamSimple(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): AssistantMessageEventStream;
-    /** One non-streaming request through the composed provider layer. */
-    complete(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): Promise<AssistantMessage>;
     getProvider(provider: string): Provider | undefined;
+    /** Stream through the configured provider with request-time authentication. */
+    stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): AssistantMessageEventStream;
+    /** Stream with provider-neutral options and request-time authentication. */
+    streamSimple(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): AssistantMessageEventStream;
+    complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): Promise<AssistantMessage>;
+    /** Every known model of a type (chat, image, classifier), optionally for one provider. */
+    getModelsOfType<TType extends ModelType>(type: TType, provider?: string): readonly ModelTypeMap[TType][];
+    /** Models of a type whose provider has working credentials. */
+    getAvailableOfType<TType extends ModelType>(type: TType, provider?: string, options?: AuthOperationOptions): Promise<readonly ModelTypeMap[TType][]>;
+    getModelOfType<TType extends ModelType>(type: TType, provider: string, modelId: string): ModelTypeMap[TType] | undefined;
+    /** Classify structured state with request-time authentication. Never rejects. */
+    classify(model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options?: ModelsClassifierOptions): Promise<ClassifierResult>;
+    /** Generate images with request-time authentication. Never rejects. */
+    generateImages(model: ImageModel<ImageApi>, context: ImagesContext, options?: ModelsImagesOptions): Promise<AssistantImages>;
     getProviderDisplayName(provider: string): string;
     getProviderAuth(provider: string): Promise<AuthResult | undefined>;
     getApiKeyForProvider(provider: string): Promise<string | undefined>;
@@ -51,6 +57,8 @@ export declare class ModelRegistry {
     registerProvider(provider: Provider): void;
     registerProvider(providerName: string, config: ProviderConfigInput): void;
     unregisterProvider(providerName: string): void;
+    registerVirtualModel(definition: VirtualModelDefinition): void;
+    unregisterVirtualModel(providerName: string, id: string): void;
     getRegisteredProviderConfig(providerName: string): ProviderConfigInput | undefined;
     getRegisteredNativeProvider(providerName: string): Provider | undefined;
     getRegisteredProviderIds(): readonly string[];

package/dist/core/model-registry.js

@@ -13,8 +13,8 @@ export class ModelRegistry {
         return this.runtime.getCredentialStore();
     }
     /** Reload models.json asynchronously. Await before making synchronous registry reads. */
-    async refresh() {
-        await this.runtime.refresh();
+    refresh(options) {
+        return this.runtime.refresh(options);
     }
     getError() {
         return this.runtime.getError();
@@ -28,6 +28,10 @@ export class ModelRegistry {
     find(provider, modelId) {
         return this.runtime.getModel(provider, modelId);
     }
+    /** Find a model of a non-chat type, e.g. `findOfType("classifier", "typesafe", "jev-latest")`. */
+    findOfType(type, provider, modelId) {
+        return this.runtime.getModelOfType(type, provider, modelId);
+    }
     hasConfiguredAuth(model) {
         return this.runtime.hasConfiguredAuth(model.provider);
     }
@@ -39,15 +43,15 @@ export class ModelRegistry {
                 if (compatibility.authHeader) {
                     return { ok: false, error: `No API key found for "${model.provider}"` };
                 }
-                const headers = compatibility.headers
-                    ? Object.fromEntries(Object.entries(compatibility.headers).filter((entry) => entry[1] !== null))
-                    : undefined;
-                return { ok: true, headers };
+                return { ok: true, headers: compatibility.headers };
             }
-            const headers = resolution.auth.headers
-                ? Object.fromEntries(Object.entries(resolution.auth.headers).filter((entry) => entry[1] !== null))
-                : undefined;
-            return { ok: true, apiKey: resolution.auth.apiKey, headers, env: resolution.env };
+            return {
+                ok: true,
+                apiKey: resolution.auth.apiKey,
+                headers: resolution.auth.headers,
+                ...(resolution.auth.baseUrl ? { baseUrl: resolution.auth.baseUrl } : {}),
+                env: resolution.env,
+            };
         }
         catch (error) {
             const cause = error instanceof Error ? error.cause : undefined;
@@ -63,24 +67,38 @@ export class ModelRegistry {
     getProviderAuthStatus(provider) {
         return this.runtime.getProviderAuthStatus(provider);
     }
-    /**
-     * Run a request through the composed provider layer — the same path the agent
-     * uses, so a provider's `streamSimple` override, auth resolution, base-URL
-     * overrides, and header transforms all apply.
-     *
-     * Extensions that call a model directly should use this instead of pi-ai's
-     * compat dispatch, which knows nothing about the providers this runtime
-     * composes (a provider override registered here is invisible to it).
-     */
+    getProvider(provider) {
+        return this.runtime.getProvider(provider);
+    }
+    /** Stream through the configured provider with request-time authentication. */
+    stream(model, context, options) {
+        return this.runtime.stream(model, context, options);
+    }
+    /** Stream with provider-neutral options and request-time authentication. */
     streamSimple(model, context, options) {
         return this.runtime.streamSimple(model, context, options);
     }
-    /** One non-streaming request through the composed provider layer. */
     complete(model, context, options) {
         return this.runtime.complete(model, context, options);
     }
-    getProvider(provider) {
-        return this.runtime.getProvider(provider);
+    /** Every known model of a type (chat, image, classifier), optionally for one provider. */
+    getModelsOfType(type, provider) {
+        return this.runtime.getModelsOfType(type, provider);
+    }
+    /** Models of a type whose provider has working credentials. */
+    getAvailableOfType(type, provider, options) {
+        return this.runtime.getAvailableOfType(type, provider, options);
+    }
+    getModelOfType(type, provider, modelId) {
+        return this.runtime.getModelOfType(type, provider, modelId);
+    }
+    /** Classify structured state with request-time authentication. Never rejects. */
+    classify(model, context, options) {
+        return this.runtime.classify(model, context, options);
+    }
+    /** Generate images with request-time authentication. Never rejects. */
+    generateImages(model, context, options) {
+        return this.runtime.generateImages(model, context, options);
     }
     getProviderDisplayName(provider) {
         return this.runtime.getProvider(provider)?.name ?? provider;
@@ -111,6 +129,12 @@ export class ModelRegistry {
     unregisterProvider(providerName) {
         this.runtime.unregisterProvider(providerName);
     }
+    registerVirtualModel(definition) {
+        this.runtime.registerVirtualModel(definition);
+    }
+    unregisterVirtualModel(providerName, id) {
+        this.runtime.unregisterVirtualModel(providerName, id);
+    }
     getRegisteredProviderConfig(providerName) {
         return this.runtime.getRegisteredProviderConfig(providerName);
     }

package/dist/core/model-resolver.d.ts

@@ -2,10 +2,10 @@
  * Model resolution, scoping, and initial selection
  */
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { type Api, type KnownProvider, type Model } from "@earendil-works/pi-ai";
+import { type Api, type AuthOperationOptions, type KnownProvider, type Model } from "@earendil-works/pi-ai";
 import type { ModelRuntime } from "./model-runtime.ts";
-/** Default model IDs for each known provider */
-export declare const defaultModelPerProvider: Record<KnownProvider, string>;
+/** Default chat model IDs for providers with built-in chat models. */
+export declare const defaultModelPerProvider: Partial<Record<KnownProvider, string>>;
 export interface ScopedModel {
     model: Model<Api>;
     /** Thinking level if explicitly specified in pattern (e.g., "model:high"), undefined otherwise */
@@ -60,8 +60,9 @@ export interface ResolveModelScopeResult {
     scopedModels: ScopedModel[];
     diagnostics: ModelScopeDiagnostic[];
 }
-export declare function resolveModelScopeWithDiagnostics(patterns: string[], modelRuntime: ModelRuntime): Promise<ResolveModelScopeResult>;
-export declare function resolveModelScope(patterns: string[], modelRuntime: ModelRuntime): Promise<ScopedModel[]>;
+export declare function resolveModelScopeFromModels(patterns: string[], models: readonly Model<Api>[]): ResolveModelScopeResult;
+export declare function resolveModelScopeWithDiagnostics(patterns: string[], modelRuntime: ModelRuntime, options?: AuthOperationOptions): Promise<ResolveModelScopeResult>;
+export declare function resolveModelScope(patterns: string[], modelRuntime: ModelRuntime, options?: AuthOperationOptions): Promise<ScopedModel[]>;
 export interface ResolveCliModelResult {
     model: Model<Api> | undefined;
     thinkingLevel?: ThinkingLevel;

package/dist/core/model-resolver.js

@@ -1,43 +1,43 @@
 /**
  * Model resolution, scoping, and initial selection
  */
-import { modelsAreEqual } from "@earendil-works/pi-ai";
+import { modelsAreEqual, } from "@earendil-works/pi-ai";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
 import { isValidThinkingLevel } from "../cli/args.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
-/** Default model IDs for each known provider */
+/** Default chat model IDs for providers with built-in chat models. */
 export const defaultModelPerProvider = {
     "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
     "ant-ling": "Ring-2.6-1T",
     anthropic: "claude-opus-4-8",
     openai: "gpt-5.5",
-    "azure-openai-responses": "gpt-5.4",
-    "openai-codex": "gpt-5.5",
+    azure: "gpt-5.4",
+    "openai-codex": "gpt-6.1-sol",
     radius: "balanced",
-    nvidia: "nvidia/nemotron-3-super-120b-a12b",
+    nvidia: "nvidia/nemotron-3-ultra-550b-a55b",
     deepseek: "deepseek-v4-pro",
     google: "gemini-3.1-pro-preview",
     "google-vertex": "gemini-3.1-pro-preview",
     "github-copilot": "gpt-5.4",
     openrouter: "moonshotai/kimi-k2.6",
     "vercel-ai-gateway": "zai/glm-5.1",
-    xai: "grok-4.5",
+    xai: "grok-4.7",
     groq: "openai/gpt-oss-120b",
-    cerebras: "zai-glm-4.7",
-    zai: "glm-5.1",
-    "zai-coding-cn": "glm-5.1",
+    cerebras: "gpt-oss-120b",
+    zai: "glm-5.3",
+    "zai-coding-cn": "glm-5.3",
     mistral: "devstral-medium-latest",
     minimax: "MiniMax-M2.7",
     "minimax-cn": "MiniMax-M2.7",
     moonshotai: "kimi-k2.6",
     "moonshotai-cn": "kimi-k2.6",
     huggingface: "moonshotai/Kimi-K2.6",
-    fireworks: "accounts/fireworks/models/kimi-k2p6",
-    together: "moonshotai/Kimi-K2.6",
+    fireworks: "accounts/fireworks/models/kimi-k3",
+    together: "moonshotai/Kimi-K3",
     baseten: "zai-org/GLM-5.2",
     opencode: "kimi-k2.6",
-    "opencode-go": "kimi-k2.6",
+    "opencode-go": "kimi-k3",
     "kimi-coding": "kimi-for-coding",
     meta: "muse-spark-1.3",
     "cloudflare-workers-ai": "@cf/moonshotai/kimi-k2.6",
@@ -201,8 +201,8 @@ export function parseModelPattern(pattern, availableModels, options) {
         return result;
     }
 }
-export async function resolveModelScopeWithDiagnostics(patterns, modelRuntime) {
-    const availableModels = [...(await modelRuntime.getAvailable())];
+export function resolveModelScopeFromModels(patterns, models) {
+    const availableModels = [...models];
     const scopedModels = [];
     const diagnostics = [];
     for (const pattern of patterns) {
@@ -268,8 +268,11 @@ export async function resolveModelScopeWithDiagnostics(patterns, modelRuntime) {
     }
     return { scopedModels, diagnostics };
 }
-export async function resolveModelScope(patterns, modelRuntime) {
-    const { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics(patterns, modelRuntime);
+export async function resolveModelScopeWithDiagnostics(patterns, modelRuntime, options) {
+    return resolveModelScopeFromModels(patterns, await modelRuntime.getAvailable(undefined, options));
+}
+export async function resolveModelScope(patterns, modelRuntime, options) {
+    const { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics(patterns, modelRuntime, options);
     for (const diagnostic of diagnostics) {
         console.warn(chalk.yellow(`Warning: ${diagnostic.message}`));
     }
@@ -335,11 +338,38 @@ export function resolveCliModel(options) {
     }
     // If no provider was inferred from the slash, try exact matches without provider inference.
     // This handles models whose IDs naturally contain slashes (e.g. OpenRouter-style IDs).
+    // Bare exact IDs can exist in multiple providers, so do not choose by catalog order.
+    // Prefer the sole authenticated provider when there is one; otherwise require an
+    // explicit provider to avoid silently selecting an unusable provider.
     if (!provider) {
         const lower = cliModel.toLowerCase();
-        const exact = availableModels.find((m) => m.id.toLowerCase() === lower || `${m.provider}/${m.id}`.toLowerCase() === lower);
-        if (exact) {
-            return { model: exact, warning: undefined, thinkingLevel: undefined, error: undefined };
+        const exactMatches = availableModels.filter((m) => m.id.toLowerCase() === lower || `${m.provider}/${m.id}`.toLowerCase() === lower);
+        if (exactMatches.length === 1) {
+            return { model: exactMatches[0], warning: undefined, thinkingLevel: undefined, error: undefined };
+        }
+        if (exactMatches.length > 1) {
+            const authenticatedExactMatches = exactMatches.filter((m) => modelRuntime.hasConfiguredAuth(m.provider));
+            if (authenticatedExactMatches.length === 1) {
+                return {
+                    model: authenticatedExactMatches[0],
+                    warning: undefined,
+                    thinkingLevel: undefined,
+                    error: undefined,
+                };
+            }
+            const matches = exactMatches
+                .map((m) => `${m.provider}/${m.id}`)
+                .sort((a, b) => a.localeCompare(b))
+                .join(", ");
+            const authHint = authenticatedExactMatches.length === 0
+                ? "No matching provider is authenticated."
+                : "More than one matching provider is authenticated.";
+            return {
+                model: undefined,
+                warning: undefined,
+                thinkingLevel: undefined,
+                error: `Model "${cliModel}" is ambiguous across providers: ${matches}. ${authHint} Use --provider or provider/model.`,
+            };
         }
     }
     if (cliProvider && provider) {
@@ -485,7 +515,7 @@ export async function findInitialModel(options) {
         }
     }
     // 4. Try first available model with valid API key
-    const availableModels = [...(await modelRuntime.getAvailable())];
+    const availableModels = [...modelRuntime.getAvailableSnapshot()];
     if (availableModels.length > 0) {
         // Try to find a default model from known providers
         for (const provider of Object.keys(defaultModelPerProvider)) {
@@ -530,7 +560,7 @@ export async function restoreModelFromSession(savedProvider, savedModelId, curre
         };
     }
     // Try to find any available model
-    const availableModels = [...(await modelRuntime.getAvailable())];
+    const availableModels = [...modelRuntime.getAvailableSnapshot()];
     if (availableModels.length > 0) {
         // Try to find a default model from known providers
         let fallbackModel;

package/dist/core/model-runtime.d.ts

@@ -1,5 +1,6 @@
-import { type Api, type AssistantMessage, type AssistantMessageEventStream, type AuthCheck, type AuthInteraction, type AuthOperationOptions, type AuthResult, type AuthType, type Context, type Credential, type CredentialInfo, type CredentialStore, type DeferredHandle, type Model, type Models, type ModelsApiStreamOptions, type ModelsDeferredCancelOptions, type ModelsDeferredFetchOptions, type ModelsRefreshOptions, type ModelsRefreshResult, type ModelsSimpleStreamOptions, type ModelsStore, type Provider } from "@earendil-works/pi-ai";
+import { type AnyModel, type Api, type AssistantImages, type AssistantMessage, type AssistantMessageEventStream, type AuthCheck, type AuthInteraction, type AuthOperationOptions, type AuthResult, type AuthType, type ClassifierApi, type ClassifierContext, type ClassifierModel, type ClassifierResult, type Context, type Credential, type CredentialInfo, type CredentialStore, type DeferredHandle, type ImageApi, type ImageModel, type ImagesContext, type LoginOptions, type Message, type Model, type Models, type ModelsApiStreamOptions, type ModelsClassifierOptions, type ModelsDeferredCancelOptions, type ModelsDeferredFetchOptions, type ModelsImagesOptions, type ModelsRefreshOptions, type ModelsRefreshResult, type ModelsSimpleStreamOptions, type ModelsStore, type ModelThinkingLevel, type ModelType, type ModelTypeMap, type Provider } from "@earendil-works/pi-ai";
 import { type AuthStatus, type CompatibilityRequestConfig, type ProviderConfigInput } from "./provider-composer.ts";
+import { type ModelRoute, type ModelRouteReason, type VirtualModelDefinition } from "./virtual-models.ts";
 export interface CreateModelRuntimeOptions {
     /** Credential storage. Defaults to the file at authPath. */
     credentials?: CredentialStore;
@@ -12,6 +13,10 @@ export interface CreateModelRuntimeOptions {
     /** Timeout for the create-time network model refresh. */
     modelRefreshTimeoutMs?: number;
     catalogBaseUrl?: string;
+    /** Optional caller cancellation for initial cache restoration and availability checks. */
+    signal?: AbortSignal;
+    /** Skip initial catalog and availability refresh. Static models remain available. */
+    refreshOnCreate?: boolean;
 }
 export interface ModelRuntimeAuthOverrides extends AuthOperationOptions {
     apiKey?: string;
@@ -19,6 +24,14 @@ export interface ModelRuntimeAuthOverrides extends AuthOperationOptions {
     /** Require this much remaining OAuth-token validity; defaults to five minutes. */
     minOAuthValidityMs?: number;
 }
+export type CredentialSynchronizationOperation = "login" | "logout" | "setRuntimeApiKey" | "removeRuntimeApiKey";
+/** Credentials changed successfully, but the local model/auth snapshot could not be synchronized. */
+export declare class CredentialSynchronizationError extends Error {
+    readonly providerId: string;
+    readonly operation: CredentialSynchronizationOperation;
+    readonly credential: Credential | undefined;
+    constructor(providerId: string, operation: CredentialSynchronizationOperation, credential: Credential | undefined, options: ErrorOptions);
+}
 /** Configured pi-ai Models collection used by coding-agent and SDK consumers. */
 export declare class ModelRuntime implements Models {
     private readonly models;
@@ -27,32 +40,42 @@ export declare class ModelRuntime implements Models {
     private readonly builtins;
     private readonly nativeExtensionProviders;
     private readonly extensionProviders;
+    /** Virtual models by provider id, then model id. */
+    private readonly virtualModels;
     private readonly compositionErrors;
     private readonly modelsPath;
     private readonly modelNetworkEnabled;
     private config;
     private snapshot;
-    private availabilityRefresh;
+    private availabilityRefreshSeq;
+    private availabilityErrorSeq;
+    private readonly providerAvailabilitySeq;
     private availabilityError;
+    private readonly credentialOperations;
     private constructor();
     static create(options?: CreateModelRuntimeOptions): Promise<ModelRuntime>;
     private configureRadiusProviders;
     private providerIds;
+    /** Returns the provider without virtual models, or undefined when only virtual models define it. */
     private recomposeProvider;
+    /** The provider without virtual models, or undefined when nothing defines it. */
+    private composeProvider;
     private rebuildProviders;
     private updateModelSnapshot;
     private runAvailabilityRefresh;
     private queueAvailabilityRefresh;
-    /** Coalesce concurrent readers onto the pending refresh. */
-    private refreshAvailability;
-    /** Mutations must not observe an in-flight refresh started before them. */
-    private forceRefreshAvailability;
+    private refreshProviderAvailability;
     getProviders(): readonly Provider[];
     getProvider(providerId: string): Provider | undefined;
     getModels(providerId?: string): readonly Model<Api>[];
     getModel(providerId: string, modelId: string): Model<Api> | undefined;
-    checkAuth(providerId: string): Promise<AuthCheck | undefined>;
-    getAvailable(providerId?: string): Promise<readonly Model<Api>[]>;
+    getModelsOfType<TType extends ModelType>(type: TType, providerId?: string): readonly ModelTypeMap[TType][];
+    getModelOfType<TType extends ModelType>(type: TType, providerId: string, modelId: string): ModelTypeMap[TType] | undefined;
+    getAllModels(providerId?: string): readonly AnyModel[];
+    getAvailableOfType<TType extends ModelType>(type: TType, providerId?: string, options?: AuthOperationOptions): Promise<readonly ModelTypeMap[TType][]>;
+    getAllAvailable(providerId?: string, options?: AuthOperationOptions): Promise<readonly AnyModel[]>;
+    checkAuth(providerId: string, options?: AuthOperationOptions): Promise<AuthCheck | undefined>;
+    getAvailable(providerId?: string, options?: AuthOperationOptions): Promise<readonly Model<Api>[]>;
     getAvailableSnapshot(): readonly Model<Api>[];
     getError(): string | undefined;
     getRegisteredProviderConfig(providerId: string): ProviderConfigInput | undefined;
@@ -61,12 +84,15 @@ export declare class ModelRuntime implements Models {
     /** @internal Compatibility fallback for ModelRegistry when provider auth is unconfigured. */
     getCompatibilityRequestConfig(model: Model<Api>): CompatibilityRequestConfig;
     isUsingOAuth(providerId: string): boolean;
+    isUsingSubscription(providerId: string): boolean;
     hasConfiguredAuth(providerId: string): boolean;
     getAuth(providerId: string, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
-    getAuth(model: Model<Api>, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
-    setRuntimeApiKey(providerId: string, apiKey: string, refreshOptions?: ModelsRefreshOptions): Promise<void>;
-    removeRuntimeApiKey(providerId: string): Promise<void>;
-    listCredentials(): Promise<readonly CredentialInfo[]>;
+    getAuth(model: AnyModel, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
+    private enqueueCredentialOperation;
+    private synchronizeCredentialState;
+    setRuntimeApiKey(providerId: string, apiKey: string, options?: AuthOperationOptions): Promise<void>;
+    removeRuntimeApiKey(providerId: string, options?: AuthOperationOptions): Promise<void>;
+    listCredentials(options?: AuthOperationOptions): Promise<readonly CredentialInfo[]>;
     getProviderAuthStatus(providerId: string): AuthStatus;
     private prepareRequest;
     stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): AssistantMessageEventStream;
@@ -76,12 +102,45 @@ export declare class ModelRuntime implements Models {
     streamDeferred(model: Model<Api>, handle: DeferredHandle, options?: ModelsDeferredFetchOptions): AssistantMessageEventStream;
     fetchDeferred(model: Model<Api>, handle: DeferredHandle, options?: ModelsDeferredFetchOptions): Promise<AssistantMessage>;
     cancelDeferred(model: Model<Api>, handle: DeferredHandle, options?: ModelsDeferredCancelOptions): Promise<void>;
-    login(providerId: string, type: AuthType, interaction: AuthInteraction): Promise<Credential>;
-    logout(providerId: string): Promise<void>;
+    generateImages(model: ImageModel<ImageApi>, context: ImagesContext, options?: ModelsImagesOptions): Promise<AssistantImages>;
+    classify(model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options?: ModelsClassifierOptions): Promise<ClassifierResult>;
+    login(providerId: string, type: AuthType, interaction: AuthInteraction, options?: LoginOptions): Promise<Credential>;
+    logout(providerId: string, options?: AuthOperationOptions): Promise<void>;
     getCredentialStore(): CredentialStore;
     reloadConfig(): Promise<void>;
     refresh(options?: ModelsRefreshOptions): Promise<ModelsRefreshResult>;
     registerNativeProvider(provider: Provider): void;
+    /**
+     * 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.
+     */
+    private markProvisionallyConfigured;
     registerProvider(providerId: string, config: ProviderConfigInput): void;
     unregisterProvider(providerId: string): void;
+    /**
+     * Register a virtual model under `definition.provider`, which may also list physical models or
+     * several virtual models. Re-registering the same provider and id replaces the virtual model.
+     * Throws when the id belongs to a physical model of that provider.
+     */
+    registerVirtualModel(definition: VirtualModelDefinition): void;
+    unregisterVirtualModel(providerId: string, id: string): void;
+    /**
+     * Ask a virtual model's router for the model and thinking level of one request. The router must
+     * return a physical catalog model whose provider has credentials; the thinking level is clamped
+     * to that model. Throws when routing fails.
+     *
+     * `previous` reports the latest successful response in `messages`. A retry passes the failed
+     * response as `options.failed`; `messages` no longer contains it. `options.state` is the router
+     * state stored by the caller, which also stores the returned state.
+     */
+    resolveModel(model: Model<Api>, messages: readonly Message[], options: {
+        reason: ModelRouteReason;
+        thinkingLevel: ModelThinkingLevel;
+        signal?: AbortSignal;
+        failed?: AssistantMessage;
+        state?: unknown;
+    }): Promise<ModelRoute>;
+    /** A catalog chat model that is not virtual. */
+    getPhysicalModel(providerId: string, modelId: string): Model<Api> | undefined;
 }