@mseep/claudian 2.0.25

package/src/core/providers/ProviderSettingsCoordinator.ts

@@ -0,0 +1,434 @@
+import type { Conversation } from '../types';
+import { toProviderRuntimeModelId } from './modelSelection';
+import { ProviderRegistry } from './ProviderRegistry';
+import type { ProviderChatUIConfig, ProviderId } from './types';
+
+export interface SettingsReconciliationResult {
+  changed: boolean;
+  invalidatedConversations: Conversation[];
+}
+
+const PROJECTION_KEYS = new Set([
+  'model',
+  'effortLevel',
+  'serviceTier',
+  'thinkingBudget',
+  'permissionMode',
+]);
+
+type ProviderProjectionMap = Partial<Record<string, string>>;
+
+function getSettingsProviderId(settings: Record<string, unknown>): ProviderId {
+  return ProviderRegistry.resolveSettingsProviderId(settings);
+}
+
+function ensureProjectionMap(
+  settings: Record<string, unknown>,
+  key:
+  | 'savedProviderModel'
+  | 'savedProviderEffort'
+  | 'savedProviderServiceTier'
+  | 'savedProviderThinkingBudget'
+  | 'savedProviderPermissionMode',
+): ProviderProjectionMap {
+  const current = settings[key];
+  if (current && typeof current === 'object') {
+    return current;
+  }
+
+  const next: ProviderProjectionMap = {};
+  settings[key] = next;
+  return next;
+}
+
+function cloneProviderSettings(settings: Record<string, unknown>): Record<string, unknown> {
+  return {
+    ...settings,
+    savedProviderModel: { ...(settings.savedProviderModel as ProviderProjectionMap | undefined) },
+    savedProviderEffort: { ...(settings.savedProviderEffort as ProviderProjectionMap | undefined) },
+    savedProviderServiceTier: { ...(settings.savedProviderServiceTier as ProviderProjectionMap | undefined) },
+    savedProviderThinkingBudget: { ...(settings.savedProviderThinkingBudget as ProviderProjectionMap | undefined) },
+    savedProviderPermissionMode: { ...(settings.savedProviderPermissionMode as ProviderProjectionMap | undefined) },
+  };
+}
+
+function normalizeToggleValue(
+  value: unknown,
+  allowedValues: Set<string>,
+): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  return allowedValues.has(value) ? value : undefined;
+}
+
+function mergeProviderSettings(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+): void {
+  for (const [key, value] of Object.entries(source)) {
+    if (PROJECTION_KEYS.has(key)) {
+      continue;
+    }
+    target[key] = value;
+  }
+}
+
+function normalizeReasoningValue(
+  uiConfig: ProviderChatUIConfig,
+  settings: Record<string, unknown>,
+  model: string,
+  value: unknown,
+): string {
+  const allowedValues = new Set(uiConfig.getReasoningOptions(model, settings).map(option => option.value));
+  if (typeof value === 'string' && allowedValues.has(value)) {
+    return value;
+  }
+  return uiConfig.getDefaultReasoningValue(model, settings);
+}
+
+function normalizeProviderModel(
+  uiConfig: ProviderChatUIConfig,
+  settings: Record<string, unknown>,
+  model: string | undefined,
+): string | undefined {
+  if (!model) {
+    return undefined;
+  }
+  return uiConfig.normalizeModelVariant(model, settings);
+}
+
+export class ProviderSettingsCoordinator {
+  static handleEnvironmentChange(
+    settings: Record<string, unknown>,
+    providerIds: ProviderId[],
+  ): boolean {
+    let anyChanged = false;
+    for (const providerId of providerIds) {
+      const reconciler = ProviderRegistry.getSettingsReconciler(providerId);
+      if (reconciler.handleEnvironmentChange?.(settings)) {
+        anyChanged = true;
+      }
+    }
+    return anyChanged;
+  }
+
+  static reconcileTitleGenerationModelSelection(settings: Record<string, unknown>): boolean {
+    const currentModel = typeof settings.titleGenerationModel === 'string'
+      ? settings.titleGenerationModel
+      : '';
+    if (!currentModel) {
+      return false;
+    }
+
+    for (const providerId of ProviderRegistry.getRegisteredProviderIds()) {
+      const uiConfig = ProviderRegistry.getChatUIConfig(providerId);
+      if (!uiConfig.ownsModel(currentModel, settings)) {
+        continue;
+      }
+
+      const normalizedModel = normalizeProviderModel(uiConfig, settings, currentModel);
+      const currentRuntimeModel = toProviderRuntimeModelId(providerId, currentModel);
+      const isValid = normalizedModel !== undefined
+        && uiConfig.getModelOptions(settings).some((option) =>
+          option.value === normalizedModel
+          && toProviderRuntimeModelId(providerId, option.value) === currentRuntimeModel
+        );
+      if (!isValid) {
+        continue;
+      }
+
+      if (normalizedModel !== currentModel) {
+        settings.titleGenerationModel = normalizedModel;
+        return true;
+      }
+      return false;
+    }
+
+    settings.titleGenerationModel = '';
+    return true;
+  }
+
+  static normalizeProviderSelection(settings: Record<string, unknown>): boolean {
+    const next = getSettingsProviderId(settings);
+
+    if (settings.settingsProvider === next) {
+      return false;
+    }
+
+    settings.settingsProvider = next;
+    return true;
+  }
+
+  static getProviderSettingsSnapshot<T extends Record<string, unknown>>(
+    settings: T,
+    providerId: ProviderId,
+  ): T {
+    const snapshot = cloneProviderSettings(settings) as T;
+    this.projectProviderState(snapshot, providerId);
+    return snapshot;
+  }
+
+  static commitProviderSettingsSnapshot(
+    settings: Record<string, unknown>,
+    providerId: ProviderId,
+    snapshot: Record<string, unknown>,
+  ): void {
+    this.persistProjectedProviderState(snapshot, providerId);
+
+    if (providerId === getSettingsProviderId(settings)) {
+      Object.assign(settings, snapshot);
+      return;
+    }
+
+    mergeProviderSettings(settings, snapshot);
+  }
+
+  static persistProjectedProviderState(
+    settings: Record<string, unknown>,
+    providerId: ProviderId = getSettingsProviderId(settings),
+  ): void {
+    const savedModel = ensureProjectionMap(settings, 'savedProviderModel');
+    const savedEffort = ensureProjectionMap(settings, 'savedProviderEffort');
+    const savedServiceTier = ensureProjectionMap(settings, 'savedProviderServiceTier');
+    const savedBudget = ensureProjectionMap(settings, 'savedProviderThinkingBudget');
+    const savedPermissionMode = ensureProjectionMap(settings, 'savedProviderPermissionMode');
+    const uiConfig = ProviderRegistry.getChatUIConfig(providerId);
+    const normalizedModel = normalizeProviderModel(
+      uiConfig,
+      settings,
+      typeof settings.model === 'string' ? settings.model : undefined,
+    );
+    const projectedSettings = normalizedModel && normalizedModel !== settings.model
+      ? { ...settings, model: normalizedModel }
+      : settings;
+
+    if (normalizedModel) {
+      savedModel[providerId] = normalizedModel;
+    }
+    if (typeof settings.effortLevel === 'string') {
+      savedEffort[providerId] = settings.effortLevel;
+    }
+    const serviceTierToggle = uiConfig.getServiceTierToggle?.(projectedSettings) ?? null;
+    if (serviceTierToggle && typeof settings.serviceTier === 'string') {
+      savedServiceTier[providerId] = settings.serviceTier;
+    }
+    const usesBudget = normalizedModel !== undefined
+      && !uiConfig.isAdaptiveReasoningModel(normalizedModel, projectedSettings);
+    if (usesBudget && typeof settings.thinkingBudget === 'string') {
+      savedBudget[providerId] = settings.thinkingBudget;
+    } else {
+      delete savedBudget[providerId];
+    }
+    if (typeof settings.permissionMode === 'string' && uiConfig.getPermissionModeToggle?.()) {
+      savedPermissionMode[providerId] = settings.permissionMode;
+    }
+  }
+
+  static projectProviderState(
+    settings: Record<string, unknown>,
+    providerId: ProviderId,
+  ): void {
+    const uiConfig = ProviderRegistry.getChatUIConfig(providerId);
+    const savedModel = settings.savedProviderModel as ProviderProjectionMap | undefined;
+    const savedEffort = settings.savedProviderEffort as ProviderProjectionMap | undefined;
+    const savedServiceTier = settings.savedProviderServiceTier as ProviderProjectionMap | undefined;
+    const savedBudget = settings.savedProviderThinkingBudget as ProviderProjectionMap | undefined;
+    const savedPermissionMode = settings.savedProviderPermissionMode as ProviderProjectionMap | undefined;
+
+    const shouldPreferCurrentProjection = providerId === getSettingsProviderId(settings);
+    const currentModelRaw = typeof settings.model === 'string' ? settings.model : '';
+    const currentModel = shouldPreferCurrentProjection
+      ? (normalizeProviderModel(uiConfig, settings, currentModelRaw) ?? '')
+      : currentModelRaw;
+    const currentEffort = typeof settings.effortLevel === 'string' ? settings.effortLevel : undefined;
+    const currentServiceTier = typeof settings.serviceTier === 'string' ? settings.serviceTier : undefined;
+    const currentBudget = typeof settings.thinkingBudget === 'string' ? settings.thinkingBudget : undefined;
+    const modelOptions = uiConfig.getModelOptions(settings);
+    const isDefaultModelOfAnotherProvider = currentModel.length > 0
+      && ProviderRegistry.getRegisteredProviderIds()
+        .filter(id => id !== providerId)
+        .some(id => ProviderRegistry.getChatUIConfig(id).isDefaultModel(currentModel));
+    const canReuseCurrentModel = currentModel.length > 0
+      && !isDefaultModelOfAnotherProvider
+      && (
+        shouldPreferCurrentProjection
+        || modelOptions.some(option => option.value === currentModel)
+      );
+    const fallbackModel = canReuseCurrentModel
+      ? currentModel
+      : (modelOptions[0]?.value ?? currentModel);
+    const savedModelValue = normalizeProviderModel(uiConfig, settings, savedModel?.[providerId]);
+    const isSavedModelValid = savedModelValue !== undefined
+      && modelOptions.some(option => option.value === savedModelValue);
+    const model = (isSavedModelValid ? savedModelValue : undefined) ?? fallbackModel;
+    const canReuseCurrentProjection = canReuseCurrentModel && model === currentModel;
+
+    if (model) {
+      settings.model = model;
+      uiConfig.applyModelDefaults(model, settings);
+    }
+
+    const serviceTierToggle = uiConfig.getServiceTierToggle?.({
+      ...settings,
+      ...(model ? { model } : {}),
+    }) ?? null;
+
+    const isAdaptive = Boolean(model) && uiConfig.isAdaptiveReasoningModel(model, settings);
+
+    if (savedEffort?.[providerId] !== undefined) {
+      settings.effortLevel = savedEffort[providerId];
+    } else if (canReuseCurrentProjection && currentEffort !== undefined) {
+      settings.effortLevel = currentEffort;
+    } else if (isAdaptive) {
+      settings.effortLevel = uiConfig.getDefaultReasoningValue(model, settings);
+    }
+
+    if (isAdaptive) {
+      settings.effortLevel = normalizeReasoningValue(uiConfig, settings, model, settings.effortLevel);
+    }
+
+    if (savedServiceTier?.[providerId] !== undefined) {
+      settings.serviceTier = savedServiceTier[providerId];
+    } else if (canReuseCurrentProjection && currentServiceTier !== undefined) {
+      settings.serviceTier = currentServiceTier;
+    } else {
+      settings.serviceTier = serviceTierToggle?.inactiveValue ?? 'default';
+    }
+
+    const usesBudget = Boolean(model) && !isAdaptive;
+
+    if (usesBudget) {
+      if (savedBudget?.[providerId] !== undefined) {
+        settings.thinkingBudget = savedBudget[providerId];
+      } else if (canReuseCurrentProjection && currentBudget !== undefined) {
+        settings.thinkingBudget = currentBudget;
+      } else {
+        settings.thinkingBudget = uiConfig.getDefaultReasoningValue(model, settings);
+      }
+      settings.thinkingBudget = normalizeReasoningValue(uiConfig, settings, model, settings.thinkingBudget);
+    }
+
+    const permissionToggle = uiConfig.getPermissionModeToggle?.() ?? null;
+    if (!permissionToggle) {
+      return;
+    }
+
+    const allowedPermissionModes = new Set([
+      permissionToggle.inactiveValue,
+      permissionToggle.activeValue,
+      ...(permissionToggle.planValue ? [permissionToggle.planValue] : []),
+    ]);
+    const currentPermissionMode = normalizeToggleValue(settings.permissionMode, allowedPermissionModes);
+    const derivedPermissionMode = normalizeToggleValue(
+      uiConfig.resolvePermissionMode?.(settings),
+      allowedPermissionModes,
+    );
+    const savedPermissionModeValue = normalizeToggleValue(
+      savedPermissionMode?.[providerId],
+      allowedPermissionModes,
+    );
+
+    const projectedPermissionMode = savedPermissionModeValue
+      ?? derivedPermissionMode
+      ?? (shouldPreferCurrentProjection ? currentPermissionMode : undefined)
+      ?? currentPermissionMode;
+
+    if (projectedPermissionMode !== undefined) {
+      settings.permissionMode = projectedPermissionMode;
+    }
+  }
+
+  /** Each provider's reconciler only processes its own conversations. */
+  static reconcileAllProviders(
+    settings: Record<string, unknown>,
+    conversations: Conversation[],
+  ): SettingsReconciliationResult {
+    return this.reconcileProviders(
+      settings,
+      conversations,
+      ProviderRegistry.getRegisteredProviderIds(),
+    );
+  }
+
+  static reconcileProviders(
+    settings: Record<string, unknown>,
+    conversations: Conversation[],
+    providerIds: ProviderId[],
+  ): SettingsReconciliationResult {
+    let anyChanged = false;
+    const allInvalidated: Conversation[] = [];
+    const settingsProvider = getSettingsProviderId(settings);
+
+    for (const providerId of providerIds) {
+      const reconciler = ProviderRegistry.getSettingsReconciler(providerId);
+      const providerConversations = conversations.filter(c => c.providerId === providerId);
+      const targetSettings = providerId === settingsProvider
+        ? settings
+        : cloneProviderSettings(settings);
+
+      if (providerId !== settingsProvider) {
+        this.projectProviderState(targetSettings, providerId);
+      }
+
+      const { changed, invalidatedConversations } = reconciler.reconcileModelWithEnvironment(
+        targetSettings,
+        providerConversations,
+      );
+
+      if (changed) {
+        anyChanged = true;
+        this.persistProjectedProviderState(targetSettings, providerId);
+        if (providerId !== settingsProvider) {
+          mergeProviderSettings(settings, targetSettings);
+        }
+      }
+      allInvalidated.push(...invalidatedConversations);
+    }
+
+    if (this.reconcileTitleGenerationModelSelection(settings)) {
+      anyChanged = true;
+    }
+
+    return { changed: anyChanged, invalidatedConversations: allInvalidated };
+  }
+
+  static normalizeAllModelVariants(settings: Record<string, unknown>): boolean {
+    let anyChanged = false;
+    const settingsProvider = getSettingsProviderId(settings);
+
+    for (const providerId of ProviderRegistry.getRegisteredProviderIds()) {
+      const reconciler = ProviderRegistry.getSettingsReconciler(providerId);
+      const targetSettings = providerId === settingsProvider
+        ? settings
+        : cloneProviderSettings(settings);
+
+      if (providerId !== settingsProvider) {
+        this.projectProviderState(targetSettings, providerId);
+      }
+
+      const changed = reconciler.normalizeModelVariantSettings(targetSettings);
+      if (changed) {
+        anyChanged = true;
+        this.persistProjectedProviderState(targetSettings, providerId);
+        if (providerId !== settingsProvider) {
+          mergeProviderSettings(settings, targetSettings);
+        }
+      }
+    }
+
+    if (this.reconcileTitleGenerationModelSelection(settings)) {
+      anyChanged = true;
+    }
+    return anyChanged;
+  }
+
+  /**
+   * Project the settings provider's saved values into the top-level
+   * model/effortLevel/thinkingBudget fields.
+   */
+  static projectActiveProviderState(settings: Record<string, unknown>): void {
+    this.projectProviderState(settings, getSettingsProviderId(settings));
+  }
+}

