@pixelzx/genesis 2026.5.5-1 → 2026.5.5-2

package/dist/provider-stream-family-tKIQwQoP.js

@@ -1,2 +0,0 @@
-import "./provider-stream-BZwCdDk2.js";
-export {};

package/dist/provider-usage-DZHssxuZ.js

@@ -1,4 +0,0 @@
-import { o as resolveUsageProviderId } from "./provider-usage.shared-CcvPrv1N.js";
-import { n as formatUsageSummaryLine, r as formatUsageWindowSummary, t as formatUsageReportLines } from "./provider-usage-DtCUHOBT.js";
-import { t as loadProviderUsageSummary } from "./provider-usage.load-DfxOyIjr.js";
-export { formatUsageReportLines, formatUsageSummaryLine, formatUsageWindowSummary, loadProviderUsageSummary, resolveUsageProviderId };

package/dist/provider-usage-DtCUHOBT.js

@@ -1,71 +0,0 @@
-import { r as clampPercent } from "./provider-usage.shared-CcvPrv1N.js";
-import "./provider-usage.load-DfxOyIjr.js";
-//#region src/infra/provider-usage.format.ts
-function formatResetRemaining(targetMs, now) {
-	if (!targetMs) return null;
-	const diffMs = targetMs - (now ?? Date.now());
-	if (diffMs <= 0) return "now";
-	const diffMins = Math.floor(diffMs / 6e4);
-	if (diffMins < 60) return `${diffMins}m`;
-	const hours = Math.floor(diffMins / 60);
-	const mins = diffMins % 60;
-	if (hours < 24) return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
-	const days = Math.floor(hours / 24);
-	if (days < 7) return `${days}d ${hours % 24}h`;
-	return new Intl.DateTimeFormat("en-US", {
-		month: "short",
-		day: "numeric"
-	}).format(new Date(targetMs));
-}
-function formatWindowShort(window, now) {
-	const remaining = clampPercent(100 - window.usedPercent);
-	const reset = formatResetRemaining(window.resetAt, now);
-	const resetSuffix = reset ? ` ⏱${reset}` : "";
-	return `${remaining.toFixed(0)}% left (${window.label}${resetSuffix})`;
-}
-function formatUsageWindowSummary(snapshot, opts) {
-	if (snapshot.error) return null;
-	if (snapshot.windows.length === 0) return null;
-	const now = opts?.now ?? Date.now();
-	const maxWindows = typeof opts?.maxWindows === "number" && opts.maxWindows > 0 ? Math.min(opts.maxWindows, snapshot.windows.length) : snapshot.windows.length;
-	const includeResets = opts?.includeResets ?? false;
-	return snapshot.windows.slice(0, maxWindows).map((window) => {
-		const remaining = clampPercent(100 - window.usedPercent);
-		const reset = includeResets ? formatResetRemaining(window.resetAt, now) : null;
-		const resetSuffix = reset ? ` ⏱${reset}` : "";
-		return `${window.label} ${remaining.toFixed(0)}% left${resetSuffix}`;
-	}).join(" · ");
-}
-function formatUsageSummaryLine(summary, opts) {
-	const providers = summary.providers.filter((entry) => entry.windows.length > 0 && !entry.error).slice(0, opts?.maxProviders ?? summary.providers.length);
-	if (providers.length === 0) return null;
-	return `📊 Usage: ${providers.map((entry) => {
-		const window = entry.windows.reduce((best, next) => next.usedPercent > best.usedPercent ? next : best);
-		return `${entry.displayName} ${formatWindowShort(window, opts?.now)}`;
-	}).join(" · ")}`;
-}
-function formatUsageReportLines(summary, opts) {
-	if (summary.providers.length === 0) return ["Usage: no provider usage available."];
-	const lines = ["Usage:"];
-	for (const entry of summary.providers) {
-		const planSuffix = entry.plan ? ` (${entry.plan})` : "";
-		if (entry.error) {
-			lines.push(`  ${entry.displayName}${planSuffix}: ${entry.error}`);
-			continue;
-		}
-		if (entry.windows.length === 0) {
-			lines.push(`  ${entry.displayName}${planSuffix}: no data`);
-			continue;
-		}
-		lines.push(`  ${entry.displayName}${planSuffix}`);
-		for (const window of entry.windows) {
-			const remaining = clampPercent(100 - window.usedPercent);
-			const reset = formatResetRemaining(window.resetAt, opts?.now);
-			const resetSuffix = reset ? ` · resets ${reset}` : "";
-			lines.push(`    ${window.label}: ${remaining.toFixed(0)}% left${resetSuffix}`);
-		}
-	}
-	return lines;
-}
-//#endregion
-export { formatUsageSummaryLine as n, formatUsageWindowSummary as r, formatUsageReportLines as t };

