@schlenkr/ragents 0.1.5 → 0.1.6

package/packages/agent/src/core/model-runtime.ts

@@ -1,517 +1,159 @@
-import { dirname, join } from "node:path";
 import {
 	type Api,
-	type ApiStreamOptions,
 	type AssistantMessage,
+	type AssistantMessageEvent,
 	type AssistantMessageEventStream,
 	type AuthCheck,
-	type AuthInteraction,
 	type AuthResult,
-	type AuthType,
 	type Context,
-	type Credential,
-	type CredentialInfo,
-	type CredentialStore,
 	createModels,
 	lazyStream,
 	type Model,
-	type Models,
-	type ModelsApiStreamOptions,
-	ModelsError,
-	type ModelsRefreshOptions,
-	type ModelsRefreshResult,
-	type ModelsSimpleStreamOptions,
-	type ModelsStore,
-	type ModelsStreamTransforms,
 	type MutableModels,
 	type Provider,
-	type ProviderHeaders,
 	type SimpleStreamOptions,
-	type StreamOptions,
-} from "@aicontainer/ai";
-import * as builtinProviderCatalog from "@aicontainer/ai/providers/all";
-import { getAgentDir } from "../config.ts";
-import { AuthStorage as DefaultAuthStorage } from "./auth-storage.ts";
-import { ModelConfig } from "./model-config.ts";
-import {
-	type AuthStatus,
-	type CompatibilityRequestConfig,
-	composeModelProvider,
-	configuredRequestAuthStatus,
-	type ProviderConfigInput,
-	resolveCompatibilityRequestConfig,
-	resolveConfiguredModelHeaders,
-	validateExtensionProvider,
-} from "./provider-composer.ts";
-import { RuntimeCredentials } from "./runtime-credentials.ts";
-
-interface ModelRuntimeSnapshot {
-	all: readonly Model<Api>[];
-	available: readonly Model<Api>[];
-	configuredProviders: ReadonlySet<string>;
-	storedProviders: ReadonlySet<string>;
-	auth: ReadonlyMap<string, AuthCheck | undefined>;
-}
-
-export interface CreateModelRuntimeOptions {
-	/** Credential storage. Defaults to the file at authPath. */
-	credentials?: CredentialStore;
-	authPath?: string;
-	modelsPath?: string | null;
-	modelRefreshTimeoutMs?: number;
+} from "@ragents/ai";
+import { builtinProviders } from "@ragents/ai/providers/all";
+import { composeModelProvider, type ProviderConfigInput } from "./provider-composer.ts";
+
+/** A name under which a model of another provider is offered; only the alias is visible to callers. */
+export interface ModelAlias {
+	readonly alias: string;
+	readonly upstream: string;
+	readonly model: string;
 }
 
