Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

49.3 KB
Raw Blame
import { createEffect, createMemo, createSignal, on, onCleanup, onMount } from 'solid-js';
import { createStore } from 'solid-js/store';
import { AIAPI } from '@/api/ai';
import { runPatrolModelReadiness, type PatrolModelReadinessResponse } from '@/api/patrol';
import { getPatrolCostPreview, getPatrolModelGuidance } from '@/api/aiPatrolCost';
import {
  AI_PROVIDERS,
  createInitialProviderHealth,
  isAIProviderConfigured,
  type ProviderHealthState,
  type ProviderTestResult,
} from '@/components/Settings/aiSettingsModel';
import { apiErrorDetails } from '@/api/responseUtils';
import {
  aiRuntimeModels,
  aiRuntimeModelsError,
  clearAIRuntimeModels,
  loadAIRuntimeModels,
  syncAIRuntimeSettings,
} from '@/stores/aiRuntimeState';
import { hasFeature, loadRuntimeCapabilities } from '@/stores/license';
import { getUpgradeActionDestination } from '@/stores/licenseCommercial';
import { presentationPolicyHidesUpgradePrompts } from '@/stores/sessionPresentationPolicy';
import { aiAvailabilityStore } from '@/stores/aiAvailability';
import { notificationStore } from '@/stores/notifications';
import type {
  AISettings as AISettingsType,
  AIProvider,
  AuthMethod,
  ModelInfo,
  PatrolCostProjection,
  PatrolModelGuidanceResponse,
} from '@/types/ai';
import {
  getPatrolIntervalAutoAdjust,
  type PatrolIntervalAutoAdjust,
} from '@/utils/aiPatrolCostPresentation';
import { getAIProviderDisplayName, getProviderFromModelId } from '@/utils/aiProviderPresentation';
import {
  getAICredentialsClearErrorMessage,
  getAIOAuthErrorMessage,
  getAIModelsLoadErrorMessage,
  getAISettingsReadinessPresentation,
  getAISettingsSaveErrorMessage,
  getAISettingsToggleErrorMessage,
} from '@/utils/aiSettingsPresentation';
import { logger } from '@/utils/logger';

type AISettingsSaveProviderFailure = {
  provider: string;
  model?: string;
  providerMessage?: string;
};

interface AISettingsStateOptions {
  saveErrorFallback?: string;
  savedLabel?: string;
}

const AI_SETTINGS_PROVIDER_PAYLOAD_FIELDS: Record<AIProvider, string[]> = {
  anthropic: ['anthropic_api_key'],
  openai: ['openai_api_key', 'openai_base_url'],
  openrouter: ['openrouter_api_key'],
  deepseek: ['deepseek_api_key'],
  zai: ['zai_api_key', 'zai_base_url'],
  groq: ['groq_api_key'],
  mistral: ['mistral_api_key'],
  cerebras: ['cerebras_api_key'],
  together: ['together_api_key'],
  fireworks: ['fireworks_api_key'],
  gemini: ['gemini_api_key'],
  ollama: [
    'ollama_base_url',
    'ollama_keep_alive',
    'ollama_username',
    'ollama_password',
    'clear_ollama_password',
  ],
  'codex-subscription': ['codex_subscription_enabled'],
  'claude-subscription': ['claude_subscription_enabled'],
};

const compactUnique = (values: Array<string | undefined>): string[] => {
  const seen = new Set<string>();
  const result: string[] = [];
  for (const value of values) {
    const normalized = value?.trim();
    if (!normalized || seen.has(normalized)) continue;
    seen.add(normalized);
    result.push(normalized);
  }
  return result;
};

const getProviderTestDiagnosticMessage = (result: {
  message?: string;
  recommendation?: string;
}): string =>
  compactUnique([result.message, result.recommendation]).join(' · ') || 'Connection test failed';

const isKnownAIProvider = (provider: string): provider is AIProvider =>
  AI_PROVIDERS.includes(provider as AIProvider);

const providerPayloadEntries = (payload: Record<string, unknown>): string[] =>
  AI_PROVIDERS.filter((provider) =>
    AI_SETTINGS_PROVIDER_PAYLOAD_FIELDS[provider].some(
      (field) =>
        payload[field] === true ||
        (typeof payload[field] === 'string' && String(payload[field]).trim().length > 0),
    ),
  );

const modelProviderEntries = (models: string[]): Array<{ provider: string; model: string }> =>
  models
    .map((model) => model.trim())
    .filter(Boolean)
    .map((model) => ({
      provider: getProviderFromModelId(model),
      model,
    }));

const findModelForProvider = (
  provider: string,
  models: Array<{ provider: string; model: string }>,
): string | undefined => models.find((entry) => entry.provider === provider)?.model;

const isGenericAISettingsSaveFailure = (error: unknown): boolean => {
  const message = error instanceof Error ? error.message.trim().toLowerCase() : '';
  if (!message) return true;
  return (
    message === 'failed to save pulse intelligence settings' ||
    message === 'failed to save provider & models settings' ||
    message === 'unable to save provider & models settings.' ||
    message === 'unable to save provider & models settings' ||
    message.includes('failed to save pulse intelligence settings') ||
    message.includes('failed to save provider & models settings') ||
    message.startsWith('request failed with status')
  );
};

export function getAISettingsSaveProviderFailureMessage(
  message: string | undefined,
  failure?: AISettingsSaveProviderFailure | null,
  fallback?: string,
): string {
  const baseMessage = getAISettingsSaveErrorMessage(message, fallback);
  if (!failure?.provider) return baseMessage;

  const providerLabel = getAIProviderDisplayName(failure.provider);
  const lowerBase = baseMessage.toLowerCase();
  const context = [
    lowerBase.includes(providerLabel.toLowerCase()) ? undefined : `${providerLabel} provider`,
    failure.model && !baseMessage.includes(failure.model) ? `model ${failure.model}` : undefined,
    failure.providerMessage && !baseMessage.includes(failure.providerMessage)
      ? failure.providerMessage
      : undefined,
  ].filter((value): value is string => Boolean(value));

  return context.length > 0 ? `${context.join(' · ')}: ${baseMessage}` : baseMessage;
}

