Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

6.6 KB
Raw Blame
import * as React from 'react';
import { CheckCircle2, CircleX, FlaskConical, LoaderCircle } from 'lucide-react';
import { useTranslation } from 'react-i18next';

import { Button } from '@/components/ui/button';
import { Combobox } from '@/components/ui/combobox';
import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogTitle } from '@/components/ui/dialog';
import { cn } from '@/lib/utils';
import { Field } from './dialogFields';
import { apiFailure, modelsApi } from './modelsApi';
import { createContinuationSettlement, type TrackSourceMutation } from './mutationSettlement';
import { foldRegionRead } from './regionRead';
import { serverText } from './serverCopy';
import { selectTestModel } from './testModelPreference';
import type { Source, SourceProbeResult } from './types';

type TestStatus = { kind: 'result'; result: SourceProbeResult; stillCooling: boolean } | { kind: 'unconfirmed' } | null;

export const SourceTestDialog: React.FC<{
  source: Source;
  onClose: () => void;
  trackMutation: TrackSourceMutation;
}> = ({ source, onClose, trackMutation }) => {
  const { t } = useTranslation();
  const [selection, setSelection] = React.useState(() => selectTestModel(source.models));
  const [busy, setBusy] = React.useState(false);
  const [status, setStatus] = React.useState<TestStatus>(null);
  const [continuation] = React.useState(createContinuationSettlement);
  const running = React.useRef(false);
  // Every credential change, a same-handle reauthentication included, mints a new generation that verification keeps.
  const identity = `${source.id}/${source.credential_ref}/${source.credential_generation ?? ''}/${source.base_url}/${source.protocol}`;
  const selected = selectTestModel(source.models, selection);
  React.useEffect(() => {
    continuation.invalidate();
    setStatus(null);
    return () => { continuation.invalidate(); };
  }, [continuation, identity, selected]);
  const options = source.models.filter((model) => !model.retired).map((model) => ({
    value: model.id, label: model.id,
  }));
  const run = async () => {
    if (!selected || running.current) return;
    running.current = true;
    setBusy(true);
    setStatus(null);
    const ticket = continuation.begin();
    try {
      await trackMutation(async (latest, settlement) => {
        let answer: SourceProbeResult;
        try {
          answer = await modelsApi.probeSource(latest.id, selected);
        } catch (error) {
          if (apiFailure(error)?.code === 'source_not_found') await settlement.gone(latest.id);
          else await settlement.unread();
          continuation.settle(ticket, () => setStatus({ kind: 'unconfirmed' }));
          return;
        }
        // Reconciliation, not an old dialog snapshot, owns the current identity.
        // A read this dialog cannot complete leaves the probe unconfirmed rather
        // than retrying the same read here.
        const landing = await settlement.unread();
        const current = landing === null ? undefined : foldRegionRead<Source[], Source | undefined>(landing.sources, {
          loading: () => undefined,
          ready: (sources) => sources.find((item) => item.id === latest.id),
          unread: () => undefined,
          degraded: () => undefined,
        });
        const matches = current && current.credential_ref === latest.credential_ref
          && current.base_url === latest.base_url && current.protocol === latest.protocol
          // Every credential change mints a new generation, which verification keeps.
          && (current.credential_generation ?? null) === (latest.credential_generation ?? null)
          && current.models.some((model) => model.id === selected && !model.retired);
        // Only a verified reply lifts a cooldown, so the reconciled state, not
        // `reachable`, says whether this test restored the provider.
        continuation.settle(ticket, () => setStatus(matches
          ? { kind: 'result', result: answer, stillCooling: current.state.status === 'cooldown' }
          : { kind: 'unconfirmed' }));
      });
    } catch {
      continuation.settle(ticket, () => setStatus({ kind: 'unconfirmed' }));
    } finally {
      running.current = false;
      setBusy(false);
    }
  };
  const result = status?.kind === 'result' ? status.result : null;
  const stillCooling = status?.kind === 'result' && status.stillCooling;
  return (
    <Dialog open onOpenChange={(open) => { if (!open) onClose(); }}>
      <DialogContent closeLabel={t('common.close')}>
        <DialogTitle className="min-w-0 break-words pr-6">{t('settings.models.sourceTest.title', { source: source.display_name })}</DialogTitle>
        <DialogDescription>
          {t('settings.models.sourceTest.hint')}
          {source.state.status === 'cooldown' && ` ${t('settings.models.sourceTest.cooldownHint')}`}
        </DialogDescription>
        <Field label={t('settings.models.sourceTest.model')}>
          {(id) => <Combobox id={id} ariaLabel={t('settings.models.sourceTest.model')} options={options}
            value={selected} disabled={busy || options.length === 0} allowCustomValue={false}
            onValueChange={(value) => { setSelection(value); setStatus(null); }} />}
        </Field>
        {options.length === 0 && <p className="text-sm text-muted">{t('settings.models.sourceTest.empty')}</p>}
        {result && <p role="status" className={cn('min-w-0 break-words text-sm', result.reachable ? 'model-hub-ink-mint' : 'text-destructive-ink')}>
          {result.reachable ? <CheckCircle2 aria-hidden className="mr-1.5 inline size-4 align-[-3px]" /> : <CircleX aria-hidden className="mr-1.5 inline size-4 align-[-3px]" />}
          {result.reachable
            ? t('settings.models.sourceTest.success', { model: result.model_id, ms: result.latency_ms })
            : t('settings.models.sourceTest.failure', {
              model: result.model_id,
              reason: serverText(t, result.error, 'settings.models.sourceTest.unknown'),
            })}
          {result.reachable && stillCooling && ` ${t('settings.models.sourceTest.stillUnavailable')}`}
        </p>}
        {status?.kind === 'unconfirmed' && <p role="alert" className="text-sm text-destructive-ink">{t('settings.models.sourceTest.requestFailed')}</p>}
        <DialogFooter>
          <Button variant="outline" onClick={onClose}>{t('common.close')}</Button>
          <Button disabled={busy || !selected} onClick={() => void run()}>
            {busy ? <LoaderCircle className="size-4 animate-spin" /> : <FlaskConical className="size-4" />}
            {t(busy ? 'settings.models.sourceTest.running' : 'settings.models.sourceTest.run')}
          </Button>
        </DialogFooter>
      </DialogContent>
    </Dialog>
  );
};