package/dist/provider-usage.load-DfxOyIjr.js

@@ -1,334 +0,0 @@
-import { t as loadPluginManifestRegistry } from "./manifest-registry-DQR_-Eq8.js";
-import { o as normalizePluginsConfig } from "./config-state-C9Af4Gv_.js";
-import { a as loadConfig } from "./io-h8M_Z0Lj.js";
-import { r as normalizeProviderId } from "./provider-id-BLh32HP1.js";
-import { a as resolveProviderAuthEnvVarCandidates } from "./provider-env-vars-CEaBLk-N.js";
-import "./config-B3ZoZd5V.js";
-import { t as hasAnyAuthProfileStoreSource } from "./source-check-DseWz2_m.js";
-import { i as ensureAuthProfileStoreWithoutExternalProfiles, n as ensureAuthProfileStore } from "./store-DPPUFKL4.js";
-import { l as passesManifestOwnerBasePolicy, s as isActivatedManifestOwner } from "./config-presence-CyVi4mwn.js";
-import { B as resolveProviderUsageSnapshotWithPlugin, z as resolveProviderUsageAuthWithPlugin } from "./provider-runtime-C4mK2ZHM.js";
-import { u as isNonSecretApiKeyMarker } from "./model-auth-markers-fwjZQJ4n.js";
-import "./model-selection-BRmopwFB.js";
-import { n as normalizeSecretInput } from "./normalize-secret-input-CNeH9Ebc.js";
-import { t as resolveEnvApiKey } from "./model-auth-env-Dz5Pixvx.js";
-import { t as resolveApiKeyForProfile } from "./auth-profiles-Bn8y2hqR.js";
-import { n as listProfilesForProvider, t as dedupeProfileIds } from "./profile-list-DxD5kVCL.js";
-import { n as resolveAuthProfileOrder } from "./order-dgHk1PE1.js";
-import { l as resolveUsableCustomProviderApiKey } from "./model-auth-C1Z9RsQ5.js";
-import { t as resolveFetch } from "./fetch-BzAIu2qj.js";
-import { a as resolveLegacyPiAgentAccessToken, c as withTimeout, i as ignoredErrors, n as PROVIDER_LABELS, s as usageProviders } from "./provider-usage.shared-CcvPrv1N.js";
-//#region src/infra/provider-usage.auth.ts
-function resolveUsageAuthStore(state) {
-	state.store ??= ensureAuthProfileStore(state.agentDir, { allowKeychainPrompt: false });
-	return state.store;
-}
-function resolveProviderApiKeyFromConfig(params) {
-	const envDirect = params.envDirect?.map(normalizeSecretInput).find(Boolean);
-	if (envDirect) return envDirect;
-	for (const providerId of params.providerIds) {
-		const envKey = resolveEnvApiKey(providerId, params.state.env)?.apiKey;
-		if (envKey) return envKey;
-		const key = resolveUsableCustomProviderApiKey({
-			cfg: params.state.cfg,
-			provider: providerId,
-			env: params.state.env
-		})?.apiKey;
-		if (key) return key;
-	}
-}
-function hasProviderAuthEnvCredentialSource(params) {
-	const candidates = resolveProviderAuthEnvVarCandidates({
-		config: params.state.cfg,
-		env: {
-			...process.env.VITEST ? process.env : {},
-			...params.state.env
-		}
-	});
-	for (const providerId of normalizeProviderIds(params.providerIds)) {
-		const envVars = Object.hasOwn(candidates, providerId) ? candidates[providerId] : void 0;
-		if (!envVars) continue;
-		if (envVars.some((envVar) => Boolean(normalizeSecretInput(params.state.env[envVar])))) return true;
-	}
-	return false;
-}
-function resolveProviderApiKeyFromConfigAndStore(params) {
-	const configKey = resolveProviderApiKeyFromConfig(params);
-	if (configKey || !params.state.allowAuthProfileStore) return configKey;
-	const cred = [...new Set(params.providerIds.map((providerId) => normalizeProviderId(providerId)).filter(Boolean))].flatMap((providerId) => listProfilesForProvider(resolveUsageAuthStore(params.state), providerId)).map((id) => resolveUsageAuthStore(params.state).profiles[id]).find((profile) => profile?.type === "api_key" || profile?.type === "token");
-	if (!cred) return;
-	if (cred.type === "api_key") {
-		const key = normalizeSecretInput(cred.key);
-		if (key && !isNonSecretApiKeyMarker(key)) return key;
-		return;
-	}
-	const token = normalizeSecretInput(cred.token);
-	if (token && !isNonSecretApiKeyMarker(token)) return token;
-}
-function normalizeProviderIds(providerIds) {
-	return [...new Set([...providerIds].map((providerId) => providerId ? normalizeProviderId(providerId) : void 0).filter((providerId) => Boolean(providerId)))];
-}
-function isUsageProviderManifestEligible(params) {
-	const normalizedConfig = normalizePluginsConfig(params.state.cfg.plugins);
-	if (!passesManifestOwnerBasePolicy({
-		plugin: params.plugin,
-		normalizedConfig
-	})) return false;
-	if (params.plugin.origin !== "workspace") return true;
-	return isActivatedManifestOwner({
-		plugin: params.plugin,
-		normalizedConfig,
-		rootConfig: params.state.cfg
-	});
-}
-function resolveUsageCredentialProviderIds(params) {
-	const providerIds = new Set(normalizeProviderIds([params.provider]));
-	const providerIdSet = new Set(providerIds);
-	try {
-		const registry = loadPluginManifestRegistry({
-			config: params.state.cfg,
-			env: params.state.env
-		});
-		for (const plugin of registry.plugins) {
-			const pluginProviderIds = normalizeProviderIds(plugin.providers);
-			if (!pluginProviderIds.some((providerId) => providerIdSet.has(providerId))) continue;
-			if (!isUsageProviderManifestEligible({
-				plugin,
-				state: params.state
-			})) continue;
-			for (const providerId of pluginProviderIds) providerIds.add(providerId);
-		}
-	} catch {}
-	return [...providerIds];
-}
-async function resolveOAuthToken(params) {
-	if (!params.state.allowAuthProfileStore) return null;
-	const store = resolveUsageAuthStore(params.state);
-	const deduped = dedupeProfileIds(resolveAuthProfileOrder({
-		cfg: params.state.cfg,
-		store,
-		provider: params.provider
-	}));
-	for (const profileId of deduped) {
-		const cred = store.profiles[profileId];
-		if (!cred || cred.type !== "oauth" && cred.type !== "token") continue;
-		try {
-			const resolved = await resolveApiKeyForProfile({
-				cfg: params.state.cfg,
-				store,
-				profileId,
-				agentDir: params.state.agentDir
-			});
-			if (!resolved) continue;
-			return {
-				provider: params.provider,
-				token: resolved.apiKey,
-				accountId: cred.type === "oauth" && "accountId" in cred ? cred.accountId : void 0
-			};
-		} catch {}
-	}
-	return null;
-}
-async function resolveProviderUsageAuthViaPlugin(params) {
-	const resolved = await resolveProviderUsageAuthWithPlugin({
-		provider: params.provider,
-		config: params.state.cfg,
-		env: params.state.env,
-		context: {
-			config: params.state.cfg,
-			agentDir: params.state.agentDir,
-			env: params.state.env,
-			provider: params.provider,
-			resolveApiKeyFromConfigAndStore: (options) => resolveProviderApiKeyFromConfigAndStore({
-				state: params.state,
-				providerIds: options?.providerIds ?? [params.provider],
-				envDirect: options?.envDirect
-			}),
-			resolveOAuthToken: async (options) => {
-				const auth = await resolveOAuthToken({
-					state: params.state,
-					provider: options?.provider ?? params.provider
-				});
-				return auth ? {
-					token: auth.token,
-					...auth.accountId ? { accountId: auth.accountId } : {}
-				} : null;
-			}
-		}
-	});
-	if (!resolved?.token) return null;
-	return {
-		provider: params.provider,
-		token: resolved.token,
-		...resolved.accountId ? { accountId: resolved.accountId } : {}
-	};
-}
-async function resolveProviderUsageAuthFallback(params) {
-	const oauthToken = await resolveOAuthToken({
-		state: params.state,
-		provider: params.provider
-	});
-	if (oauthToken) return oauthToken;
-	const apiKey = resolveProviderApiKeyFromConfigAndStore({
-		state: params.state,
-		providerIds: [params.provider]
-	});
-	if (apiKey) return {
-		provider: params.provider,
-		token: apiKey
-	};
-	return null;
-}
-function hasAuthProfileCredentialSource(params) {
-	const store = ensureAuthProfileStoreWithoutExternalProfiles(params.state.agentDir, { allowKeychainPrompt: false });
-	for (const provider of params.providerIds) if (dedupeProfileIds(resolveAuthProfileOrder({
-		cfg: params.state.cfg,
-		store,
-		provider
-	})).some((profileId) => {
-		const cred = store.profiles[profileId];
-		return cred?.type === "api_key" || cred?.type === "oauth" || cred?.type === "token";
-	})) return true;
-	return false;
-}
-function resolveLegacyPiAgentProviderIds(provider) {
-	return provider === "zai" ? ["z-ai", "zai"] : [provider];
-}
-async function resolveProviderAuths(params) {
-	if (params.auth) return params.auth;
-	const stateBase = {
-		cfg: params.config ?? loadConfig(),
-		env: params.env ?? process.env,
-		agentDir: params.agentDir
-	};
-	const hasAuthProfileStoreSource = hasAnyAuthProfileStoreSource(params.agentDir);
-	const authProfileSourceState = {
-		...stateBase,
-		allowAuthProfileStore: true
-	};
-	const auths = [];
-	for (const provider of params.providers) {
-		const directCredentialState = {
-			...stateBase,
-			allowAuthProfileStore: false
-		};
-		const credentialProviderIds = resolveUsageCredentialProviderIds({
-			state: directCredentialState,
-			provider
-		});
-		const hasDirectCredentialSource = Boolean(resolveProviderApiKeyFromConfig({
-			state: directCredentialState,
-			providerIds: credentialProviderIds
-		})) || hasProviderAuthEnvCredentialSource({
-			state: directCredentialState,
-			providerIds: credentialProviderIds
-		});
-		const allowAuthProfileStore = !params.skipPluginAuthWithoutCredentialSource || hasDirectCredentialSource || hasAuthProfileStoreSource && hasAuthProfileCredentialSource({
-			state: authProfileSourceState,
-			providerIds: credentialProviderIds
-		});
-		const state = {
-			...stateBase,
-			allowAuthProfileStore
-		};
-		const hasLegacyPiAgentCredentialSource = Boolean(resolveLegacyPiAgentAccessToken(stateBase.env, resolveLegacyPiAgentProviderIds(provider)));
-		const hasPluginCredentialSource = hasDirectCredentialSource || allowAuthProfileStore || hasLegacyPiAgentCredentialSource;
-		if (!params.skipPluginAuthWithoutCredentialSource || hasPluginCredentialSource) {
-			const pluginAuth = await resolveProviderUsageAuthViaPlugin({
-				state,
-				provider
-			});
-			if (pluginAuth) {
-				auths.push(pluginAuth);
-				continue;
-			}
-		}
-		const fallbackAuth = await resolveProviderUsageAuthFallback({
-			state,
-			provider
-		});
-		if (fallbackAuth) auths.push(fallbackAuth);
-	}
-	return auths;
-}
-//#endregion
-//#region src/infra/provider-usage.load.ts
-async function fetchProviderUsageSnapshotFallback(params) {
-	params.timeoutMs;
-	params.fetchFn;
-	return {
-		provider: params.auth.provider,
-		displayName: PROVIDER_LABELS[params.auth.provider] ?? params.auth.provider,
-		windows: [],
-		error: "Unsupported provider"
-	};
-}
-async function fetchProviderUsageSnapshot(params) {
-	const pluginSnapshot = await resolveProviderUsageSnapshotWithPlugin({
-		provider: params.auth.provider,
-		config: params.config,
-		workspaceDir: params.workspaceDir,
-		env: params.env,
-		context: {
-			config: params.config,
-			agentDir: params.agentDir,
-			workspaceDir: params.workspaceDir,
-			env: params.env,
-			provider: params.auth.provider,
-			token: params.auth.token,
-			accountId: params.auth.accountId,
-			timeoutMs: params.timeoutMs,
-			fetchFn: params.fetchFn
-		}
-	});
-	if (pluginSnapshot) return pluginSnapshot;
-	return await fetchProviderUsageSnapshotFallback({
-		auth: params.auth,
-		timeoutMs: params.timeoutMs,
-		fetchFn: params.fetchFn
-	});
-}
-async function loadProviderUsageSummary(opts = {}) {
-	const now = opts.now ?? Date.now();
-	const timeoutMs = opts.timeoutMs ?? 5e3;
-	const config = opts.config ?? loadConfig();
-	const env = opts.env ?? process.env;
-	const fetchFn = resolveFetch(opts.fetch);
-	if (!fetchFn) throw new Error("fetch is not available");
-	const auths = await resolveProviderAuths({
-		providers: opts.providers ?? usageProviders,
-		auth: opts.auth,
-		agentDir: opts.agentDir,
-		config,
-		env,
-		skipPluginAuthWithoutCredentialSource: opts.skipPluginAuthWithoutCredentialSource
-	});
-	if (auths.length === 0) return {
-		updatedAt: now,
-		providers: []
-	};
-	const tasks = auths.map((auth) => withTimeout(fetchProviderUsageSnapshot({
-		auth,
-		config,
-		env,
-		agentDir: opts.agentDir,
-		workspaceDir: opts.workspaceDir,
-		timeoutMs,
-		fetchFn
-	}), timeoutMs + 1e3, {
-		provider: auth.provider,
-		displayName: PROVIDER_LABELS[auth.provider],
-		windows: [],
-		error: "Timeout"
-	}));
-	return {
-		updatedAt: now,
-		providers: (await Promise.all(tasks)).filter((entry) => {
-			if (entry.windows.length > 0) return true;
-			if (!entry.error) return true;
-			return !ignoredErrors.has(entry.error);
-		})
-	};
-}
-//#endregion
-export { loadProviderUsageSummary as t };