-export interface ModelRuntimeAuthOverrides {
-	apiKey?: string;
-	env?: Record<string, string>;
+interface AliasRegistration {
+	readonly provider: string;
+	readonly aliases: ReadonlyMap<string, ModelAlias>;
 }
 
-function mergeHeaders(
-	base: ProviderHeaders | undefined,
-	override: ProviderHeaders | undefined,
-): ProviderHeaders | undefined {
-	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;
+/** The metadata of the target under the alias as id and name, with the alias provider as provider. */
+export function aliasedModel(providerId: string, alias: string, target: Model<Api>): Model<Api> {
+	return { ...target, id: alias, name: alias, provider: providerId };
 }
 
-/** Configured Models collection used by coding-agent and SDK consumers. */
-export class ModelRuntime implements Models {
-	private readonly models: MutableModels;
-	private readonly credentials: RuntimeCredentials;
-	private readonly defaultBuiltins: ReadonlyMap<string, Provider>;
-	private readonly builtins = new Map<string, Provider>();
-	private readonly extensionProviders = new Map<string, ProviderConfigInput>();
-	private readonly compositionErrors = new Map<string, string>();
-	private readonly modelsPath: string | undefined;
-	private config: ModelConfig;
-	private snapshot: ModelRuntimeSnapshot = {
-		all: [],
-		available: [],
-		configuredProviders: new Set(),
-		storedProviders: new Set(),
-		auth: new Map(),
-	};
-	private availabilityRefresh: Promise<void> | undefined;
-	private availabilityError: string | undefined;
+/** The built-in providers plus the ones registered at runtime; a key comes from the registration or the environment. */
+export class ModelRuntime {
+	private readonly models: MutableModels = createModels();
+	private readonly builtins: ReadonlyMap<string, Provider>;
+	private readonly registrations = new Map<string, ProviderConfigInput>();
+	private aliasRegistration: AliasRegistration | undefined;
 
-	private constructor(
-		credentials: RuntimeCredentials,
-		config: ModelConfig,
-		modelsPath: string | undefined,
-		providers: readonly Provider[],
-	) {
-		this.credentials = credentials;
-		this.config = config;
-		this.modelsPath = modelsPath;
-		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 });
-		this.rebuildProviders();
+	private constructor() {
+		this.builtins = new Map(builtinProviders().map((provider) => [provider.id, provider]));
+		for (const provider of this.builtins.values()) this.models.setProvider(provider);
 	}
 
-	static async create(options: CreateModelRuntimeOptions = {}): Promise<ModelRuntime> {
-		const credentials = new RuntimeCredentials(options.credentials ?? DefaultAuthStorage.create(options.authPath));
-		const modelsPath =
-			options.modelsPath === null ? undefined : (options.modelsPath ?? join(getAgentDir(), "models.json"));
-		const config = await ModelConfig.load(modelsPath);
-		const runtime = new ModelRuntime(credentials, config, modelsPath, builtinProviderCatalog.builtinProviders());
-		runtime.resetBuiltins();
-		runtime.rebuildProviders();
-		await runtime.refresh();
-		return runtime;
-	}
-
-	private resetBuiltins(): void {
-		this.builtins.clear();
-		for (const [providerId, provider] of this.defaultBuiltins) this.builtins.set(providerId, provider);
-	}
-
-	private providerIds(): Set<string> {
-		return new Set([...this.builtins.keys(), ...this.config.getProviderIds(), ...this.extensionProviders.keys()]);
-	}
-
-	private recomposeProvider(providerId: string): void {
-		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 overlays: use the builtin untouched so its auth/login/stream behavior is exact.
-			this.models.setProvider(base);
-			this.compositionErrors.delete(providerId);
-			return;
-		}
-		try {
-			this.models.setProvider(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(base);
-			else this.models.deleteProvider(providerId);
-		}
-	}
-
-	private rebuildProviders(): void {
-		this.models.clearProviders();
-		this.compositionErrors.clear();
-		for (const providerId of this.providerIds()) this.recomposeProvider(providerId);
-		this.updateModelSnapshot();
-	}
-
-	private updateModelSnapshot(): void {
-		const all = [...this.models.getModels()];
-		this.snapshot = {
-			...this.snapshot,
-			all,
-			available: all.filter((model) => this.snapshot.configuredProviders.has(model.provider)),
-		};
-	}
-
-	private async runAvailabilityRefresh(): Promise<void> {
-		const providers = this.models.getProviders();
-		const [available, checks, credentials] = await Promise.all([
-			this.models.getAvailable(),
-			Promise.all(
-				providers.map(
-					async (provider): Promise<[string, AuthCheck | undefined]> => [
-						provider.id,
-						await this.models.checkAuth(provider.id),
-					],
-				),
-			),
-			this.credentials.list(),
-		]);
-		const auth = new Map(checks);
-		const configuredProviders = new Set(
-			checks
-				.filter((entry): entry is [string, AuthCheck] => entry[1] !== undefined)
-				.map(([providerId]) => providerId),
-		);
-		this.snapshot = {
-			all: [...this.models.getModels()],
-			available: [...available],
-			configuredProviders,
-			storedProviders: new Set(credentials.map((entry) => entry.providerId)),
-			auth,
-		};
-		this.availabilityError = undefined;
-	}
-
-	private queueAvailabilityRefresh(after: Promise<void> | undefined): Promise<void> {
-		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. */
-	private refreshAvailability(): Promise<void> {
-		return this.availabilityRefresh ?? this.queueAvailabilityRefresh(undefined);
-	}
-
-	/** Mutations must not observe an in-flight refresh started before them. */
-	private forceRefreshAvailability(): Promise<void> {
-		return this.queueAvailabilityRefresh(this.availabilityRefresh);
-	}
-
-	getProviders(): readonly Provider[] {
-		return this.models.getProviders();
-	}
-
-	getProvider(providerId: string): Provider | undefined {
-		return this.models.getProvider(providerId);
+	static create(): ModelRuntime {
+		return new ModelRuntime();
 	}
 
 	getModels(providerId?: string): readonly Model<Api>[] {
-		return this.models.getModels(providerId);
+		if (providerId !== undefined && providerId === this.aliasRegistration?.provider) return this.aliasModels();
+		const models = this.models.getModels(providerId);
+		return providerId === undefined ? [...models, ...this.aliasModels()] : models;
 	}
 
 	getModel(providerId: string, modelId: string): Model<Api> | undefined {
+		if (providerId === this.aliasRegistration?.provider) return this.aliasModels().find((model) => model.id === modelId);
 		return this.models.getModel(providerId, modelId);
 	}
 
 	async checkAuth(providerId: string): Promise<AuthCheck | undefined> {
-		return this.models.checkAuth(providerId);
-	}
-
-	async getAvailable(providerId?: string): Promise<readonly Model<Api>[]> {
-		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(): readonly Model<Api>[] {
-		return this.snapshot.available;
+		const registration = this.aliasRegistration;
+		if (providerId !== registration?.provider) return this.models.checkAuth(providerId);
+		const upstreams = [...new Set([...registration.aliases.values()].map((entry) => entry.upstream))];
+		const checks = await Promise.all(upstreams.map((upstream) => this.models.checkAuth(upstream)));
+		return checks.every((check) => check !== undefined) ? checks[0] : undefined;
 	}
 
-	getError(): string | undefined {
-		const errors: string[] = [];
-		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;
+	getAuth(model: Model<Api>): Promise<AuthResult | undefined> {
+		return this.models.getAuth(this.targetOf(model) ?? model);
 	}
 
-	getRegisteredProviderConfig(providerId: string): ProviderConfigInput | undefined {
-		return this.extensionProviders.get(providerId);
+	streamSimple(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+		const target = this.targetOf(model);
+		if (!target) return this.models.streamSimple(model, context, options);
+		const source = this.models.streamSimple(target, withTargetHistory(context, model, target), options);
+		return lazyStream(model, async () => relabeledEvents(source, model, target));
 	}
 
-	getRegisteredProviderIds(): readonly string[] {
-		return [...this.extensionProviders.keys()];
-	}
-
-	/** @internal Compatibility fallback for ModelRegistry when provider auth is unconfigured. */
-	getCompatibilityRequestConfig(model: Model<Api>): CompatibilityRequestConfig {
-		return resolveCompatibilityRequestConfig(
-			model,
-			this.config.getProvider(model.provider),
-			this.extensionProviders.get(model.provider),
-		);
-	}
-
-	isUsingOAuth(providerId: string): boolean {
-		return this.snapshot.auth.get(providerId)?.type === "oauth";
-	}
-
-	hasConfiguredAuth(providerId: string): boolean {
-		return this.snapshot.configuredProviders.has(providerId);
-	}
-
-	getAuth(providerId: string, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
-	getAuth(model: Model<Api>, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
-	async getAuth(
-		providerOrModel: string | Model<Api>,
-		overrides: ModelRuntimeAuthOverrides = {},
-	): Promise<AuthResult | undefined> {
-		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),
-			},
-		};
-	}
-
-	async setRuntimeApiKey(providerId: string, apiKey: string): Promise<void> {
-		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();
-	}
-
-	async removeRuntimeApiKey(providerId: string): Promise<void> {
-		this.credentials.removeRuntimeApiKey(providerId);
-		await this.refresh();
-	}
-
-	listCredentials(): Promise<readonly CredentialInfo[]> {
-		return this.credentials.list();
-	}
-
-	getProviderAuthStatus(providerId: string): AuthStatus {
-		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 };
+	completeSimple(model: Model<Api>, context: Context, options?: SimpleStreamOptions): Promise<AssistantMessage> {
+		return this.streamSimple(model, context, options).result();
 	}
 
-	private async prepareRequest(
-		model: Model<Api>,
-		options: (StreamOptions & ModelsStreamTransforms) | undefined,
-	): Promise<{ provider: Provider; model: Model<Api>; options: StreamOptions }> {
-		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,
-			},
+	/** A repeated registration keeps the earlier values it does not set; an invalid one throws and changes nothing. */
+	registerProvider(providerId: string, config: ProviderConfigInput): void {
+		if (providerId === this.aliasRegistration?.provider) throw new Error(`Provider ${providerId} is the alias provider.`);
+		const effective: ProviderConfigInput = {
+			...this.registrations.get(providerId),
+			...Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined)),
 		};
-	}
-
-	stream<TApi extends Api>(
-		model: Model<TApi>,
-		context: Context,
-		options?: ModelsApiStreamOptions<TApi>,
-	): AssistantMessageEventStream {
-		return lazyStream(model, async () => {
-			const prepared = await this.prepareRequest(
-				model,
-				options as (StreamOptions & ModelsStreamTransforms) | undefined,
-			);
-			return prepared.provider.stream(
-				prepared.model as Model<TApi>,
-				context,
-				prepared.options as ApiStreamOptions<TApi>,
-			);
-		});
-	}
-
-	complete<TApi extends Api>(
-		model: Model<TApi>,
-		context: Context,
-		options?: ModelsApiStreamOptions<TApi>,
-	): Promise<AssistantMessage> {
-		return this.stream(model, context, options).result();
-	}
-
-	streamSimple(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): AssistantMessageEventStream {
-		return lazyStream(model, async () => {
-			const prepared = await this.prepareRequest(model, options);
-			return prepared.provider.streamSimple(prepared.model, context, prepared.options as SimpleStreamOptions);
+		this.models.setProvider(composeModelProvider(providerId, this.builtins.get(providerId), effective));
+		this.registrations.set(providerId, effective);
+	}
+
+	/** Offers models of registered providers under alias names; requests go to the target, answers carry the alias. */
+	registerAliases(providerId: string, aliases: readonly ModelAlias[]): void {
+		if (this.aliasRegistration) throw new Error(`Aliases are already registered under ${this.aliasRegistration.provider}.`);
+		if (this.models.getProvider(providerId)) throw new Error(`Alias provider ${providerId} collides with a registered provider.`);
+		const duplicate = aliases.find((entry, index) => aliases.findIndex((other) => other.alias === entry.alias) !== index);
+		if (duplicate) throw new Error(`Alias ${duplicate.alias} is registered twice.`);
+		const missing = aliases.find((entry) => !this.models.getModel(entry.upstream, entry.model));
+		if (missing) throw new Error(`Alias ${missing.alias}: model ${missing.upstream}/${missing.model} is not configured.`);
+		this.aliasRegistration = { provider: providerId, aliases: new Map(aliases.map((entry) => [entry.alias, entry])) };
+	}
+
+	private aliasModels(): Model<Api>[] {
+		const registration = this.aliasRegistration;
+		if (!registration) return [];
+		return [...registration.aliases.values()].flatMap((entry) => {
+			const target = this.models.getModel(entry.upstream, entry.model);
+			return target ? [aliasedModel(registration.provider, entry.alias, target)] : [];
 		});
 	}
 
-	completeSimple(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): Promise<AssistantMessage> {
-		return this.streamSimple(model, context, options).result();
-	}
-
-	async login(providerId: string, type: AuthType, interaction: AuthInteraction): Promise<Credential> {
-		const credential = await this.models.login(providerId, type, interaction);
-		await this.refresh();
-		return credential;
-	}
-
-	async logout(providerId: string): Promise<void> {
-		await this.models.logout(providerId);
-		// Reset credential-dependent compatibility projections before the unconfigured provider is skipped by refresh.
-		this.recomposeProvider(providerId);
-		await this.refresh();
-	}
-
-	async reloadConfig(): Promise<void> {
-		this.config = await ModelConfig.load(this.modelsPath);
-		this.resetBuiltins();
-		this.rebuildProviders();
-		await this.refresh();
+	private targetOf(model: Model<Api>): Model<Api> | undefined {
+		const registration = this.aliasRegistration;
+		if (model.provider !== registration?.provider) return undefined;
+		const entry = registration.aliases.get(model.id);
+		const target = entry && this.models.getModel(entry.upstream, entry.model);
+		if (!target) throw new Error(`Model ${model.provider}/${model.id} is not configured.`);
+		return target;
 	}
+}
 
-	async refresh(options: ModelsRefreshOptions = {}): Promise<ModelsRefreshResult> {
-		const refreshOptions = {
-			...options,
-			allowNetwork: options.allowNetwork ?? false,
-		};
-		const result = ((await this.models.refresh(refreshOptions)) as ModelsRefreshResult | undefined) ?? {
-			aborted: refreshOptions.signal?.aborted ?? false,
-			errors: new Map(),
-		};
-		this.updateModelSnapshot();
-		try {
-			await this.forceRefreshAvailability();
-		} catch {
-			// Availability errors are recorded by forceRefreshAvailability; refreshed models remain usable.
-		}
-		return result;
-	}
+/** Earlier answers of the alias count as answers of the target, so the target keeps its reasoning across turns. */
+function withTargetHistory(context: Context, alias: Model<Api>, target: Model<Api>): Context {
+	return {
+		...context,
+		messages: context.messages.map((message) =>
+			message.role === "assistant" && message.provider === alias.provider && message.model === alias.id
+				? { ...message, provider: target.provider, model: target.id }
+				: message,
+		),
+	};
+}
 
-	registerProvider(providerId: string, config: ProviderConfigInput): void {
-		// 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: ProviderConfigInput = { ...previous };
-		for (const [key, value] of Object.entries(config)) {
-			if (value !== undefined) (effective as Record<string, unknown>)[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();
-	}
+function relabeled(message: AssistantMessage, alias: Model<Api>, target: Model<Api>): AssistantMessage {
+	return {
+		...message,
+		provider: alias.provider,
+		model: alias.id,
+		...(message.responseModel === undefined ? {} : { responseModel: alias.id }),
+		...(message.errorMessage === undefined ? {} : { errorMessage: message.errorMessage.replaceAll(target.id, alias.id) }),
+	};
+}
 
-	unregisterProvider(providerId: string): void {
-		this.extensionProviders.delete(providerId);
-		this.recomposeProvider(providerId);
-		this.updateModelSnapshot();
-		void this.refresh();
+async function* relabeledEvents(
+	source: AssistantMessageEventStream,
+	alias: Model<Api>,
+	target: Model<Api>,
+): AsyncIterable<AssistantMessageEvent> {
+	for await (const event of source) {
+		if (event.type === "done") yield { ...event, message: relabeled(event.message, alias, target) };
+		else if (event.type === "error") yield { ...event, error: relabeled(event.error, alias, target) };
+		else yield { ...event, partial: relabeled(event.partial, alias, target) };
 	}
 }