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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
import type { TranslationKey } from '@/i18n/types';
import * as React from 'react';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import {
CircleX,
LoaderCircle,
Save,
TriangleAlert,
X,
} from 'lucide-react';
import { useTranslation } from 'react-i18next';
import { Button } from '@/components/ui/button';
import { useToast } from '@/context/ToastContext';
import { ApiKeyField, ApiKeySourceForm } from './ApiKeySourceForm';
import { apiKeyVendorPreset } from './apiKeyVendors';
import { SearchServiceNotes, SearchServicePrice, SearchVendorFacts } from './SearchServiceParts';
import {
apiKeySourceCreate,
apiKeyWriteSettled,
draftComplete,
EMPTY_API_KEY_DRAFT,
sourceClientNonce,
type ApiKeySourceDraft,
} from './apiKeySourceDraft';
import { classifyModelHubFailure, type ModelHubFailureClass } from './asyncLifetime';
import type { CollectionReadAuthority } from './collectionReadAuthority';
import { GuardDialog } from './GuardDialog';
import { GuardImpact, type GuardPlan } from './GuardImpact';
import { confirmGuardPlan, sendAgreed, unansweredRefusal } from './guardedWrite';
import { apiFailure, modelsApi, type SourceCreated } from './modelsApi';
import {
createContinuationSettlement,
createSourceCreatedDelivery,
type ContinuationTicket,
type SourceMutationLanding,
type SourceMutationSettlement,
type TrackSourceMutation,
} from './mutationSettlement';
import { reconcileUnknownWrite } from './reconcileUnknownWrite';
import { mayHaveWritten, REPAIR_TOAST, wasBlocked } from './repair';
import { serverText } from './serverCopy';
import {
type Source,
type HostedSearchServiceVendor,
type SupplyGap,
} from './types';
type Phase =
| { kind: 'form' }
| { kind: 'working' }
| { kind: 'persist_failure'; messageKey: string | null }
| { kind: 'save_unconfirmed' };
const INITIAL_PHASE: Phase = { kind: 'form' };
/**
* A landed replacement is announced in one toast, in the repair verdict's own
* words and order. Which hops it cost was the guard's question, answered before
* the write, so the toast says only what is still wrong: an Agent the write
* stranded, or a source that is still stopped.
*/
const replacementToast = (source: Source, gaps: SupplyGap[] = []) =>
REPAIR_TOAST[gaps.length > 0 ? 'gaps' : wasBlocked(source.state) ? 'unresolved' : 'repaired'];
type ReplacePhase =
| { kind: 'edit' }
| { kind: 'submitting' }
| { kind: 'failure'; failureClass: ModelHubFailureClass; messageKey?: string | null };
type AddApiKeyDialogProps = {
open: boolean;
onClose: () => void;
} & (
| {
mode?: 'add';
/** A catalog-selected search service reuses create settlement, with a key-only form. */
serviceVendor?: HostedSearchServiceVendor;
onAdded: (created: SourceCreated) => void;
sourceReads: CollectionReadAuthority<Source[]>;
}
| {
mode: 'replace';
source: Source;
trackMutation: TrackSourceMutation;
}
);
const failureMessageKey = (failure: ReturnType<typeof apiFailure>): string | null =>
failure?.detail ?? failure?.code ?? null;
const REPLACE_FAILURE_KEY: Record<ModelHubFailureClass, TranslationKey> = {
'authoritative-terminal': 'settings.models.repair.replaceFailed',
inconclusive: 'settings.models.repair.replaceFailed',
'retryable-provider': 'settings.models.repair.replaceFailed',
};
export const AddApiKeyDialog: React.FC<AddApiKeyDialogProps> = (props) => {
const { open, onClose } = props;
const replaceMode = props.mode === 'replace';
const serviceVendor = replaceMode ? undefined : props.serviceVendor;
const addSourceReads = replaceMode ? null : props.sourceReads;
const addOnAdded = replaceMode ? null : props.onAdded;
const replaceSourceId = replaceMode ? props.source.id : null;
const { t } = useTranslation();
const { showToast } = useToast();
const [draft, setDraft] = React.useState<ApiKeySourceDraft>(EMPTY_API_KEY_DRAFT);
const apiKey = draft.apiKey;
const [revealed, setRevealed] = React.useState(false);
const [phase, setPhase] = React.useState<Phase>(INITIAL_PHASE);
const [replacePhase, setReplacePhase] = React.useState<ReplacePhase>({ kind: 'edit' });
const [guard, setGuard] = React.useState<GuardPlan | null>(null);
const [continuation] = React.useState(createContinuationSettlement);
const [createdDelivery] = React.useState(createSourceCreatedDelivery);
const clientNonce = React.useRef(sourceClientNonce());
React.useEffect(() => {
if (addOnAdded) createdDelivery.update(addOnAdded, onClose);
}, [addOnAdded, createdDelivery, onClose]);
React.useEffect(() => {
continuation.invalidate();
if (open) {
clientNonce.current = sourceClientNonce();
setDraft(EMPTY_API_KEY_DRAFT);
setRevealed(false);
setPhase(INITIAL_PHASE);
setReplacePhase({ kind: 'edit' });
setGuard(null);
}
return () => continuation.invalidate();
}, [continuation, open, replaceSourceId]);
const publishReplacementEvidence = React.useCallback((
seq: ContinuationTicket,
settlement: SourceMutationSettlement,
source: Source,
gaps?: SupplyGap[],
) => {
continuation.settle(seq, () => {
const toast = replacementToast(source, gaps);
showToast(t(toast.key) as string, toast.tone);
onClose();
});
// Entity settlement applies synchronously; collection reconciliation is
// trailing work and cannot gate an outcome already established by evidence.
void settlement.source(source).catch(() => undefined);
}, [continuation, onClose, showToast, t]);
const publishReplacementFailure = React.useCallback((
seq: ContinuationTicket,
failureClass: ModelHubFailureClass,
settle?: () => Promise<SourceMutationLanding>,
messageKey?: string | null,
) => {
continuation.settle(seq, () => {
setGuard(null);
setReplacePhase({ kind: 'failure', failureClass, messageKey });
});
if (settle) void settle().catch(() => undefined);
}, [continuation]);
const persist = React.useCallback(async (seq: ContinuationTicket) => {
if (continuation.settle(seq, () => setPhase({ kind: 'working' })) === 'stale') return;
try {
const created = await modelsApi.createApiKeySource(serviceVendor ? {
kind: 'api_key', vendor: serviceVendor.id, key: draft.apiKey.trim(), client_nonce: clientNonce.current,
...(serviceVendor.facts.tool_only ? { protocol: 'search' as const } : {
protocol: apiKeyVendorPreset(serviceVendor.id)?.protocol,
save_unverified: true,
}),
} : apiKeySourceCreate(draft, clientNonce.current));
createdDelivery.settle(continuation, seq, created);
} catch (error) {
continuation.settle(seq, () => setPhase(apiKeyWriteSettled(error)
? { kind: 'persist_failure', messageKey: failureMessageKey(apiFailure(error)) }
: { kind: 'save_unconfirmed' }));
}
}, [continuation, createdDelivery, draft, serviceVendor]);
// `plan` is the guard's question already answered: the write echoes it, and a
// plan that moved before the forced write lands is resent, not asked again.
const submitReplacement = React.useCallback(async (plan: GuardPlan | null) => {
if (props.mode !== 'replace' || !apiKey.trim() || replacePhase.kind === 'submitting') return;
const key = apiKey.trim();
const seq = continuation.begin();
setReplacePhase({ kind: 'submitting' });
await props.trackMutation(async (latest, settlement) => {
let sent = plan;
try {
const answer = await sendAgreed(plan !== null, plan, (next) => {
sent = next;
return modelsApi.replaceCredential(latest.id, next ? { key, ...confirmGuardPlan(next) } : { key });
});
publishReplacementEvidence(
seq,
settlement,
answer.source,
answer.interrupted,
);
} catch (error) {
const failure = apiFailure(error);
// Only an unconfirmed attempt asks: a confirmed one already resent the
// moving plan within its bound, and ends as the failure below — unless
// the plan now stops an Agent the confirmation did not show.
const refusal = unansweredRefusal(error, plan !== null, plan);
if (refusal) {
settlement.release();
continuation.settle(seq, () => {
setGuard(refusal);
setReplacePhase({ kind: 'edit' });
});
return;
}
let failureClass = classifyModelHubFailure(failure);
if (failure?.code === 'source_not_found') {
publishReplacementFailure(
seq,
failureClass,
() => settlement.gone(latest.id),
);
return;
} else if (mayHaveWritten(failure)) {
try {
const inventory = await settlement.readInventory();
const current = inventory.sources.find((source) => source.id === latest.id);
if (!current) {
failureClass = 'authoritative-terminal';
publishReplacementFailure(
seq,
failureClass,
() => settlement.gone(latest.id, inventory),
);
return;
} else if (
!wasBlocked(current.state)
|| current.credential_generation !== latest.credential_generation
) {
publishReplacementEvidence(
seq,
settlement,
current,
sent?.gaps,
);
return;
}
} catch {
publishReplacementFailure(seq, failureClass, settlement.unread);
return;
}
} else settlement.release();
publishReplacementFailure(seq, failureClass, undefined, failure?.detail);
}
});
}, [apiKey, continuation, props, publishReplacementEvidence, publishReplacementFailure, replacePhase.kind]);
const cancel = React.useCallback(() => {
if (replaceMode) {
if (replacePhase.kind === 'submitting') return;
continuation.invalidate();
onClose();
return;
}
if (phase.kind === 'working') return;
continuation.invalidate();
createdDelivery.close();
}, [continuation, createdDelivery, onClose, phase, replaceMode, replacePhase.kind]);
const retry = async () => {
if (phase.kind === 'save_unconfirmed') {
if (!addSourceReads) return;
const seq = continuation.begin();
const reconciliation = await reconcileUnknownWrite(
() => addSourceReads.readValue(),
(sources) => sources.find((source) => source.client_nonce === clientNonce.current),
);
if (reconciliation.kind === 'committed') {
createdDelivery.settle(continuation, seq, {
source: reconciliation.value,
added_to: [],
adopted_by: reconciliation.value.adopted_by ?? [],
});
return;
}
if (reconciliation.kind === 'absent') {
await persist(seq);
}
return;
}
if (phase.kind === 'persist_failure') await persist(continuation.begin());
};
const clearSaveFailure = () => {
setPhase((current) => current.kind === 'persist_failure' ? INITIAL_PHASE : current);
};
const editKey = (value: string) => {
setDraft((current) => ({ ...current, apiKey: value }));
if (replaceMode && replacePhase.kind === 'failure') setReplacePhase({ kind: 'edit' });
clearSaveFailure();
};
// A vendor change resets the phase outright rather than only clearing a save
// failure: it restates what is being connected to, so an unsettled outcome
// from the previous one no longer describes what the form holds.
const editDraft = (next: ApiKeySourceDraft, field: keyof ApiKeySourceDraft) => {
setDraft(next);
if (field === 'vendor') setPhase(INITIAL_PHASE);
else clearSaveFailure();
};
const isWorking = phase.kind === 'working';
const formLocked = isWorking || phase.kind === 'save_unconfirmed';
const canCancel = replaceMode ? replacePhase.kind !== 'submitting' : !isWorking;
const canSubmit = (serviceVendor ? Boolean(apiKey.trim()) : draftComplete(draft)) && !formLocked;
const replaceTerminalFailure = replacePhase.kind === 'failure'
&& replacePhase.failureClass === 'authoritative-terminal';
const replaceFieldLocked = replacePhase.kind === 'submitting' || replaceTerminalFailure;
return (
<DialogPrimitive.Root open={open} onOpenChange={(next) => !next && canCancel && cancel()}>
<DialogPrimitive.Portal>
<DialogPrimitive.Overlay className="model-hub-add-key-overlay fixed inset-0 z-50" />
<DialogPrimitive.Content
className="model-hub-add-key-dialog fixed left-1/2 top-1/2 z-50 flex max-h-[calc(100dvh-2rem)] -translate-x-1/2 -translate-y-1/2 flex-col gap-0 overflow-hidden border border-border-strong bg-surface p-0 shadow-xl outline-none"
onEscapeKeyDown={(event) => { if (!canCancel) event.preventDefault(); }}
onPointerDownOutside={(event) => { if (!canCancel) event.preventDefault(); }}
>
<header className="model-hub-add-key-head flex flex-col border-b border-border px-5 py-4">
<div className="flex items-center justify-between gap-3">
<DialogPrimitive.Title className="model-hub-add-key-title font-bold text-foreground">
{replaceMode
? t('settings.models.repair.replaceTitle', { name: props.source.display_name })
: serviceVendor ? t('settings.models.searchServices.addVendor', { vendor: serviceVendor.name }) : t('settings.models.addKey.title')}
</DialogPrimitive.Title>
<Button
type="button"
variant="ghost"
size="icon"
className="model-hub-ink-59 size-[27px]"
aria-label={t('settings.models.addKey.cancel')}
disabled={!canCancel}
onClick={cancel}
>
<X className="size-[15px]" />
</Button>
</div>
<DialogPrimitive.Description className="model-hub-add-key-subtitle model-hub-ink-muted-b3 font-mono">
{replaceMode
? t('settings.models.repair.replaceBody')
: serviceVendor ? t(serviceVendor.facts.tool_only ? 'settings.models.searchServices.noModels' : 'settings.models.searchServices.createModelSource', { vendor: serviceVendor.name }) : t('settings.models.addKey.saveFirstHint')}
</DialogPrimitive.Description>
</header>
{replaceMode && (
<div className="model-hub-add-key-body flex flex-col">
<ApiKeyField
value={apiKey}
revealed={revealed}
disabled={replaceFieldLocked}
autoFocus
label={t('settings.models.repair.replaceLabel')}
onChange={editKey}
onToggleReveal={() => setRevealed((value) => !value)}
onEnter={replaceTerminalFailure ? undefined : () => void submitReplacement(null)}
/>
{replacePhase.kind === 'submitting' && (
<div className="model-hub-add-key-strip model-hub-add-key-strip--working">
<LoaderCircle className="model-hub-ink-mint size-3.5 shrink-0 animate-spin" />
<span className="model-hub-add-key-strip-title text-foreground">{t('settings.models.repair.replacing')}</span>
</div>
)}
{replacePhase.kind === 'failure' && (
<div
className="model-hub-add-key-strip model-hub-add-key-strip--error"
data-failure-class={replacePhase.failureClass}
>
<TriangleAlert className="model-hub-add-key-error-ink size-3.5 shrink-0" />
<span className="model-hub-add-key-error-ink model-hub-add-key-strip-title">
{serverText(t, replacePhase.messageKey, REPLACE_FAILURE_KEY[replacePhase.failureClass])
?? t(REPLACE_FAILURE_KEY[replacePhase.failureClass])}
</span>
</div>
)}
</div>
)}
{!replaceMode && (
<div className="model-hub-add-key-body flex flex-col">
{serviceVendor ? <>
<SearchVendorFacts vendor={serviceVendor} />
<SearchServicePrice price={serviceVendor.price} />
<ApiKeyField value={apiKey} revealed={revealed} disabled={formLocked} autoFocus label={t('settings.models.addKey.field.apiKey')} onChange={editKey} onToggleReveal={() => setRevealed((value) => !value)} onEnter={canSubmit ? () => void persist(continuation.begin()) : undefined} />
<p className="model-hub-tool-note">{t(serviceVendor.facts.free_check ? 'settings.models.searchServices.freeCheck' : 'settings.models.searchServices.noFreeCheck')}</p>
<SearchServiceNotes vendor={serviceVendor} />
</> : <ApiKeySourceForm
draft={draft}
disabled={formLocked}
revealed={revealed}
onChange={editDraft}
onToggleReveal={() => setRevealed((value) => !value)}
/>}
{isWorking && <div className="model-hub-add-key-strip model-hub-add-key-strip--working">
<LoaderCircle className="model-hub-ink-mint size-3.5 animate-spin" />
<span className="model-hub-add-key-strip-title">{t('settings.models.addKey.saving')}</span>
</div>}
{phase.kind === 'save_unconfirmed' && (
<div className="model-hub-add-key-strip model-hub-add-key-strip--error">
<CircleX className="model-hub-add-key-error-ink size-3.5 shrink-0" />
<span className="model-hub-add-key-error-ink model-hub-add-key-strip-title">{t('settings.models.addKey.fail.save')}</span>
</div>
)}
{phase.kind === 'persist_failure' && (
<div className="model-hub-add-key-strip model-hub-add-key-strip--error">
<CircleX className="model-hub-add-key-error-ink size-3.5 shrink-0" />
<span className="model-hub-add-key-error-ink model-hub-add-key-strip-title">
{serverText(t, phase.messageKey, 'settings.models.addKey.fail.unclassified')
?? t('settings.models.addKey.fail.unclassified')}
</span>
</div>
)}
</div>
)}
<footer className="model-hub-add-key-foot model-hub-fill-05 flex flex-row flex-wrap items-center justify-end border-t border-border">
{replaceMode ? (
<>
<Button
type="button"
variant="outline"
className="model-hub-add-key-action"
disabled={!canCancel}
onClick={cancel}
>
{t('settings.models.addKey.cancel')}
</Button>
{!replaceTerminalFailure && (
<Button
type="button"
variant="brand"
className="model-hub-add-key-action"
disabled={replacePhase.kind === 'submitting' || !apiKey.trim()}
onClick={() => void submitReplacement(null)}
>
{replacePhase.kind === 'submitting' && <LoaderCircle className="size-3 animate-spin" />}
{t(replacePhase.kind === 'submitting'
? 'settings.models.repair.replacing'
: replacePhase.kind === 'failure'
? 'settings.models.addKey.retry'
: 'settings.models.repair.replaceSubmit')}
</Button>
)}
</>
) : (
<>
<Button
type="button"
variant="outline"
className="model-hub-add-key-action"
disabled={!canCancel}
onClick={cancel}
>
{t(serviceVendor ? 'common.back' : 'settings.models.addKey.cancel')}
</Button>
<Button type="button" variant="brand" className="model-hub-add-key-action"
disabled={isWorking || (phase.kind !== 'save_unconfirmed' && !canSubmit)}
onClick={() => void (phase.kind === 'save_unconfirmed' || phase.kind === 'persist_failure'
? retry() : persist(continuation.begin()))}>
{isWorking ? <LoaderCircle className="size-3 animate-spin" /> : <Save className="size-3" />}
{t(isWorking ? 'settings.models.addKey.saving'
: phase.kind === 'form' ? serviceVendor ? 'common.save' : 'settings.models.addKey.confirm' : 'settings.models.addKey.retry')}
</Button>
</>
)}
</footer>
{replaceMode && (
<GuardDialog
open={guard !== null}
title={t('settings.models.guard.title.replaceKey', { source: props.source.display_name })}
subtitle={t('settings.models.guard.subtitle.replaceKey')}
confirmLabel={t('settings.models.guard.confirm.replaceKey')}
busy={replacePhase.kind === 'submitting'}
onCancel={() => setGuard(null)}
onConfirm={() => { if (guard) void submitReplacement(guard); }}
>
{guard && <GuardImpact hops={guard.hops} gaps={guard.gaps} />}
</GuardDialog>
)}
</DialogPrimitive.Content>
</DialogPrimitive.Portal>
</DialogPrimitive.Root>
);
};