package/dist/provider-utils-CDXJKXaV.js

@@ -1,49 +0,0 @@
-import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
-import { j as resolveProviderReasoningOutputModeWithPlugin } from "./provider-runtime-C4mK2ZHM.js";
-//#region src/utils/provider-utils.ts
-const BUILTIN_REASONING_OUTPUT_MODES = { "google-generative-ai": "tagged" };
-/**
-* Utility functions for provider-specific logic and capabilities.
-*/
-function resolveReasoningOutputMode(params) {
-	const provider = normalizeOptionalString(params.provider);
-	if (!provider) return "native";
-	const normalized = normalizeOptionalLowercaseString(provider) ?? "";
-	const pluginMode = resolveProviderReasoningOutputModeWithPlugin({
-		provider,
-		config: params.config,
-		workspaceDir: params.workspaceDir,
-		env: params.env,
-		context: {
-			config: params.config,
-			workspaceDir: params.workspaceDir,
-			env: params.env,
-			provider,
-			modelId: params.modelId,
-			modelApi: params.modelApi,
-			model: params.model
-		}
-	});
-	if (pluginMode) return pluginMode;
-	const builtInMode = BUILTIN_REASONING_OUTPUT_MODES[normalized];
-	if (builtInMode) return builtInMode;
-	return "native";
-}
-/**
-* Returns true if the provider requires reasoning to be wrapped in tags
-* (e.g. <think> and <final>) in the text stream, rather than using native
-* API fields for reasoning/thinking.
-*/
-function isReasoningTagProvider(provider, options) {
-	return resolveReasoningOutputMode({
-		provider,
-		config: options?.config,
-		workspaceDir: options?.workspaceDir,
-		env: options?.env,
-		modelId: options?.modelId,
-		modelApi: options?.modelApi,
-		model: options?.model
-	}) === "tagged";
-}
-//#endregion
-export { isReasoningTagProvider as t };