package/src/core/providers/ProviderWorkspaceRegistry.ts

@@ -0,0 +1,119 @@
+import type ClaudianPlugin from '../../main';
+import { HomeFileAdapter } from '../storage/HomeFileAdapter';
+import type { ProviderCommandCatalog } from './commands/ProviderCommandCatalog';
+import type {
+  AgentMentionProvider,
+  ProviderCliResolver,
+  ProviderId,
+  ProviderRuntimeCommandLoader,
+  ProviderSettingsTabRenderer,
+  ProviderTabWarmupPolicy,
+  ProviderWorkspaceRegistration,
+  ProviderWorkspaceServices,
+} from './types';
+
+/**
+ * Registry for provider-owned workspace/bootstrap services.
+ *
+ * Unlike `ProviderRegistry`, this boundary owns app-level provider services such
+ * as command catalogs, mention providers, MCP/plugin/agent managers, and
+ * provider-specific storage adaptors.
+ */
+export class ProviderWorkspaceRegistry {
+  private static registrations: Partial<Record<ProviderId, ProviderWorkspaceRegistration>> = {};
+  private static services: Partial<Record<ProviderId, ProviderWorkspaceServices>> = {};
+
+  static register(
+    providerId: ProviderId,
+    registration: ProviderWorkspaceRegistration,
+  ): void {
+    this.registrations[providerId] = registration;
+  }
+
+  private static getWorkspaceRegistration(providerId: ProviderId): ProviderWorkspaceRegistration {
+    const registration = this.registrations[providerId];
+    if (!registration) {
+      throw new Error(`Provider workspace "${providerId}" is not registered.`);
+    }
+    return registration;
+  }
+
+  static async initializeAll(plugin: ClaudianPlugin): Promise<void> {
+    const providerIds = Object.keys(this.registrations);
+    const storage = plugin.storage;
+    const vaultAdapter = storage.getAdapter();
+    const homeAdapter = new HomeFileAdapter();
+
+    for (const providerId of providerIds) {
+      this.services[providerId] = await this.getWorkspaceRegistration(providerId).initialize({
+        plugin,
+        storage,
+        vaultAdapter,
+        homeAdapter,
+      });
+    }
+  }
+
+  static setServices(
+    providerId: ProviderId,
+    services: ProviderWorkspaceServices | undefined,
+  ): void {
+    if (services) {
+      this.services[providerId] = services;
+    } else {
+      delete this.services[providerId];
+    }
+  }
+
+  static clear(): void {
+    this.services = {};
+  }
+
+  static getServices(
+    providerId: ProviderId,
+  ): ProviderWorkspaceServices | null {
+    return this.services[providerId] ?? null;
+  }
+
+  static requireServices(
+    providerId: ProviderId,
+  ): ProviderWorkspaceServices {
+    const services = this.getServices(providerId);
+    if (!services) {
+      throw new Error(`Provider workspace "${providerId}" is not initialized.`);
+    }
+    return services;
+  }
+
+  static getCommandCatalog(providerId: ProviderId): ProviderCommandCatalog | null {
+    return this.getServices(providerId)?.commandCatalog ?? null;
+  }
+
+  static getAgentMentionProvider(providerId: ProviderId): AgentMentionProvider | null {
+    return this.getServices(providerId)?.agentMentionProvider ?? null;
+  }
+
+  static async refreshAgentMentions(providerId: ProviderId): Promise<void> {
+    await this.getServices(providerId)?.refreshAgentMentions?.();
+  }
+
+  static getCliResolver(providerId: ProviderId): ProviderCliResolver | null {
+    return this.getServices(providerId)?.cliResolver ?? null;
+  }
+
+  static getRuntimeCommandLoader(providerId: ProviderId): ProviderRuntimeCommandLoader | null {
+    return this.getServices(providerId)?.runtimeCommandLoader ?? null;
+  }
+
+  static getTabWarmupPolicy(providerId: ProviderId): ProviderTabWarmupPolicy | null {
+    return this.getServices(providerId)?.tabWarmupPolicy ?? null;
+  }
+
+  static getMcpServerManager(providerId: ProviderId) {
+    return this.getServices(providerId)?.mcpServerManager ?? null;
+  }
+
+  static getSettingsTabRenderer(providerId: ProviderId): ProviderSettingsTabRenderer | null {
+    return this.getServices(providerId)?.settingsTabRenderer ?? null;
+  }
+}