export function getAISettingsPatrolReadinessSaveMessage(
  readiness: AISettingsType['patrol_readiness'] | null | undefined,
  savedLabel = 'Provider & Models settings saved',
): string | null {
  if (!readiness || readiness.status === 'ready') return null;

  const provider = readiness.provider ? getAIProviderDisplayName(readiness.provider) : '';
  const model = readiness.model?.trim();
  const context = [
    readiness.summary?.trim(),
    provider ? `Provider: ${provider}` : undefined,
    model ? `Model: ${model}` : undefined,
  ].filter((value): value is string => Boolean(value));
  const readinessLabel = readiness.status === 'not_ready' ? 'not ready' : 'degraded';

  return context.length > 0
    ? `${savedLabel}, but Patrol is ${readinessLabel}: ${context.join(' · ')}`
    : `${savedLabel}, but Patrol is ${readinessLabel}.`;
}

export function resolveAISettingsSaveProviderFailure(input: {
  error: unknown;
  payload: Record<string, unknown>;
  providerHealth: Record<AIProvider, ProviderHealthState>;
  models: string[];
}): AISettingsSaveProviderFailure | null {
  const details = apiErrorDetails(input.error);
  const detailProvider = details?.provider?.trim();
  const detailModel = details?.model?.trim();
  if (detailProvider) {
    return {
      provider: detailProvider,
      model: detailModel,
      providerMessage: details?.cause || details?.reason || details?.summary,
    };
  }

  const modelEntries = modelProviderEntries(input.models);
  const payloadProviders = providerPayloadEntries(input.payload);
  const canUseLocalProviderContext =
    payloadProviders.length > 0 || isGenericAISettingsSaveFailure(input.error);
  if (!canUseLocalProviderContext) {
    return null;
  }
  const candidateProviders = compactUnique([
    ...payloadProviders,
    ...modelEntries.map((entry) => entry.provider),
  ]);

  const erroredCandidate = candidateProviders.find(
    (provider) => isKnownAIProvider(provider) && input.providerHealth[provider].status === 'error',
  );
  if (erroredCandidate && isKnownAIProvider(erroredCandidate)) {
    return {
      provider: erroredCandidate,
      model: findModelForProvider(erroredCandidate, modelEntries),
      providerMessage: input.providerHealth[erroredCandidate].message,
    };
  }

  const anyErroredProvider = AI_PROVIDERS.find(
    (provider) => input.providerHealth[provider].status === 'error',
  );
  if (anyErroredProvider) {
    return {
      provider: anyErroredProvider,
      model: findModelForProvider(anyErroredProvider, modelEntries),
      providerMessage: input.providerHealth[anyErroredProvider].message,
    };
  }

  if (candidateProviders.length === 1) {
    const provider = candidateProviders[0];
    return {
      provider,
      model: findModelForProvider(provider, modelEntries),
    };
  }

  return null;
}

