import { useAtomValue } from "@effect/atom-react";
import { AuthSettingsWriteScope, type EnvironmentId, sessionGrantsScope } from "@t3tools/contracts";
import { ChevronDownIcon, PlusIcon, RotateCcwIcon, XIcon } from "lucide-react";
import { AsyncResult, Atom } from "effect/reactivity";
import { useRef, useState } from "react";
import { cn } from "../../lib/utils";
import { environmentPresentations } from "../../state/presentation";
import { serverEnvironment } from "../../state/server";
import { environmentSession, readEnvironmentScope } from "../../state/session";
import { useAtomCommand } from "../../state/use-atom-command";
import type { EnvironmentUsageStatus } from "../../state/usage";
import { Button } from "../ui/button";
import {
Dialog,
DialogDescription,
DialogFooter,
DialogHeader,
DialogPanel,
DialogPopup,
DialogTitle,
} from "../ui/dialog";
import { Input } from "../ui/input";
import { Label } from "../ui/label";
import { Menu, MenuCheckboxItem, MenuPopup, MenuSeparator, MenuTrigger } from "../ui/menu";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "../ui/table";
import { Tooltip, TooltipTrigger, TooltipPopup } from "../ui/tooltip";
import { isUsagePriceEdit, USAGE_PRICE_FIELDS } from "./usagePriceForm";
import {
isEmptyUsagePriceDraft,
usageAliasCell,
usagePriceCell,
usagePriceTableChanges,
usagePriceTableErrors,
type UsagePriceDraft,
type UsagePriceField,
} from "./usagePriceTable";
import {
writeUsagePrices,
type UsagePriceTarget,
type UsagePriceWriteResult,
} from "./usagePriceTargets";
const priceTargetsAtom = Atom.make((get): readonly UsagePriceTarget[] =>
[...get(environmentPresentations.presentationsAtom)].map(([environmentId, environment]) => {
const settings = get(serverEnvironment.settingsValueAtom(environmentId));
const session = get(environmentSession.sessionStateAtom(environmentId));
const sessionData = AsyncResult.getOrElse(session, () => null);
const access =
session._tag === "Failure"
? "denied"
: sessionData === null
? session.waiting
? "pending"
: "denied"
: sessionGrantsScope(sessionData, AuthSettingsWriteScope)
? "granted"
: "denied";
return {
environmentId,
label: environment.entry.target.label,
prices: settings?.usagePriceOverrides ?? null,
aliases:
environment.serverConfig?.environment.capabilities.usageModelAliases === true
? (settings?.usageModelAliases ?? null)
: null,
unavailable:
environment.connection.phase !== "connected"
? "Offline"
: settings === null
? "Prices not loaded"
: access === "pending"
? "Checking permissions…"
: access === "denied"
? "Read-only access"
: null,
};
}),
);
type SaveAttempt = {
readonly drafts: readonly UsagePriceDraft[];
readonly destinations: readonly {
readonly environmentId: EnvironmentId;
readonly label: string;
}[];
readonly results: ReadonlyMap<
EnvironmentId,
UsagePriceWriteResult | { readonly status: "saving" }
>;
};
export function UsagePriceOverrides({
usage,
initialSelectedEnvironmentIds,
initialModel,
onOpenChange,
}: {
readonly usage: readonly EnvironmentUsageStatus[];
readonly initialSelectedEnvironmentIds: ReadonlySet<EnvironmentId> | null;
readonly initialModel?: string | undefined;
readonly onOpenChange: (open: boolean) => void;
}) {
const environments = useAtomValue(priceTargetsAtom);
const [selectedIds, setSelectedIds] = useState(initialSelectedEnvironmentIds);
const selected = environments.filter(
(environment) => selectedIds === null || selectedIds.has(environment.environmentId),
);
const [drafts, setDrafts] = useState<readonly UsagePriceDraft[]>(() =>
initialModel === undefined ||
selected.some(
(environment) =>
Object.hasOwn(environment.prices ?? {}, initialModel) ||
Object.hasOwn(environment.aliases ?? {}, initialModel),
)
? []
: [{ id: "new:initial", model: initialModel, isNew: true, values: {} }],
);
const [pending, setPending] = useState(false);
const [attempt, setAttempt] = useState<SaveAttempt | null>(null);
const focusRowRef = useRef<string | null>(null);
const nextRowId = useRef(0);
const updateSettings = useAtomCommand(serverEnvironment.updateSettings, { reportFailure: false });
const customModels = [
...new Set(
selected.flatMap((environment) => [
...Object.keys(environment.prices ?? {}),
...Object.keys(environment.aliases ?? {}),
]),
),
].sort();
const models = [
...new Set([
...customModels,
...usage
.filter((environment) =>
selected.some((target) => target.environmentId === environment.environmentId),
)
.flatMap((environment) => environment.summary?.buckets.map((bucket) => bucket.model) ?? []),
]),
].sort();
const newModels = new Set(
drafts.filter((draft) => draft.isNew).map((draft) => draft.model.trim()),
);
const rows: readonly UsagePriceDraft[] = [
...customModels
.filter((model) => attempt === null || !newModels.has(model))
.map(
(model) =>
drafts.find((draft) => draft.id === `model:${model}`) ?? {
id: `model:${model}`,
model,
isNew: false,
values: {},
},
),
...drafts.filter((draft) => draft.isNew),
];
const stagedDrafts = drafts.filter((draft) => !isEmptyUsagePriceDraft(draft));
const errors = usagePriceTableErrors(selected, stagedDrafts);
for (const draft of stagedDrafts) {
if (!draft.isNew) continue;
if (draft.model.trim() === "") errors.set(draft.id, "Enter a model ID.");
else if (
attempt === null &&
(customModels.includes(draft.model.trim()) ||
drafts.some((other) => other.id !== draft.id && other.model.trim() === draft.model.trim()))
)
errors.set(draft.id, "This model already has a row. Edit its prices there.");
}
const failedDestinations =
attempt?.destinations.filter(
(destination) => attempt.results.get(destination.environmentId)?.status === "failed",
) ?? [];
const locked = pending || failedDestinations.length > 0;
const hasChanges = stagedDrafts.length > 0;
const destinationLabel =
selected.length === 1 ? selected[0]!.label : `${selected.length} environments`;
const selectionLabel = selectedIds === null ? "All environments" : destinationLabel;
const discard = () => {
setDrafts([]);
setAttempt(null);
};
const selectEnvironments = (ids: ReadonlySet<EnvironmentId> | null) => {
setSelectedIds(ids);
setAttempt(null);
};
const updateDraft = (draft: UsagePriceDraft) => {
setDrafts((previous) =>
previous.some((entry) => entry.id === draft.id)
? previous.map((entry) => (entry.id === draft.id ? draft : entry))
: [...previous, draft],
);
setAttempt(null);
};
const matchesSaved = (
row: UsagePriceDraft,
cell: { value: string; placeholder: string },
value: string,
) =>
!row.isNew &&
cell.placeholder !== "Mixed" &&
cell.placeholder !== "Unavailable" &&
value === cell.value;
const updateOrDropDraft = (draft: UsagePriceDraft) => {
if (!draft.isNew && Object.keys(draft.values).length === 0 && draft.alias === undefined)
setDrafts((previous) => previous.filter((entry) => entry.id !== draft.id));
else updateDraft(draft);
};
const editCell = (row: UsagePriceDraft, field: UsagePriceField, value: string) => {
const values = { ...row.values, [field]: value };
const original = usagePriceCell(selected, row.model, field);
if (matchesSaved(row, original, value)) delete values[field];
updateOrDropDraft({ ...row, values });
};
const editAlias = (row: UsagePriceDraft, value: string) => {
const { alias: _alias, ...rest } = row;
const original = usageAliasCell(selected, row.model);
updateOrDropDraft(matchesSaved(row, original, value) ? rest : { ...rest, alias: value });
};
const save = async (retry = false) => {
if (pending) return;
const destinations = retry ? failedDestinations : selected;
const edits = retry && attempt ? attempt.drafts : stagedDrafts;
if (destinations.length === 0 || edits.length === 0) return;
const targets = destinations.map(
(destination) =>
environments.find(
(environment) => environment.environmentId === destination.environmentId,
) ?? { ...destination, prices: null, aliases: null, unavailable: "Environment removed" },
);
const changes = new Map(
targets.map((target) => [target.environmentId, usagePriceTableChanges(target, edits)]),
);
setPending(true);
setAttempt((previous) => ({
drafts: edits,
destinations: retry && previous ? previous.destinations : targets,
results: new Map([
...(retry && previous ? previous.results : []),
...targets.map((target) => [target.environmentId, { status: "saving" } as const] as const),
]),
}));
let failed = false;
await writeUsagePrices({
targets: targets.map((target) => ({
...target,
unavailable:
target.unavailable ?? [...changes.get(target.environmentId)!.errors.values()][0] ?? null,
})),
changes: new Map([...changes].map(([id, plan]) => [id, plan.changes])),
write: async (input) =>
readEnvironmentScope(input.environmentId, AuthSettingsWriteScope)
? updateSettings(input)
: { _tag: "Failure" },
onResult: (environmentId, result) => {
if (result.status === "failed") failed = true;
setAttempt((previous) =>
previous === null
? null
: { ...previous, results: new Map(previous.results).set(environmentId, result) },
);
},
});
setPending(false);
if (!failed) setDrafts([]);
};
return (
<Dialog
open
onOpenChange={(open) => {
if (!pending) onOpenChange(open);
}}
>
<DialogPopup className="max-w-4xl">
<DialogHeader>
<DialogTitle>Custom model prices</DialogTitle>
<DialogDescription>
Prices and mappings apply to all past and future usage on the environments you select.
</DialogDescription>
</DialogHeader>
<DialogPanel>
<div className="flex flex-wrap items-center justify-between gap-2">
<div className="flex min-w-0 items-center gap-2">
<Label id="usage-prices-apply-label" className="shrink-0">
Apply to
</Label>
<Menu>
<MenuTrigger
render={<Button variant="outline" size="sm" className="min-w-0" />}
aria-labelledby="usage-prices-apply-label usage-prices-selection"
disabled={pending || hasChanges}
>
<span id="usage-prices-selection" className="truncate">
{selectionLabel}
</span>
<ChevronDownIcon className="size-3.5 shrink-0" aria-hidden />
</MenuTrigger>
<MenuPopup align="start">
<MenuCheckboxItem
checked={selectedIds === null}
closeOnClick={false}
onCheckedChange={(checked) => selectEnvironments(checked ? null : new Set())}
>
All environments
</MenuCheckboxItem>
<MenuSeparator />
{environments.map((environment) => (
<MenuCheckboxItem
key={environment.environmentId}
checked={selectedIds === null || selectedIds.has(environment.environmentId)}
closeOnClick={false}
onCheckedChange={(checked) => {
const next = new Set(selected.map((target) => target.environmentId));
if (checked) next.add(environment.environmentId);
else next.delete(environment.environmentId);
selectEnvironments(next.size === environments.length ? null : next);
}}
>
<span className="flex min-w-0 items-center gap-3">
<span className="min-w-0 flex-1 truncate">{environment.label}</span>
{environment.unavailable ? (
<span className="text-xs text-muted-foreground">
{environment.unavailable}
</span>
) : null}
</span>
</MenuCheckboxItem>
))}
</MenuPopup>
</Menu>
</div>
<span className="text-xs text-muted-foreground">USD / million tokens</span>
</div>
{selected.length === 0 ? (
<p className="text-sm text-muted-foreground">
{environments.length === 0
? "Connect an environment to set model prices."
: "Select an environment to see and change its model prices."}
</p>
) : (
<>
<div className="min-w-0 overflow-hidden rounded-lg border border-border">
<Table className="min-w-180 table-fixed" aria-label="Custom model prices">
<colgroup>
<col className="w-[22%]" />
<col className="w-[18%]" />
{USAGE_PRICE_FIELDS.map((field) => (
<col key={field.key} />
))}
<col className="w-10" />
</colgroup>
<TableHeader>
<TableRow>
<TableHead>Model ID</TableHead>
<TableHead>Map to</TableHead>
{USAGE_PRICE_FIELDS.map((field) => (
<TableHead key={field.key}>{field.label}</TableHead>
))}
<TableHead>
<Button
size="icon-xs"
variant="ghost"
aria-label="Add model price"
disabled={locked}
onClick={() => {
const id = `new:${nextRowId.current++}`;
focusRowRef.current = id;
updateDraft({ id, model: "", isNew: true, values: {} });
}}
>
<PlusIcon aria-hidden />
</Button>
</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{rows.length === 0 ? (
<TableRow>
<TableCell colSpan={7} className="text-center whitespace-normal">
<p className="py-6 text-muted-foreground">
{selected.some((environment) => environment.prices === null)
? "Some environment prices are unavailable."
: "No custom prices or mappings. Add a row to set one."}
</p>
</TableCell>
</TableRow>
) : (
rows.map((row) => {
const aliasCell = usageAliasCell(selected, row.model);
const alias = (row.alias ?? aliasCell.value).trim();
return (
<TableRow key={row.id} data-row-id={row.id}>
<TableCell className="whitespace-normal">
{row.isNew ? (
<Input
size="compact"
value={row.model}
ref={(node) => {
if (node && focusRowRef.current === row.id) {
node.focus();
focusRowRef.current = null;
}
}}
aria-label="New model ID"
aria-invalid={
(row.model.trim() !== "" && errors.has(row.id)) || undefined
}
list="usage-price-models"
placeholder="Model ID"
autoComplete="off"
spellCheck={false}
disabled={locked}
onChange={(event) =>
updateDraft({ ...row, model: event.target.value })
}
/>
) : (
<span
className={cn(
"block break-all",
row.removed && "text-muted-foreground line-through",
)}
>
{row.model}
</span>
)}
{errors.has(row.id) &&
(row.model.trim() !== "" ||
Object.values(row.values).some((value) => value !== "")) ? (
<p role="alert" className="mt-1 text-xs text-destructive">
{errors.get(row.id)}
</p>
) : null}
</TableCell>
{row.removed ? (
<TableCell colSpan={5}>
<span className="text-muted-foreground">
Automatic pricing after saving
</span>
</TableCell>
) : (
<TableCell>
<Input
size="compact"
value={row.alias ?? aliasCell.value}
aria-label={`Map ${row.model || "new model"} to model`}
list="usage-alias-models"
placeholder={row.isNew ? "Optional" : aliasCell.placeholder}
autoComplete="off"
spellCheck={false}
disabled={locked}
onChange={(event) => editAlias(row, event.target.value)}
/>
</TableCell>
)}
{row.removed ? null : alias !== "" ? (
<TableCell colSpan={4} className="whitespace-normal">
<span className="break-all text-muted-foreground">
Counted as {alias}
</span>
</TableCell>
) : (
USAGE_PRICE_FIELDS.map((field) => {
const cell = usagePriceCell(selected, row.model, field.key);
const value =
row.values[field.key] ?? (row.isNew ? "" : cell.value);
return (
<TableCell key={field.key}>
<Input
size="compact"
inputMode="decimal"
aria-label={`${field.label} price for ${row.model || "new model"}`}
value={value}
placeholder={
row.isNew
? field.optional
? "Input rate"
: "0.00"
: cell.placeholder
}
autoComplete="off"
disabled={locked}
font="mono"
onChange={(event) => {
if (isUsagePriceEdit(value, event.target.value))
editCell(row, field.key, event.target.value);
}}
/>
</TableCell>
);
})
)}
<TableCell>
<Tooltip>
<TooltipTrigger
render={<Button size="icon-xs" variant="ghost" />}
disabled={locked}
aria-label={
row.removed
? `Undo reset for ${row.model}`
: row.isNew
? "Remove new model"
: `Reset price for ${row.model} to automatic`
}
onClick={() => {
if (row.isNew)
setDrafts((previous) =>
previous.filter((entry) => entry.id !== row.id),
);
else if (row.removed)
updateOrDropDraft({ ...row, removed: false });
else updateDraft({ ...row, removed: true });
}}
>
{row.isNew ? (
<XIcon aria-hidden />
) : (
<RotateCcwIcon aria-hidden />
)}
</TooltipTrigger>
<TooltipPopup>
{row.removed
? "Undo reset"
: row.isNew
? "Remove row"
: "Reset to automatic"}
</TooltipPopup>
</Tooltip>
</TableCell>
</TableRow>
);
})
)}
</TableBody>
</Table>
</div>
<datalist id="usage-price-models">
{models
.filter((model) => !customModels.includes(model))
.map((model) => (
<option key={model} value={model} />
))}
</datalist>
<datalist id="usage-alias-models">
{models
.filter((model) =>
selected.every(
(environment) => !Object.hasOwn(environment.aliases ?? {}, model),
),
)
.map((model) => (
<option key={model} value={model} />
))}
</datalist>
<p className="text-xs text-muted-foreground">
Blank cache rates use the input price. Enter 0 for free tokens. A mapped model’s
usage counts as the model it maps to.
{selected.length > 1
? " Mixed cells keep each environment’s rate until you edit them."
: ""}
</p>
</>
)}
{attempt ? (
<div role="status" className="grid gap-1 text-xs">
{attempt.destinations.map((destination) => {
const result = attempt.results.get(destination.environmentId);
return (
<div key={destination.environmentId} className="flex justify-between gap-3">
<span className="truncate text-muted-foreground">{destination.label}</span>
<span
className={
result?.status === "failed"
? "text-right text-destructive"
: "text-muted-foreground"
}
>
{result?.status === "failed"
? `Not saved · ${result.error}`
: result?.status === "saved"
? "Saved"
: "Saving…"}
</span>
</div>
);
})}
</div>
) : null}
</DialogPanel>
<DialogFooter variant="bare" className="items-center sm:justify-between">
<span className="text-xs text-muted-foreground">
{hasChanges ? `Changes apply to ${destinationLabel}` : ""}
</span>
<div className="flex w-full flex-wrap justify-end gap-2 sm:w-auto">
{hasChanges ? (
<Button variant="ghost" disabled={pending} onClick={discard}>
{failedDestinations.length > 0 ? "Discard pending changes" : "Discard changes"}
</Button>
) : null}
<Button
disabled={
pending ||
(!hasChanges && failedDestinations.length === 0) ||
(failedDestinations.length === 0 && (errors.size > 0 || selected.length === 0))
}
onClick={() => void save(failedDestinations.length > 0)}
>
{pending
? "Saving…"
: failedDestinations.length > 0
? "Retry failed saves"
: "Save changes"}
</Button>
</div>
</DialogFooter>
</DialogPopup>
</Dialog>
);
}