package/src/core/providers/commands/ProviderCommandCatalog.ts

@@ -0,0 +1,21 @@
+import type { SlashCommand } from '../../types';
+import type { ProviderId } from '../types';
+import type { ProviderCommandEntry } from './ProviderCommandEntry';
+
+export interface ProviderCommandDropdownConfig {
+  providerId: ProviderId;
+  triggerChars: string[];
+  builtInPrefix: string;
+  skillPrefix: string;
+  commandPrefix: string;
+}
+
+export interface ProviderCommandCatalog {
+  listDropdownEntries(context: { includeBuiltIns: boolean }): Promise<ProviderCommandEntry[]>;
+  listVaultEntries(): Promise<ProviderCommandEntry[]>;
+  saveVaultEntry(entry: ProviderCommandEntry): Promise<void>;
+  deleteVaultEntry(entry: ProviderCommandEntry): Promise<void>;
+  setRuntimeCommands(commands: SlashCommand[]): void;
+  getDropdownConfig(): ProviderCommandDropdownConfig;
+  refresh(): Promise<void>;
+}

package/src/core/providers/commands/ProviderCommandEntry.ts

@@ -0,0 +1,33 @@
+import type { SlashCommandSource } from '../../types/settings';
+import type { ProviderId } from '../types';
+
+export type ProviderCommandKind = 'command' | 'skill';
+export type ProviderCommandScope = 'builtin' | 'vault' | 'user' | 'system' | 'runtime';
+
+export interface ProviderCommandEntry {
+  id: string;
+  providerId: ProviderId;
+  kind: ProviderCommandKind;
+  name: string;
+  description?: string;
+  content: string;
+  argumentHint?: string;
+  allowedTools?: string[];
+  model?: string;
+  disableModelInvocation?: boolean;
+  userInvocable?: boolean;
+  context?: 'fork';
+  agent?: string;
+  hooks?: Record<string, unknown>;
+  scope: ProviderCommandScope;
+  source: SlashCommandSource;
+  isEditable: boolean;
+  isDeletable: boolean;
+  displayPrefix: string;
+  insertPrefix: string;
+  /**
+   * Opaque provider-owned persistence token used to preserve storage location
+   * across edits, renames, and deletes in shared settings UIs.
+   */
+  persistenceKey?: string;
+}