package/dist/provider-wizard-FaPEKwkS.js

@@ -1,166 +0,0 @@
-import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
-import { r as normalizeProviderId } from "./provider-id-BLh32HP1.js";
-import { r as DEFAULT_PROVIDER } from "./defaults-DM8yIn8C.js";
-import { n as resolvePluginProviders } from "./providers.runtime-CNRwqmqP.js";
-import "./model-selection-BRmopwFB.js";
-//#region src/plugins/provider-wizard.ts
-const PROVIDER_PLUGIN_CHOICE_PREFIX = "provider-plugin:";
-function resolveWizardSetupChoiceId(provider, wizard) {
-	const explicit = normalizeOptionalString(wizard.choiceId);
-	if (explicit) return explicit;
-	const explicitMethodId = normalizeOptionalString(wizard.methodId);
-	if (explicitMethodId) return buildProviderPluginMethodChoice(provider.id, explicitMethodId);
-	if (provider.auth.length === 1) return provider.id;
-	return buildProviderPluginMethodChoice(provider.id, provider.auth[0]?.id ?? "default");
-}
-function resolveMethodById(provider, methodId) {
-	const normalizedMethodId = normalizeOptionalLowercaseString(methodId);
-	if (!normalizedMethodId) return provider.auth[0];
-	return provider.auth.find((method) => normalizeOptionalLowercaseString(method.id) === normalizedMethodId);
-}
-function listMethodWizardSetups(provider) {
-	return provider.auth.map((method) => method.wizard ? {
-		method,
-		wizard: method.wizard
-	} : null).filter((entry) => Boolean(entry));
-}
-function buildSetupOptionForMethod(params) {
-	const normalizedGroupId = normalizeOptionalString(params.wizard.groupId) || params.provider.id;
-	return {
-		value: normalizeOptionalString(params.value) ?? "",
-		label: normalizeOptionalString(params.wizard.choiceLabel) || (params.provider.auth.length === 1 ? params.provider.label : params.method.label),
-		hint: normalizeOptionalString(params.wizard.choiceHint) || params.method.hint,
-		groupId: normalizedGroupId,
-		groupLabel: normalizeOptionalString(params.wizard.groupLabel) || params.provider.label,
-		groupHint: normalizeOptionalString(params.wizard.groupHint),
-		...params.wizard.onboardingScopes ? { onboardingScopes: params.wizard.onboardingScopes } : {},
-		...typeof params.wizard.assistantPriority === "number" && Number.isFinite(params.wizard.assistantPriority) ? { assistantPriority: params.wizard.assistantPriority } : {},
-		...params.wizard.assistantVisibility ? { assistantVisibility: params.wizard.assistantVisibility } : {}
-	};
-}
-function buildProviderPluginMethodChoice(providerId, methodId) {
-	return `${PROVIDER_PLUGIN_CHOICE_PREFIX}${normalizeOptionalString(providerId) ?? ""}:${normalizeOptionalString(methodId) ?? ""}`;
-}
-function resolveProviderWizardProviders(params) {
-	return resolvePluginProviders({
-		config: params.config,
-		workspaceDir: params.workspaceDir,
-		env: params.env,
-		mode: "setup"
-	});
-}
-function resolveProviderWizardOptions(params) {
-	const providers = resolveProviderWizardProviders(params);
-	const options = [];
-	for (const provider of providers) {
-		const methodSetups = listMethodWizardSetups(provider);
-		for (const { method, wizard } of methodSetups) options.push(buildSetupOptionForMethod({
-			provider,
-			wizard,
-			method,
-			value: normalizeOptionalString(wizard.choiceId) || buildProviderPluginMethodChoice(provider.id, method.id)
-		}));
-		if (methodSetups.length > 0) continue;
-		const setup = provider.wizard?.setup;
-		if (!setup) continue;
-		const explicitMethod = resolveMethodById(provider, setup.methodId);
-		if (explicitMethod) {
-			options.push(buildSetupOptionForMethod({
-				provider,
-				wizard: setup,
-				method: explicitMethod,
-				value: resolveWizardSetupChoiceId(provider, setup)
-			}));
-			continue;
-		}
-		for (const method of provider.auth) options.push(buildSetupOptionForMethod({
-			provider,
-			wizard: setup,
-			method,
-			value: buildProviderPluginMethodChoice(provider.id, method.id)
-		}));
-	}
-	return options;
-}
-function resolveModelPickerChoiceValue(provider, modelPicker) {
-	const explicitMethodId = normalizeOptionalString(modelPicker.methodId);
-	if (explicitMethodId) return buildProviderPluginMethodChoice(provider.id, explicitMethodId);
-	if (provider.auth.length === 1) return provider.id;
-	return buildProviderPluginMethodChoice(provider.id, provider.auth[0]?.id ?? "default");
-}
-function resolveProviderModelPickerEntries(params) {
-	const providers = resolveProviderWizardProviders(params);
-	const entries = [];
-	for (const provider of providers) {
-		const modelPicker = provider.wizard?.modelPicker;
-		if (!modelPicker) continue;
-		entries.push({
-			value: resolveModelPickerChoiceValue(provider, modelPicker),
-			label: normalizeOptionalString(modelPicker.label) || `${provider.label} (custom)`,
-			hint: normalizeOptionalString(modelPicker.hint)
-		});
-	}
-	return entries;
-}
-function resolveProviderPluginChoice(params) {
-	const choice = normalizeOptionalString(params.choice) ?? "";
-	if (!choice) return null;
-	if (choice.startsWith("provider-plugin:")) {
-		const payload = choice.slice(16);
-		const separator = payload.indexOf(":");
-		const providerId = separator >= 0 ? payload.slice(0, separator) : payload;
-		const methodId = separator >= 0 ? payload.slice(separator + 1) : void 0;
-		const provider = params.providers.find((entry) => normalizeProviderId(entry.id) === normalizeProviderId(providerId));
-		if (!provider) return null;
-		const method = resolveMethodById(provider, methodId);
-		return method ? {
-			provider,
-			method
-		} : null;
-	}
-	for (const provider of params.providers) {
-		for (const { method, wizard } of listMethodWizardSetups(provider)) if ((normalizeOptionalString(normalizeOptionalString(wizard.choiceId) || buildProviderPluginMethodChoice(provider.id, method.id)) ?? "") === choice) return {
-			provider,
-			method,
-			wizard
-		};
-		const setup = provider.wizard?.setup;
-		if (setup) {
-			if ((normalizeOptionalString(resolveWizardSetupChoiceId(provider, setup)) ?? "") === choice) {
-				const method = resolveMethodById(provider, setup.methodId);
-				if (method) return {
-					provider,
-					method,
-					wizard: setup
-				};
-			}
-		}
-		if (normalizeProviderId(provider.id) === normalizeProviderId(choice) && provider.auth.length > 0) return {
-			provider,
-			method: provider.auth[0]
-		};
-	}
-	return null;
-}
-async function runProviderModelSelectedHook(params) {
-	const rawModel = params.model.trim();
-	if (!rawModel) return;
-	const slashIndex = rawModel.indexOf("/");
-	const selectedProviderId = slashIndex === -1 ? DEFAULT_PROVIDER : normalizeProviderId(rawModel.slice(0, slashIndex).trim());
-	if (!selectedProviderId || slashIndex !== -1 && !rawModel.slice(slashIndex + 1).trim()) return;
-	const provider = resolveProviderWizardProviders({
-		config: params.config,
-		workspaceDir: params.workspaceDir,
-		env: params.env
-	}).find((entry) => normalizeProviderId(entry.id) === selectedProviderId);
-	if (!provider?.onModelSelected) return;
-	await provider.onModelSelected({
-		config: params.config,
-		model: params.model,
-		prompter: params.prompter,
-		agentDir: params.agentDir,
-		workspaceDir: params.workspaceDir
-	});
-}
-//#endregion
-export { runProviderModelSelectedHook as i, resolveProviderPluginChoice as n, resolveProviderWizardOptions as r, resolveProviderModelPickerEntries as t };