export const useAISettingsState = (options: AISettingsStateOptions = {}) => {
  const [settings, setSettings] = createSignal<AISettingsType | null>(null);
  const [loading, setLoading] = createSignal(false);
  const [loadError, setLoadError] = createSignal(false);
  const [saving, setSaving] = createSignal(false);
  const [testing, setTesting] = createSignal(false);

  const [availableModels, setAvailableModels] = createSignal<ModelInfo[]>([]);
  const [modelsLoading, setModelsLoading] = createSignal(false);
  const [modelsError, setModelsError] = createSignal('');

  const [expandedProviders, setExpandedProviders] = createSignal<Set<AIProvider>>(
    new Set(['anthropic']),
  );
  // Tracks whether the initial expand policy has been applied, so later
  // resetForm calls (after every save) preserve the operator's own
  // expand/collapse choices instead of clobbering them.
  const [providersExpandedInitialized, setProvidersExpandedInitialized] = createSignal(false);

  const [testingProvider, setTestingProvider] = createSignal<AIProvider | null>(null);
  const [providerTestResult, setProviderTestResult] = createSignal<ProviderTestResult | null>(null);
  const [providerHealth, setProviderHealth] = createStore<Record<AIProvider, ProviderHealthState>>(
    createInitialProviderHealth(),
  );
  const [preflightRunning, setPreflightRunning] = createSignal(false);
  const [preflightLastCheckedAt, setPreflightLastCheckedAt] = createSignal<number | null>(null);
  const [patrolModelReadinessRunning, setPatrolModelReadinessRunning] = createSignal(false);
  const [patrolModelReadinessResult, setPatrolModelReadinessResult] =
    createSignal<PatrolModelReadinessResponse | null>(null);
  let patrolModelReadinessAbortController: AbortController | null = null;

  const hydratePatrolModelReadinessFromSettings = (data: AISettingsType | null) => {
    setPatrolModelReadinessResult(data?.patrol_model_readiness ?? null);
  };

  // Cost preview and model guidance for the Patrol model choice. The server
  // owns the price table and the install's run history; the form only says
  // which model and schedule to price.
  const [patrolCostPreview, setPatrolCostPreview] = createSignal<PatrolCostProjection | null>(null);
  const [patrolCostPreviewLoading, setPatrolCostPreviewLoading] = createSignal(false);
  const [patrolModelGuidance, setPatrolModelGuidance] =
    createSignal<PatrolModelGuidanceResponse | null>(null);
  const [patrolIntervalAutoAdjust, setPatrolIntervalAutoAdjust] =
    createSignal<PatrolIntervalAutoAdjust | null>(null);
  let patrolCostPreviewAbortController: AbortController | null = null;
  let patrolCostPreviewTimer: ReturnType<typeof setTimeout> | null = null;
  let patrolCostPreviewUserSelection = false;

  const loadPatrolModelGuidance = async () => {
    try {
      setPatrolModelGuidance(await getPatrolModelGuidance());
    } catch (error) {
      logger.debug('[AISettings] Failed to load Patrol model guidance:', error);
    }
  };

  const refreshPatrolCostPreview = async () => {
    const userSelection = patrolCostPreviewUserSelection;
    patrolCostPreviewUserSelection = false;
    const model = effectivePatrolModel();
    const intervalMinutes = form.patrolIntervalMinutes;
    patrolCostPreviewAbortController?.abort();
    if (!model) {
      patrolCostPreviewAbortController = null;
      setPatrolCostPreview(null);
      setPatrolCostPreviewLoading(false);
      return;
    }
    const controller = new AbortController();
    patrolCostPreviewAbortController = controller;
    setPatrolCostPreviewLoading(true);
    try {
      const projection = await getPatrolCostPreview({ model, intervalMinutes }, controller.signal);
      if (controller.signal.aborted) return;
      setPatrolCostPreview(projection ?? null);
      if (userSelection && projection) {
        const adjust = getPatrolIntervalAutoAdjust(projection, {
          currentIntervalMinutes: form.patrolIntervalMinutes,
          savedIntervalMinutes: settings()?.patrol_interval_minutes ?? 360,
        });
        if (adjust) {
          setForm('patrolIntervalMinutes', adjust.to);
          setPatrolIntervalAutoAdjust(adjust);
        }
      }
    } catch (error) {
      if (controller.signal.aborted) return;
      logger.debug('[AISettings] Failed to load Patrol cost preview:', error);
      setPatrolCostPreview(null);
    } finally {
      if (patrolCostPreviewAbortController === controller) {
        patrolCostPreviewAbortController = null;
        setPatrolCostPreviewLoading(false);
      }
    }
  };

  const schedulePatrolCostPreviewRefresh = () => {
    if (patrolCostPreviewTimer) clearTimeout(patrolCostPreviewTimer);
    patrolCostPreviewTimer = setTimeout(() => {
      patrolCostPreviewTimer = null;
      void refreshPatrolCostPreview();
    }, 150);
  };

  type ModelFormKey = 'model' | 'patrolModel';
  // Model picks made by the operator (as opposed to loads and resets) are
  // the only moment the schedule may be defaulted for a per-token model.
  const handleModelSelection = (formKey: ModelFormKey, modelId: string) => {
    if (formKey === 'model' || formKey === 'patrolModel') {
      patrolCostPreviewUserSelection = true;
    }
    setForm(formKey, modelId);
  };

  const [showSetupModal, setShowSetupModal] = createSignal(false);
  const [setupProvider, setSetupProvider] = createSignal<AIProvider>('anthropic');
  const [setupApiKey, setSetupApiKey] = createSignal('');
  const [setupOllamaUrl, setSetupOllamaUrl] = createSignal('http://localhost:11434');
  const [setupSaving, setSetupSaving] = createSignal(false);
  const [showAdvancedModels, setShowAdvancedModels] = createSignal(false);

  const [form, setForm] = createStore({
    enabled: false,
    model: '',
    patrolModel: '',
    autoFixModel: '',
    authMethod: 'api_key' as AuthMethod,
    patrolIntervalMinutes: 360,
    alertTriggeredAnalysis: true,
    patrolAlertTriggers: true,
    patrolAnomalyTriggers: true,
    patrolAlertTriggerMinSeverity: 'critical' as 'warning' | 'critical',
    patrolFindingNotifications: true,
    patrolFindingNotifyMinSeverity: 'warning' as 'warning' | 'critical',
    patrolAutoFix: false,
    anthropicApiKey: '',
    openaiApiKey: '',
    openrouterApiKey: '',
    deepseekApiKey: '',
    zaiApiKey: '',
    groqApiKey: '',
    mistralApiKey: '',
    cerebrasApiKey: '',
    togetherApiKey: '',
    fireworksApiKey: '',
    geminiApiKey: '',
    ollamaBaseUrl: 'http://localhost:11434',
    ollamaKeepAlive: '',
    ollamaUsername: '',
    ollamaPassword: '',
    clearOllamaPassword: false,
    openaiBaseUrl: '',
    zaiBaseUrl: '',
    codexSubscriptionEnabled: false,
    claudeSubscriptionEnabled: false,
    costBudgetUSD30d: '',
    requestTimeoutSeconds: 300,
  });

  const showUpgradePrompts = () => !presentationPolicyHidesUpgradePrompts();

  const settingsReadiness = createMemo(() =>
    getAISettingsReadinessPresentation({
      configured: Boolean(settings()?.configured),
      providerCount: settings()?.configured_providers?.length || 0,
      modelCount: availableModels().length,
    }),
  );
  const autoFixLocked = createMemo(() => !hasFeature('ai_autofix'));
  const alertAnalysisLocked = createMemo(() => !hasFeature('ai_alerts'));
  const providerIssueCount = createMemo(
    () => AI_PROVIDERS.filter((provider) => providerHealth[provider].status === 'error').length,
  );
  const hasConfiguredProvider = createMemo(() => {
    const current = settings();
    return Boolean(
      current &&
      (current.anthropic_configured ||
        current.openai_configured ||
        current.openrouter_configured ||
        current.deepseek_configured ||
        current.zai_configured ||
        current.groq_configured ||
        current.mistral_configured ||
        current.cerebras_configured ||
        current.together_configured ||
        current.fireworks_configured ||
        current.gemini_configured ||
        current.codex_subscription_enabled ||
        current.claude_subscription_enabled ||
        current.ollama_configured),
    );
  });

  const effectivePatrolModel = createMemo(() => (form.patrolModel || form.model).trim());
  const upgradeAutofixDestination = () => getUpgradeActionDestination('ai_autofix');

  const hasProviderBackedModels = (data: AISettingsType | null | undefined) =>
    (data?.configured_providers?.length ?? 0) > 0;

  const syncModelCatalogForSettings = (data: AISettingsType | null | undefined) => {
    syncAIRuntimeSettings(data ?? null);
    if (hasProviderBackedModels(data)) {
      void loadModels();
      return;
    }
    setAvailableModels([]);
    setModelsError('');
    clearAIRuntimeModels();
  };

  const resetForm = (data: AISettingsType | null) => {
    if (!data) {
      setForm({
        enabled: false,
        model: '',
        patrolModel: '',
        autoFixModel: '',
        authMethod: 'api_key',
        patrolIntervalMinutes: 360,
        alertTriggeredAnalysis: true,
        patrolAlertTriggers: true,
        patrolAnomalyTriggers: true,
        patrolAlertTriggerMinSeverity: 'critical',
        patrolFindingNotifications: true,
        patrolFindingNotifyMinSeverity: 'warning',
        patrolAutoFix: false,
        anthropicApiKey: '',
        openaiApiKey: '',
        openrouterApiKey: '',
        deepseekApiKey: '',
        zaiApiKey: '',
        groqApiKey: '',
        mistralApiKey: '',
        cerebrasApiKey: '',
        togetherApiKey: '',
        fireworksApiKey: '',
        geminiApiKey: '',
        ollamaBaseUrl: 'http://localhost:11434',
        ollamaKeepAlive: '',
        ollamaUsername: '',
        ollamaPassword: '',
        clearOllamaPassword: false,
        openaiBaseUrl: '',
        zaiBaseUrl: '',
        codexSubscriptionEnabled: false,
        claudeSubscriptionEnabled: false,
        costBudgetUSD30d: '',
        requestTimeoutSeconds: 300,
      });
      return;
    }

    const legacyEventTriggersEnabled =
      data.patrol_event_triggers_enabled ?? data.alert_triggered_analysis !== false;

    setForm({
      enabled: data.enabled,
      model: data.model || '',
      patrolModel: data.patrol_model || '',
      autoFixModel: data.auto_fix_model || '',
      authMethod: data.auth_method || 'api_key',
      patrolIntervalMinutes: data.patrol_interval_minutes ?? 360,
      alertTriggeredAnalysis: data.alert_triggered_analysis !== false,
      patrolAlertTriggers: data.patrol_alert_triggers_enabled ?? legacyEventTriggersEnabled,
      patrolAnomalyTriggers: data.patrol_anomaly_triggers_enabled ?? legacyEventTriggersEnabled,
      patrolAlertTriggerMinSeverity:
        data.patrol_alert_trigger_min_severity === 'warning' ? 'warning' : 'critical',
      patrolFindingNotifications: data.patrol_finding_notifications_enabled !== false,
      patrolFindingNotifyMinSeverity:
        data.patrol_finding_notify_min_severity === 'critical' ? 'critical' : 'warning',
      patrolAutoFix: data.patrol_auto_fix || false,
      anthropicApiKey: '',
      openaiApiKey: '',
      openrouterApiKey: '',
      deepseekApiKey: '',
      zaiApiKey: '',
      groqApiKey: '',
      mistralApiKey: '',
      cerebrasApiKey: '',
      togetherApiKey: '',
      fireworksApiKey: '',
      geminiApiKey: '',
      ollamaBaseUrl: data.ollama_base_url || 'http://localhost:11434',
      ollamaKeepAlive: data.ollama_keep_alive ?? '',
      ollamaUsername: data.ollama_username ?? '',
      ollamaPassword: '',
      clearOllamaPassword: false,
      openaiBaseUrl: data.openai_base_url || '',
      zaiBaseUrl: data.zai_base_url || '',
      codexSubscriptionEnabled: Boolean(data.codex_subscription_enabled),
      claudeSubscriptionEnabled: Boolean(data.claude_subscription_enabled),
      costBudgetUSD30d:
        typeof data.cost_budget_usd_30d === 'number' && data.cost_budget_usd_30d > 0
          ? String(data.cost_budget_usd_30d)
          : '',
      requestTimeoutSeconds: data.request_timeout_seconds ?? 300,
    });

    const configured = new Set<AIProvider>();
    if (data.anthropic_configured) configured.add('anthropic');
    if (data.openai_configured) configured.add('openai');
    if (data.openrouter_configured) configured.add('openrouter');
    if (data.deepseek_configured) configured.add('deepseek');
    if (data.gemini_configured) configured.add('gemini');
    if (data.zai_configured) configured.add('zai');
    if (data.groq_configured) configured.add('groq');
    if (data.mistral_configured) configured.add('mistral');
    if (data.cerebras_configured) configured.add('cerebras');
    if (data.together_configured) configured.add('together');
    if (data.fireworks_configured) configured.add('fireworks');
    if (data.codex_subscription_enabled) configured.add('codex-subscription');
    if (data.claude_subscription_enabled) configured.add('claude-subscription');
    if (data.ollama_configured) configured.add('ollama');
    // Apply the expand policy only on the first load. Guide first-time
    // setup by expanding the default provider when nothing is configured
    // yet; once at least one provider is configured, keep the list
    // collapsed — the per-provider badges and the health callout already
    // convey status, and expanding every configured provider just produces
    // a wall of API-key inputs. Later saves preserve the operator's own
    // expand/collapse selections.
    if (!providersExpandedInitialized()) {
      setProvidersExpandedInitialized(true);
      setExpandedProviders(
        configured.size === 0 ? new Set<AIProvider>(['anthropic']) : new Set<AIProvider>(),
      );
    }
  };

  const loadModels = async () => {
    setModelsLoading(true);
    setModelsError('');
    try {
      await loadAIRuntimeModels(true);
      const nextError = aiRuntimeModelsError();
      if (nextError) {
        setModelsError(nextError);
        logger.debug('[AISettings] API returned error for models:', nextError);
      }
      setAvailableModels(aiRuntimeModels());
    } catch (error) {
      const message = getAIModelsLoadErrorMessage(error instanceof Error ? error.message : '');
      setModelsError(message);
      setAvailableModels([]);
      logger.debug('[AISettings] Failed to load models from API:', error);
    } finally {
      setModelsLoading(false);
    }
  };

  const selectedModelForProviderTest = (provider: AIProvider): string | undefined =>
    compactUnique([form.patrolModel, form.autoFixModel, form.model]).find(
      (model) => getProviderFromModelId(model) === provider,
    );

  const handleCloseSetupModal = () => {
    setShowSetupModal(false);
    setSetupApiKey('');
  };

  const openEnableSetupModal = () => {
    setShowSetupModal(true);
  };

  const checkProviderHealth = async (
    provider: AIProvider,
    opts: { notify?: boolean; storeManualResult?: boolean } = {},
  ): Promise<ProviderTestResult> => {
    try {
      const result = await AIAPI.testProvider(provider, selectedModelForProviderTest(provider));
      const message = getProviderTestDiagnosticMessage(result);
      const normalizedResult: ProviderTestResult = {
        provider,
        success: result.success,
        message,
        model: result.model,
        cause: result.cause,
        summary: result.summary,
        recommendation: result.recommendation,
        action: result.action,
      };
      setProviderHealth(provider, {
        status: result.success ? 'ok' : 'error',
        message,
        model: result.model,
        cause: result.cause,
        summary: result.summary,
        recommendation: result.recommendation,
        action: result.action,
      });
      if (opts.storeManualResult) {
        setProviderTestResult(normalizedResult);
      }
      if (opts.notify) {
        if (result.success) {
          notificationStore.success(`${provider}: ${result.message}`);
        } else {
          notificationStore.error(`${provider}: ${result.message}`);
        }
      }
      return normalizedResult;
    } catch (error) {
      const message = error instanceof Error ? error.message : 'Connection test failed';
      const result: ProviderTestResult = { provider, success: false, message };
      setProviderHealth(provider, {
        status: 'error',
        message,
        model: undefined,
        cause: undefined,
        summary: undefined,
        recommendation: undefined,
        action: undefined,
      });
      if (opts.storeManualResult) {
        setProviderTestResult(result);
      }
      if (opts.notify) {
        notificationStore.error(`${provider}: ${message}`);
      }
      return result;
    }
  };

  const runProviderPreflight = async (settingsSnapshot?: AISettingsType | null) => {
    const current = settingsSnapshot ?? settings();
    if (!current) {
      return;
    }

    const configuredProviders = AI_PROVIDERS.filter((provider) =>
      isAIProviderConfigured(provider, current),
    );
    for (const provider of AI_PROVIDERS) {
      if (!configuredProviders.includes(provider)) {
        setProviderHealth(provider, {
          status: 'not_configured',
          message: '',
          model: undefined,
          cause: undefined,
          summary: undefined,
          recommendation: undefined,
          action: undefined,
        });
      }
    }
    if (configuredProviders.length === 0) {
      setPreflightLastCheckedAt(Date.now());
      return;
    }

    setPreflightRunning(true);
    try {
      await Promise.all(
        configuredProviders.map(async (provider) => {
          setProviderHealth(provider, {
            status: 'checking',
            message: '',
            model: undefined,
            cause: undefined,
            summary: undefined,
            recommendation: undefined,
            action: undefined,
          });
          await checkProviderHealth(provider, { notify: false, storeManualResult: false });
        }),
      );
      setPreflightLastCheckedAt(Date.now());
    } finally {
      setPreflightRunning(false);
    }
  };

  // Run the heavier advisor only on explicit operator action. It uses the
  // pending model selection, the same streaming transport as Patrol, and an
  // AbortSignal so slow local models can be cancelled without leaving a
  // provider request running in the backend.
  const runPatrolModelReadinessAdvisor = async () => {
    const controller = new AbortController();
    patrolModelReadinessAbortController?.abort();
    patrolModelReadinessAbortController = controller;
    setPatrolModelReadinessRunning(true);
    try {
      const pendingModel = form.patrolModel.trim();
      const result = await runPatrolModelReadiness(
        pendingModel ? { model: pendingModel } : {},
        controller.signal,
      );
      setPatrolModelReadinessResult(result);
      void loadPatrolModelGuidance();
    } catch (error) {
      const errorName =
        typeof error === 'object' && error !== null && 'name' in error ? String(error.name) : '';
      if (errorName === 'AbortError') {
        notificationStore.info('Patrol model evaluation cancelled.');
        return;
      }
      const message =
        error instanceof Error && error.message
          ? error.message
          : 'Pulse could not run the Patrol model readiness evaluation.';
      setPatrolModelReadinessResult({
        probe_version: 'patrol-readiness/v1',
        success: false,
        status: 'fail',
        duration_ms: 0,
        summary: message,
        recommendation:
          'Check that the backend is running and that you have settings-write permission, then retry.',
        dimensions: {
          connectivity: { status: 'fail', summary: message },
          tool_protocol: { status: 'not_assessed', summary: 'Not assessed.' },
          context_quality: { status: 'not_assessed', summary: 'Not assessed.' },
          latency: { status: 'not_assessed', summary: 'Not assessed.' },
        },
        modes: {
          monitor: { status: 'not_assessed', summary: 'Not assessed.' },
          approval: { status: 'not_assessed', summary: 'Not assessed.' },
          assisted: { status: 'not_assessed', summary: 'Extended verification required.' },
          full: { status: 'not_assessed', summary: 'Governed canary required.' },
        },
        recorded_at: new Date().toISOString(),
        recorded_at_unix: Math.floor(Date.now() / 1000),
      });
    } finally {
      if (patrolModelReadinessAbortController === controller) {
        patrolModelReadinessAbortController = null;
        setPatrolModelReadinessRunning(false);
      }
    }
  };

  const cancelPatrolModelReadinessAdvisor = () => {
    patrolModelReadinessAbortController?.abort();
  };

  const loadSettings = async () => {
    setLoading(true);
    setLoadError(false);
    try {
      const data = await AIAPI.getSettings();
      setSettings(data);
      resetForm(data);
      syncModelCatalogForSettings(data);
      hydratePatrolModelReadinessFromSettings(data);
      void loadPatrolModelGuidance();
      void runProviderPreflight(data);
    } catch (error) {
      logger.error('[AISettings] Failed to load settings:', error);
      setLoadError(true);
      setSettings(null);
      resetForm(null);
      setAvailableModels([]);
      setModelsError('');
      setProviderHealth(createInitialProviderHealth());
      setPreflightLastCheckedAt(null);
      setPatrolModelReadinessResult(null);
    } finally {
      setLoading(false);
    }
  };

  const handleSetupSubmit = async () => {
    setSetupSaving(true);
    let payload: Record<string, unknown> = {};
    try {
      payload = { enabled: true };

      if (setupProvider() === 'anthropic') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Anthropic API key');
          return;
        }
        payload.anthropic_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'openai') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your OpenAI API key');
          return;
        }
        payload.openai_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'openrouter') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your OpenRouter API key');
          return;
        }
        payload.openrouter_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'deepseek') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your DeepSeek API key');
          return;
        }
        payload.deepseek_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'zai') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Z.ai API key');
          return;
        }
        payload.zai_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'groq') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Groq API key');
          return;
        }
        payload.groq_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'mistral') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Mistral API key');
          return;
        }
        payload.mistral_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'cerebras') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Cerebras API key');
          return;
        }
        payload.cerebras_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'together') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Together AI API key');
          return;
        }
        payload.together_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'fireworks') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Fireworks AI API key');
          return;
        }
        payload.fireworks_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'gemini') {
        if (!setupApiKey().trim()) {
          notificationStore.error('Please enter your Google Gemini API key');
          return;
        }
        payload.gemini_api_key = setupApiKey().trim();
      } else if (setupProvider() === 'codex-subscription') {
        payload.codex_subscription_enabled = true;
      } else if (setupProvider() === 'claude-subscription') {
        payload.claude_subscription_enabled = true;
      } else {
        if (!setupOllamaUrl().trim()) {
          notificationStore.error('Please enter your Ollama server URL');
          return;
        }
        payload.ollama_base_url = setupOllamaUrl().trim();
      }

      const updated = await AIAPI.updateSettings(payload);
      setSettings(updated);
      setForm('enabled', true);
      resetForm(updated);
      syncModelCatalogForSettings(updated);
      hydratePatrolModelReadinessFromSettings(updated);
      void runProviderPreflight(updated);
      handleCloseSetupModal();
      // Reveal the Patrol entry points without a reload (the bootstrap only
      // reads the capability on page load).
      void aiAvailabilityStore.refreshEnabledFromServer();
      const patrolReadinessMessage = getAISettingsPatrolReadinessSaveMessage(
        updated.patrol_readiness,
        'Pulse Intelligence enabled',
      );
      if (patrolReadinessMessage) {
        notificationStore.warning(patrolReadinessMessage);
      } else {
        notificationStore.success(
          'Pulse Intelligence enabled. Patrol is ready to check your infrastructure.',
        );
      }
    } catch (error) {
      logger.error('[AISettings] Setup failed:', error);
      const providerFailure = resolveAISettingsSaveProviderFailure({
        error,
        payload,
        providerHealth,
        models: [form.model, form.patrolModel, form.autoFixModel],
      });
      notificationStore.error(
        getAISettingsSaveProviderFailureMessage(
          error instanceof Error ? error.message : 'Setup failed',
          providerFailure,
        ),
      );
    } finally {
      setSetupSaving(false);
    }
  };

  const handleSave = async (event?: Event) => {
    event?.preventDefault();

    if (settings() === null) {
      notificationStore.error('Cannot save: settings failed to load. Please retry loading first.');
      return;
    }

    const selectedModel = form.model.trim();
    if (selectedModel && form.enabled) {
      const modelProvider = getProviderFromModelId(selectedModel);
      if (!isAIProviderConfigured(modelProvider, settings())) {
        const isAddingCredential =
          (modelProvider === 'anthropic' && form.anthropicApiKey.trim()) ||
          (modelProvider === 'openai' && (form.openaiApiKey.trim() || form.openaiBaseUrl.trim())) ||
          (modelProvider === 'openrouter' && form.openrouterApiKey.trim()) ||
          (modelProvider === 'deepseek' && form.deepseekApiKey.trim()) ||
          (modelProvider === 'zai' && form.zaiApiKey.trim()) ||
          (modelProvider === 'groq' && form.groqApiKey.trim()) ||
          (modelProvider === 'mistral' && form.mistralApiKey.trim()) ||
          (modelProvider === 'cerebras' && form.cerebrasApiKey.trim()) ||
          (modelProvider === 'together' && form.togetherApiKey.trim()) ||
          (modelProvider === 'fireworks' && form.fireworksApiKey.trim()) ||
          (modelProvider === 'gemini' && form.geminiApiKey.trim()) ||
          (modelProvider === 'codex-subscription' && form.codexSubscriptionEnabled) ||
          (modelProvider === 'claude-subscription' && form.claudeSubscriptionEnabled) ||
          (modelProvider === 'ollama' && form.ollamaBaseUrl.trim());

        if (!isAddingCredential) {
          notificationStore.error(
            `Cannot save: Model "${selectedModel}" requires ${getAIProviderDisplayName(modelProvider) || modelProvider} to be configured. ` +
              `Please add an API key for ${getAIProviderDisplayName(modelProvider) || modelProvider} or select a different model.`,
          );
          return;
        }
      }
    }

    if (form.patrolIntervalMinutes > 0 && form.patrolIntervalMinutes < 10) {
      notificationStore.error('Patrol interval must be at least 10 minutes (or 0 to disable)');
      return;
    }

    setSaving(true);
    let payload: Record<string, unknown> = {};
    try {
      payload = {
        model: selectedModel,
      };

      if (form.enabled !== settings()?.enabled) {
        payload.enabled = form.enabled;
      }
      if (form.patrolIntervalMinutes !== (settings()?.patrol_interval_minutes ?? 360)) {
        payload.patrol_interval_minutes = form.patrolIntervalMinutes;
      }
      if (form.alertTriggeredAnalysis !== settings()?.alert_triggered_analysis) {
        payload.alert_triggered_analysis = form.alertTriggeredAnalysis;
      }
      if (form.patrolAlertTriggers !== (settings()?.patrol_alert_triggers_enabled ?? true)) {
        payload.patrol_alert_triggers_enabled = form.patrolAlertTriggers;
      }
      if (form.patrolAnomalyTriggers !== (settings()?.patrol_anomaly_triggers_enabled ?? true)) {
        payload.patrol_anomaly_triggers_enabled = form.patrolAnomalyTriggers;
      }
      if (
        form.patrolAlertTriggerMinSeverity !==
        (settings()?.patrol_alert_trigger_min_severity ?? 'critical')
      ) {
        payload.patrol_alert_trigger_min_severity = form.patrolAlertTriggerMinSeverity;
      }
      if (
        form.patrolFindingNotifications !==
        (settings()?.patrol_finding_notifications_enabled ?? true)
      ) {
        payload.patrol_finding_notifications_enabled = form.patrolFindingNotifications;
      }
      if (
        form.patrolFindingNotifyMinSeverity !==
        (settings()?.patrol_finding_notify_min_severity ?? 'warning')
      ) {
        payload.patrol_finding_notify_min_severity = form.patrolFindingNotifyMinSeverity;
      }
      if (form.patrolAutoFix !== settings()?.patrol_auto_fix) {
        payload.patrol_auto_fix = form.patrolAutoFix;
      }
      if (form.patrolModel !== (settings()?.patrol_model || '')) {
        payload.patrol_model = form.patrolModel;
      }
      if (form.autoFixModel !== (settings()?.auto_fix_model || '')) {
        payload.auto_fix_model = form.autoFixModel;
      }
      if (form.anthropicApiKey.trim()) {
        payload.anthropic_api_key = form.anthropicApiKey.trim();
      }
      if (form.openaiApiKey.trim()) {
        payload.openai_api_key = form.openaiApiKey.trim();
      }
      if (form.openrouterApiKey.trim()) {
        payload.openrouter_api_key = form.openrouterApiKey.trim();
      }
      if (form.deepseekApiKey.trim()) {
        payload.deepseek_api_key = form.deepseekApiKey.trim();
      }
      if (form.zaiApiKey.trim()) {
        payload.zai_api_key = form.zaiApiKey.trim();
      }
      if (form.groqApiKey.trim()) {
        payload.groq_api_key = form.groqApiKey.trim();
      }
      if (form.mistralApiKey.trim()) {
        payload.mistral_api_key = form.mistralApiKey.trim();
      }
      if (form.cerebrasApiKey.trim()) {
        payload.cerebras_api_key = form.cerebrasApiKey.trim();
      }
      if (form.togetherApiKey.trim()) {
        payload.together_api_key = form.togetherApiKey.trim();
      }
      if (form.fireworksApiKey.trim()) {
        payload.fireworks_api_key = form.fireworksApiKey.trim();
      }
      if (form.geminiApiKey.trim()) {
        payload.gemini_api_key = form.geminiApiKey.trim();
      }
      if (
        form.ollamaBaseUrl.trim() &&
        form.ollamaBaseUrl.trim() !== (settings()?.ollama_base_url || '')
      ) {
        payload.ollama_base_url = form.ollamaBaseUrl.trim();
      }
      if (form.ollamaKeepAlive.trim() !== (settings()?.ollama_keep_alive ?? '')) {
        payload.ollama_keep_alive = form.ollamaKeepAlive.trim();
      }
      if (form.ollamaUsername.trim() !== (settings()?.ollama_username ?? '')) {
        payload.ollama_username = form.ollamaUsername.trim();
      }
      if (form.clearOllamaPassword) {
        payload.clear_ollama_password = true;
      } else if (form.ollamaPassword !== '') {
        payload.ollama_password = form.ollamaPassword;
      }
      if (form.openaiBaseUrl !== (settings()?.openai_base_url || '')) {
        payload.openai_base_url = form.openaiBaseUrl.trim();
      }
      if (form.zaiBaseUrl !== (settings()?.zai_base_url || '')) {
        payload.zai_base_url = form.zaiBaseUrl.trim();
      }
      if (form.codexSubscriptionEnabled !== Boolean(settings()?.codex_subscription_enabled)) {
        payload.codex_subscription_enabled = form.codexSubscriptionEnabled;
      }
      if (form.claudeSubscriptionEnabled !== Boolean(settings()?.claude_subscription_enabled)) {
        payload.claude_subscription_enabled = form.claudeSubscriptionEnabled;
      }

      const rawBudget = form.costBudgetUSD30d.trim();
      const parsedBudget = rawBudget === '' ? 0 : Number(rawBudget);
      if (!Number.isFinite(parsedBudget) || parsedBudget < 0) {
        notificationStore.error('Cost budget must be a non-negative number');
        return;
      }
      const currentBudget = settings()?.cost_budget_usd_30d ?? 0;
      if (Math.abs(parsedBudget - currentBudget) > 0.0001) {
        payload.cost_budget_usd_30d = parsedBudget;
      }

      if (form.requestTimeoutSeconds !== (settings()?.request_timeout_seconds ?? 300)) {
        payload.request_timeout_seconds = form.requestTimeoutSeconds;
      }

      const updated = await AIAPI.updateSettings(payload);
      setSettings(updated);
      resetForm(updated);
      syncModelCatalogForSettings(updated);
      hydratePatrolModelReadinessFromSettings(updated);
      void runProviderPreflight(updated);
      void aiAvailabilityStore.refreshEnabledFromServer();
      const savedLabel = options.savedLabel ?? 'Provider & Models settings saved';
      const patrolReadinessMessage = getAISettingsPatrolReadinessSaveMessage(
        updated.patrol_readiness,
        savedLabel,
      );
      if (patrolReadinessMessage) {
        notificationStore.warning(patrolReadinessMessage);
      } else {
        notificationStore.success(savedLabel);
      }
    } catch (error) {
      logger.error('[AISettings] Failed to save settings:', error);
      const providerFailure = resolveAISettingsSaveProviderFailure({
        error,
        payload,
        providerHealth,
        models: [selectedModel, form.patrolModel, form.autoFixModel],
      });
      notificationStore.error(
        getAISettingsSaveProviderFailureMessage(
          error instanceof Error ? error.message : '',
          providerFailure,
          options.saveErrorFallback,
        ),
      );
    } finally {
      setSaving(false);
    }
  };

  const handleTest = async () => {
    setTesting(true);
    try {
      const result = await AIAPI.testConnection();
      const message = getProviderTestDiagnosticMessage(result);
      if (result.success) {
        notificationStore.success(message);
      } else {
        notificationStore.error(message);
      }
    } catch (error) {
      logger.error('[AISettings] Test failed:', error);
      notificationStore.error(error instanceof Error ? error.message : 'Connection test failed');
    } finally {
      setTesting(false);
    }
  };

  const handleTestProvider = async (provider: AIProvider) => {
    setTestingProvider(provider);
    setProviderTestResult(null);
    try {
      await checkProviderHealth(provider, { notify: true, storeManualResult: true });
    } catch (error) {
      logger.error(`[AISettings] Test ${provider} failed:`, error);
      const message = error instanceof Error ? error.message : 'Connection test failed';
      setProviderTestResult({ provider, success: false, message });
      notificationStore.error(`${provider}: ${message}`);
    } finally {
      setTestingProvider(null);
    }
  };

  const handleClearProvider = async (provider: AIProvider) => {
    const current = settings();
    const configuredCount = [
      current?.anthropic_configured,
      current?.openai_configured,
      current?.openrouter_configured,
      current?.deepseek_configured,
      current?.zai_configured,
      current?.groq_configured,
      current?.mistral_configured,
      current?.cerebras_configured,
      current?.together_configured,
      current?.fireworks_configured,
      current?.gemini_configured,
      current?.codex_subscription_enabled,
      current?.claude_subscription_enabled,
      current?.ollama_configured,
    ].filter(Boolean).length;
    const isLastProvider = configuredCount === 1 && isAIProviderConfigured(provider, current);
    const currentModel = form.model.trim();
    const modelUsesProvider = currentModel && getProviderFromModelId(currentModel) === provider;

    let confirmMessage = `Remove ${getAIProviderDisplayName(provider) || provider} and its saved settings?`;
    if (isLastProvider) {
      confirmMessage =
        'Warning: this is your only configured provider. Removing it will stop Patrol and clear its selected models until you configure another provider. Continue?';
    } else if (modelUsesProvider) {
      confirmMessage = `Your current model uses ${getAIProviderDisplayName(provider) || provider}. Removing it will clear provider-owned model selections. Continue?`;
    } else {
      confirmMessage += " You'll need to configure it again to use this provider.";
    }

    if (!confirm(confirmMessage)) {
      return;
    }

    setSaving(true);
    try {
      const newSettings = await AIAPI.updateSettings({ remove_providers: [provider] });
      setSettings(newSettings);
      resetForm(newSettings);
      syncModelCatalogForSettings(newSettings);
      void runProviderPreflight(newSettings);
      // Removing the last provider disables AI, so Patrol entry points and
      // alert Investigate must drop without a reload.
      void aiAvailabilityStore.refreshEnabledFromServer();

      notificationStore.success(`${getAIProviderDisplayName(provider) || provider} removed`);
    } catch (error) {
      logger.error(`[AISettings] Remove ${provider} failed:`, error);
      const detail = error instanceof Error ? error.message.trim() : '';
      notificationStore.error(
        detail ? getAICredentialsClearErrorMessage(detail) : 'Unable to remove provider.',
      );
    } finally {
      setSaving(false);
    }
  };

  const handleEnabledToggle = async (newValue: boolean) => {
    setForm('enabled', newValue);
    try {
      const updated = await AIAPI.updateSettings({ enabled: newValue });
      setSettings(updated);
      syncModelCatalogForSettings(updated);
      void runProviderPreflight(updated);
      void aiAvailabilityStore.refreshEnabledFromServer();
      notificationStore.success(
        newValue
          ? 'Pulse Intelligence enabled. Patrol is ready to check your infrastructure.'
          : 'Pulse Intelligence disabled',
      );
    } catch (error) {
      setForm('enabled', !newValue);
      logger.error('[AISettings] Failed to toggle AI:', error);
      notificationStore.error(
        getAISettingsToggleErrorMessage(error instanceof Error ? error.message : ''),
      );
    }
  };

  const handleEnableRequest = async (newValue: boolean) => {
    if (!newValue) {
      await handleEnabledToggle(false);
      return;
    }
    if (hasConfiguredProvider()) {
      await handleEnabledToggle(true);
      return;
    }
    openEnableSetupModal();
  };

  onMount(() => {
    loadRuntimeCapabilities();

    if (typeof window !== 'undefined') {
      const params = new URLSearchParams(window.location.search);
      const oauthSuccess = params.get('ai_oauth_success');
      const oauthError = params.get('ai_oauth_error');

      if (oauthSuccess === 'true') {
        notificationStore.success('Successfully connected to Claude with your subscription!');
        window.history.replaceState({}, '', window.location.pathname);
      } else if (oauthError) {
        notificationStore.error(getAIOAuthErrorMessage(oauthError));
        window.history.replaceState({}, '', window.location.pathname);
      }
    }

    void loadSettings();
  });

  createEffect(
    on([effectivePatrolModel, () => form.patrolIntervalMinutes, () => settings()], () => {
      const adjust = patrolIntervalAutoAdjust();
      if (adjust && form.patrolIntervalMinutes !== adjust.to) {
        setPatrolIntervalAutoAdjust(null);
      }
      schedulePatrolCostPreviewRefresh();
    }),
  );

  onCleanup(() => {
    patrolModelReadinessAbortController?.abort();
    patrolCostPreviewAbortController?.abort();
    if (patrolCostPreviewTimer) clearTimeout(patrolCostPreviewTimer);
  });

  return {
    alertAnalysisLocked,
    autoFixLocked,
    availableModels,
    effectivePatrolModel,
    expandedProviders,
    form,
    handleModelSelection,
    handleClearProvider,
    handleCloseSetupModal,
    handleEnableRequest,
    handleEnabledToggle,
    handleSave,
    handleSetupSubmit,
    handleTest,
    handleTestProvider,
    hasConfiguredProvider,
    loading,
    loadError,
    loadModels,
    loadSettings,
    modelsError,
    modelsLoading,
    patrolCostPreview,
    patrolCostPreviewLoading,
    patrolIntervalAutoAdjust,
    patrolModelGuidance,
    patrolModelReadinessResult,
    patrolModelReadinessRunning,
    preflightLastCheckedAt,
    preflightRunning,
    providerHealth,
    providerIssueCount,
    providerTestResult,
    resetForm,
    runProviderPreflight,
    runPatrolModelReadinessAdvisor,
    cancelPatrolModelReadinessAdvisor,
    saving,
    setExpandedProviders,
    setForm,
    setSetupApiKey,
    setSetupOllamaUrl,
    setSetupProvider,
    setShowAdvancedModels,
    setShowSetupModal,
    settings,
    settingsReadiness,
    setupApiKey,
    setupOllamaUrl,
    setupProvider,
    setupSaving,
    showAdvancedModels,
    showSetupModal,
    showUpgradePrompts,
    testing,
    testingProvider,
    upgradeAutofixDestination,
  };
};

export type AISettingsState = ReturnType<typeof useAISettingsState>;