package/src/core/providers/commands/hiddenCommands.ts

@@ -0,0 +1,74 @@
+import type { ClaudianSettings, HiddenProviderCommands } from '../../types/settings';
+import type { ProviderId } from '../types';
+
+function normalizeHiddenCommandName(value: string): string {
+  return value.trim().replace(/^[/$]+/, '');
+}
+
+export function normalizeHiddenCommandList(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const seen = new Set<string>();
+  const normalized: string[] = [];
+
+  for (const item of value) {
+    if (typeof item !== 'string') {
+      continue;
+    }
+
+    const commandName = normalizeHiddenCommandName(item);
+    if (!commandName) {
+      continue;
+    }
+
+    const key = commandName.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    normalized.push(commandName);
+  }
+
+  return normalized;
+}
+
+export function getDefaultHiddenProviderCommands(): HiddenProviderCommands {
+  return {};
+}
+
+export function normalizeHiddenProviderCommands(
+  value: unknown,
+): HiddenProviderCommands {
+  if (!value || typeof value !== 'object') {
+    return getDefaultHiddenProviderCommands();
+  }
+
+  const candidate = value as Partial<Record<string, unknown>>;
+  const normalized: HiddenProviderCommands = {};
+
+  for (const [providerId, commands] of Object.entries(candidate)) {
+    const next = normalizeHiddenCommandList(commands);
+    if (next.length > 0) {
+      normalized[providerId] = next;
+    }
+  }
+
+  return normalized;
+}
+
+export function getHiddenProviderCommands(
+  settings: Pick<ClaudianSettings, 'hiddenProviderCommands'>,
+  providerId: ProviderId,
+): string[] {
+  return settings.hiddenProviderCommands?.[providerId] ?? [];
+}
+
+export function getHiddenProviderCommandSet(
+  settings: Pick<ClaudianSettings, 'hiddenProviderCommands'>,
+  providerId: ProviderId,
+): Set<string> {
+  return new Set(getHiddenProviderCommands(settings, providerId).map((command) => command.toLowerCase()));
+}

package/src/core/providers/modelRouting.ts

@@ -0,0 +1,17 @@
+import { ProviderRegistry } from './ProviderRegistry';
+import type { ProviderId } from './types';
+
+export function getProviderForModel(model: string, settings?: Record<string, unknown>): ProviderId {
+  return ProviderRegistry.resolveProviderForModel(model, settings);
+}
+
+export function getEnabledProviderForModel(
+  model: string,
+  settings: Record<string, unknown>,
+  fallbackProviderId?: ProviderId,
+): ProviderId {
+  return ProviderRegistry.resolveProviderForModel(model, settings, {
+    onlyEnabledProviders: true,
+    fallbackProviderId,
+  });
+}