}
+ actions={readOnly ? undefined : runActions}
+ queue={queue}
+ />
{live && (
@@ -89,7 +100,6 @@ export function InvestigationDetail({
{sourceLabels[batchSettings?.source ?? "traces"]}
History
- {section !== "activity" && }
{snapshot.error && (
diff --git a/ui/litellm-dashboard/src/components/lens/investigations/detail/InvestigationFailure.tsx b/ui/litellm-dashboard/src/components/lens/investigations/detail/InvestigationFailure.tsx
deleted file mode 100644
index 54943455860..00000000000
--- a/ui/litellm-dashboard/src/components/lens/investigations/detail/InvestigationFailure.tsx
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { ComponentProps } from "react";
-import { runTime } from "../../model/format";
-import { type Job } from "../../model/types";
-import { failedTaskSummary, isPartial } from "../../model/status";
-import { cn } from "@/lib/cva.config";
-
-export type InvestigationFailureProps = ComponentProps<"div"> & {
- job: Job;
- connected: boolean;
-};
-
-export function InvestigationFailure({ job, connected, className, ...props }: InvestigationFailureProps) {
- const partial = isPartial(job);
- return (
-
-
- {partial ? "Partial results" : "This investigation did not finish"}
-
- {partial &&
{failedTaskSummary(job)}. Valid results are preserved.
}
-
- Run details
-
- {job.error}
-
-
-
-
- Run:
- - {job.id}
-
-
-
- Model:
- - {job.settings.model}
-
-
-
- Worker:
- - {connected ? "Connected now" : "Not connected"}
-
-
-
- Started:
- - {runTime(job.created_at)}
-
-
-
-
-
- Latest run:{" "}
-
- {lensStatus(lens, connected)}
-
-
-
- Last full completion: {lastSuccess ? runTime(lastSuccess) : "Not yet"}
-
-
- This month:{" "}
-
- ${spent.toFixed(3)} / ${lens.settings.monthly_budget ?? 100}
-
-
- {lens.settings.enabled && (
-
- Monitoring every {lens.settings.interval_minutes} minutes
-
-
- )}
-
+
+ {sourceLabels[settings.source ?? "traces"]}
+ {parts.map((part) => ` · ${part}`)}
+
);
}
diff --git a/ui/litellm-dashboard/src/components/lens/investigations/detail/JobMeta.tsx b/ui/litellm-dashboard/src/components/lens/investigations/detail/JobMeta.tsx
index a846b68df3d..4ee14eb43aa 100644
--- a/ui/litellm-dashboard/src/components/lens/investigations/detail/JobMeta.tsx
+++ b/ui/litellm-dashboard/src/components/lens/investigations/detail/JobMeta.tsx
@@ -1,16 +1,7 @@
"use client";
-import { useNow } from "@/hooks/useNow";
import { analysisElapsed } from "../../model/progress";
-import { nextCheckStatus } from "../../model/status";
-import type { Job, Lens } from "../../model/types";
-
-export function NextCheck({ lens }: { lens: Lens }) {
- const now = useNow(15000);
- const label = nextCheckStatus(lens, now);
- if (!label) return null;
- return {label}
;
-}
+import type { Job } from "../../model/types";
export function ScanDuration({ job }: { job: Job }) {
if (!job.finished_at) return null;
diff --git a/ui/litellm-dashboard/src/components/lens/investigations/detail/RunReport.tsx b/ui/litellm-dashboard/src/components/lens/investigations/detail/RunReport.tsx
new file mode 100644
index 00000000000..6ac47c8e846
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/lens/investigations/detail/RunReport.tsx
@@ -0,0 +1,321 @@
+"use client";
+
+import {
+ ChevronRight,
+ CircleStop,
+ ListChecks,
+ Play,
+ Plug,
+ RefreshCw,
+ Repeat,
+ Wallet,
+ type LucideIcon,
+} from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/cva.config";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible";
+import { useNow } from "@/hooks/useNow";
+
+import { analysisElapsed } from "../../model/progress";
+import { money } from "../../model/format";
+import { modelsUsed, shortTime, windowLabel } from "../../model/inbox";
+import {
+ NEXT_ACTION,
+ openIssues,
+ runSituation,
+ type RunAction,
+ type RunSituation,
+ type SituationInput,
+} from "../../model/runSituation";
+import type { Finding, Job, Lens } from "../../model/types";
+import { activeJob, failedTaskSummary } from "../../model/status";
+import { InvestigationProgress } from "../InvestigationProgress";
+import type { QueueContext } from "../useQueueReason";
+import { StepFeed } from "../StepFeed";
+
+export type RunActionHandlers = Record void>;
+
+export interface RunReportProps {
+ readonly lens: Lens;
+ readonly job: Job | undefined;
+ readonly findings: readonly Finding[] | null | undefined;
+ readonly connected: boolean;
+ readonly ready: boolean;
+ readonly busy: boolean;
+ readonly picker: ReactNode;
+ readonly actions?: RunActionHandlers;
+ readonly queue?: QueueContext;
+}
+
+interface Facts {
+ readonly runs: string;
+ readonly found: string;
+ readonly openIssues: number;
+}
+
+type Tone = "info" | "success" | "warning" | "destructive" | "muted";
+
+interface SituationView {
+ readonly status: string;
+ readonly tone: Tone;
+ readonly headline: (facts: Facts) => string;
+ readonly body: "progress" | "error" | "partial" | null;
+}
+
+const completed = ({ found, runs }: Facts) =>
+ found ? `Found ${found} across ${runs}` : `Nothing found across ${runs}`;
+
+const SITUATIONS: Record = {
+ never: { status: "Not run yet", tone: "muted", headline: () => "Run it to get the first report", body: null },
+ queued: {
+ status: "Queued",
+ tone: "info",
+ headline: () => "Waiting for an analyzer to pick this up",
+ body: "progress",
+ },
+ running: { status: "Running", tone: "info", headline: () => "Investigating now", body: "progress" },
+ budget: {
+ status: "Failed",
+ tone: "destructive",
+ headline: () => "Stopped: the monthly budget is used up",
+ body: "error",
+ },
+ offline: {
+ status: "Failed",
+ tone: "destructive",
+ headline: () => "Stopped: no analyzer is connected",
+ body: "error",
+ },
+ failed: { status: "Failed", tone: "destructive", headline: () => "Stopped before it finished", body: "error" },
+ cancelled: {
+ status: "Cancelled",
+ tone: "muted",
+ headline: ({ runs }) => `Cancelled after reviewing ${runs}`,
+ body: "error",
+ },
+ partial: { status: "Partial results", tone: "warning", headline: completed, body: "partial" },
+ unknown: { status: "Completed", tone: "success", headline: ({ runs }) => `Reviewed ${runs}`, body: null },
+ issues: { status: "Completed", tone: "success", headline: completed, body: null },
+ watching: { status: "Completed", tone: "success", headline: completed, body: null },
+ clean: { status: "Completed", tone: "success", headline: completed, body: null },
+};
+
+interface ActionView {
+ readonly label: (facts: Facts) => string;
+ readonly icon: LucideIcon;
+ readonly variant: ComponentProps["variant"];
+ readonly needsReady: boolean;
+}
+
+const ACTIONS: Record = {
+ run: { label: () => "Run now", icon: Play, variant: "default", needsReady: true },
+ stop: { label: () => "Stop run", icon: CircleStop, variant: "outline", needsReady: false },
+ retry: { label: () => "Retry", icon: RefreshCw, variant: "default", needsReady: true },
+ raiseBudget: { label: () => "Raise budget", icon: Wallet, variant: "default", needsReady: false },
+ connectWorker: { label: () => "Connect worker", icon: Plug, variant: "default", needsReady: false },
+ reviewIssues: {
+ label: ({ openIssues: count }) => `Review ${plural(count, "issue")}`,
+ icon: ListChecks,
+ variant: "default",
+ needsReady: false,
+ },
+ monitor: { label: () => "Monitor this", icon: Repeat, variant: "default", needsReady: true },
+};
+
+const TONE_CLASS: Record = {
+ info: "text-info",
+ success: "text-success",
+ warning: "text-warning",
+ destructive: "text-destructive",
+ muted: "text-muted-foreground",
+};
+
+const plural = (count: number, noun: string) => `${count.toLocaleString()} ${noun}${count === 1 ? "" : "s"}`;
+
+function facts(job: Job | undefined, findings: readonly Finding[] | null | undefined): Facts {
+ const count = (kind: Finding["kind"], noun: string) => {
+ const total = findings?.filter((f) => f.kind === kind).length ?? 0;
+ return total ? plural(total, noun) : "";
+ };
+ return {
+ runs: plural(job?.coverage?.screened ?? 0, "run"),
+ found: [count("issue", "issue"), count("pattern", "pattern")].filter(Boolean).join(" and "),
+ openIssues: openIssues(findings),
+ };
+}
+
+function Stat({ label, value, note }: { label: string; value: string; note?: string }) {
+ return (
+
+
{label}
+ {value}
+ {note && {note}}
+
+ );
+}
+
+function coverageNote(job: Job): string | undefined {
+ const { partial = 0, unassessable = 0, inconclusive = 0 } = job.coverage ?? {};
+ const notes = [
+ partial && `${partial} partial`,
+ unassessable && `${unassessable} unreadable`,
+ inconclusive && `${inconclusive} inconclusive`,
+ ].filter(Boolean);
+ return notes.length ? notes.join(" · ") : undefined;
+}
+
+const isActive = (job: Job) => job.status === "queued" || job.status === "running";
+
+function issueStat(job: Job, findings: readonly Finding[] | null | undefined) {
+ if (isActive(job)) return { value: "–", note: "When the run finishes" };
+ if (job.status !== "completed" || findings == null) return { value: "–" };
+ const issues = findings.filter((f) => f.kind === "issue");
+ const high = issues.filter((f) => f.priority === "high").length;
+ return { value: issues.length.toLocaleString(), note: high ? `${high} high priority` : undefined };
+}
+
+function RunStats({ job, findings, now }: { job: Job; findings: readonly Finding[] | null | undefined; now: number }) {
+ const calls = (job.steps ?? []).filter((step) => step.kind === "model").length;
+ const { screened = 0, selected = 0 } = job.coverage ?? {};
+ const end = job.finished_at ? Date.parse(job.finished_at) : now;
+ return (
+
+
+
+
+
+
+ );
+}
+
+function RunFailure({ job, connected }: { job: Job; connected: boolean }) {
+ return (
+
+
+
+ );
+}
+
+function RunError({ job, connected }: { job: Job; connected: boolean }) {
+ return (
+ <>
+
+ {job.error}
+
+
+
+ Run {job.id}
+
+
+ Model {job.settings.model}
+
+ Worker {connected ? "connected now" : "not connected"}
+
+
+ );
+}
+
+function RunPartial({ job, connected }: { job: Job; connected: boolean }) {
+ return (
+
+
{failedTaskSummary(job)}. Valid results are preserved.
+
+ Run details
+
+
+
+
+
+
+
+ Activity log
+
+
+ {job.trigger === "manual" ? "Manual" : "Scheduled"} · {windowLabel(job)}
+ {models.length > 0 && ` · ${models.join(", ")}`}
+
+
+
+
+
+
+ );
+}
+
+function NextAction({
+ action,
+ facts: known,
+ ready,
+ busy,
+ onClick,
+}: {
+ action: RunAction;
+ facts: Facts;
+ ready: boolean;
+ busy: boolean;
+ onClick: () => void;
+}) {
+ const { label, icon: Icon, variant, needsReady } = ACTIONS[action];
+ return (
+
+ );
+}
+
+function nextAction(lens: Lens, job: Job | undefined, situation: RunSituation): RunAction | null {
+ if (job === undefined || job.id === lens.jobs[0]?.id) return NEXT_ACTION[situation];
+ return activeJob(lens.jobs) ? "stop" : null;
+}
+
+export function RunReport({ lens, job, findings, connected, ready, busy, picker, actions, queue }: RunReportProps) {
+ const now = useNow(job && isActive(job) ? 1000 : 60000);
+ const input: SituationInput = { lens, job, findings, connected };
+ const situation = runSituation(input);
+ const view = SITUATIONS[situation];
+ const known = facts(job, findings);
+ const action = nextAction(lens, job, situation);
+ return (
+
+
+ {job && view.body === "progress" && }
+ {job?.error && view.body === "partial" && }
+ {job?.error && view.body === "error" && }
+ {job && }
+ {job && }
+
+ );
+}
diff --git a/ui/litellm-dashboard/src/components/lens/model/inbox.ts b/ui/litellm-dashboard/src/components/lens/model/inbox.ts
index b1ab117d0b8..ff01a0ad2b6 100644
--- a/ui/litellm-dashboard/src/components/lens/model/inbox.ts
+++ b/ui/litellm-dashboard/src/components/lens/model/inbox.ts
@@ -155,9 +155,10 @@ const WINDOW_FORMAT: Intl.DateTimeFormatOptions = {
minute: "2-digit",
};
+export const shortTime = (iso: string) => new Date(iso).toLocaleString(undefined, WINDOW_FORMAT);
+
export function windowLabel(job: Job): string {
- const fmt = (iso: string) => new Date(iso).toLocaleString(undefined, WINDOW_FORMAT);
- return `${fmt(job.start)} → ${fmt(job.end)}`;
+ return `${shortTime(job.start)} → ${shortTime(job.end)}`;
}
export function inboxFinding(row: InboxRow): Finding {
diff --git a/ui/litellm-dashboard/src/components/lens/model/progress.test.ts b/ui/litellm-dashboard/src/components/lens/model/progress.test.ts
index 934e85111d8..ab04cff498c 100644
--- a/ui/litellm-dashboard/src/components/lens/model/progress.test.ts
+++ b/ui/litellm-dashboard/src/components/lens/model/progress.test.ts
@@ -3,9 +3,9 @@ import {
analysisElapsed,
analysisProgress,
analysisFraction,
+ analysisStages,
analysisPace,
remainingLabel,
- stageDurations,
} from "./progress";
import { type Job } from "./types";
@@ -216,20 +216,27 @@ describe("Analysis pace", () => {
});
});
-describe("Stage durations", () => {
- const start = Date.parse("2026-09-30T12:00:00Z");
- const createdAt = "2026-09-30T12:00:00Z";
-
- it("times finished stages from the transitions it saw and the active stage up to now", () => {
- const samples = [
- { at: start + 5000, step: 0, done: 10, fraction: 0.1 },
- { at: start + 124000, step: 1, done: 0, fraction: 0.6 },
- ];
- expect(stageDurations(samples, createdAt, start + 145000)).toEqual([124, 21, null]);
+describe("Analysis stages", () => {
+ it("fills finished stages, fills the active one by its own count, and leaves later ones empty", () => {
+ const grouping = {
+ ...job,
+ stage: "Grouping observations",
+ coverage: { ...coverage, selected: 40, screened: 40, grouping_batches: 4, grouped_batches: 1 },
+ };
+ expect(analysisStages(grouping).map(({ state, fill, done, total }) => ({ state, fill, done, total }))).toEqual([
+ { state: "done", fill: 1, done: 40, total: 40 },
+ { state: "active", fill: 0.25, done: 1, total: 4 },
+ { state: "todo", fill: 0, done: 0, total: 0 },
+ ]);
});
- it("does not guess when a stage started before the page was opened", () => {
- const samples = [{ at: start + 90000, step: 1, done: 2, fraction: 0.7 }];
- expect(stageDurations(samples, createdAt, start + 100000)).toEqual([null, null, null]);
+ it("weights the stages so the bar agrees with the overall percentage", () => {
+ const grouping = {
+ ...job,
+ stage: "Grouping observations",
+ coverage: { ...coverage, selected: 40, screened: 40, grouping_batches: 4, grouped_batches: 1 },
+ };
+ const covered = analysisStages(grouping).reduce((sum, stage) => sum + stage.weight * stage.fill, 0);
+ expect(covered).toBeCloseTo(analysisFraction(analysisProgress(grouping)));
});
});
diff --git a/ui/litellm-dashboard/src/components/lens/model/progress.ts b/ui/litellm-dashboard/src/components/lens/model/progress.ts
index d1a22431701..880e91f780d 100644
--- a/ui/litellm-dashboard/src/components/lens/model/progress.ts
+++ b/ui/litellm-dashboard/src/components/lens/model/progress.ts
@@ -59,20 +59,47 @@ export function analysisProgress(job: Job) {
};
}
-export function analysisStages(job: Job): { done: number; total: number }[] {
- const {
- screened = 0,
- selected = 0,
- grouped_batches = 0,
- grouping_batches = 0,
- investigated = 0,
- candidates = 0,
- } = job.coverage ?? {};
- return [
- { done: screened, total: selected },
- { done: grouped_batches, total: grouping_batches },
- { done: investigated, total: candidates },
- ];
+type Coverage = Job["coverage"];
+
+export const ANALYSIS_STAGES = [
+ { label: "Review runs", weight: 0.6, done: (c: Coverage) => c.screened, total: (c: Coverage) => c.selected },
+ {
+ label: "Find patterns",
+ weight: 0.2,
+ done: (c: Coverage) => c.grouped_batches,
+ total: (c: Coverage) => c.grouping_batches,
+ },
+ { label: "Check evidence", weight: 0.2, done: (c: Coverage) => c.investigated, total: (c: Coverage) => c.candidates },
+] as const;
+
+export interface StageProgress {
+ readonly label: string;
+ readonly weight: number;
+ readonly state: "done" | "active" | "todo";
+ readonly done: number;
+ readonly total: number;
+ readonly fill: number;
+}
+
+function stageState(index: number, current: number): StageProgress["state"] {
+ if (index < current) return "done";
+ return index === current ? "active" : "todo";
+}
+
+function stageFill(state: StageProgress["state"], done: number, total: number): number {
+ if (state === "done") return 1;
+ if (state === "todo" || !total) return 0;
+ return Math.min(1, done / total);
+}
+
+export function analysisStages(job: Job): readonly StageProgress[] {
+ const step = analysisProgress(job).step;
+ return ANALYSIS_STAGES.map((stage, index) => {
+ const state = stageState(index, step);
+ const done = job.coverage ? stage.done(job.coverage) : 0;
+ const total = job.coverage ? stage.total(job.coverage) : 0;
+ return { label: stage.label, weight: stage.weight, state, done, total, fill: stageFill(state, done, total) };
+ });
}
export interface ProgressSample {
@@ -82,16 +109,14 @@ export interface ProgressSample {
fraction: number;
}
-const stageWeights = [0.6, 0.2, 0.2];
-
export function analysisFraction({
step,
done,
total,
}: Pick, "step" | "done" | "total">): number {
if (step < 0) return 0;
- const before = stageWeights.slice(0, step).reduce((sum, weight) => sum + weight, 0);
- return before + stageWeights[step] * (total ? Math.min(1, done / total) : 0);
+ const before = ANALYSIS_STAGES.slice(0, step).reduce((sum, stage) => sum + stage.weight, 0);
+ return before + ANALYSIS_STAGES[step].weight * (total ? Math.min(1, done / total) : 0);
}
function windowStart(samples: readonly ProgressSample[], now: number): ProgressSample | undefined {
@@ -115,22 +140,6 @@ export function analysisPace(samples: readonly ProgressSample[], now: number) {
return { perMinute, secondsLeft };
}
-export function stageDurations(samples: readonly ProgressSample[], createdAt: string, now: number): (number | null)[] {
- const current = samples.at(-1)?.step ?? -1;
- const starts = [0, 1, 2].map((stage) => {
- if (stage === 0) return Date.parse(createdAt);
- const entered = samples.findIndex(
- (sample, index) => index > 0 && sample.step >= stage && samples[index - 1].step < stage,
- );
- return entered < 0 ? null : samples[entered].at;
- });
- return starts.map((start, stage) => {
- if (start === null || stage > current) return null;
- const end = stage === current ? now : starts[stage + 1];
- return end === null ? null : Math.max(0, Math.floor((end - start) / 1000));
- });
-}
-
export function remainingLabel(seconds: number | null): string {
if (seconds === null) return "estimating";
if (seconds < 60) return "<1m";
diff --git a/ui/litellm-dashboard/src/components/lens/model/runSituation.test.ts b/ui/litellm-dashboard/src/components/lens/model/runSituation.test.ts
new file mode 100644
index 00000000000..5e3a38d1c89
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/lens/model/runSituation.test.ts
@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import { NEXT_ACTION, runSituation, type SituationInput } from "./runSituation";
+import type { Finding, Job, Lens } from "./types";
+
+const settings: Lens["settings"] = {
+ context: "",
+ source: "traces",
+ lookback_hours: 24,
+ service: "",
+ agent_name: "",
+ filters: [],
+ interval_minutes: 60,
+ sample_size: 100,
+ sample_percent: 100,
+ concurrency: 8,
+ team_id: "",
+ execution_ids: [],
+ monthly_budget: 20,
+ name: "Release reviews",
+ model: "analysis",
+ enabled: false,
+ checks: [],
+};
+const month = new Date().toISOString().slice(0, 7);
+const lens: Lens = {
+ version: 0,
+ spent: 1,
+ id: "lens",
+ scope: { all_teams: true, api_key_hash: "", team_id: "" },
+ settings,
+ revision: 1,
+ created_at: "2026-09-30T10:00:00Z",
+ next_run_at: "2026-09-30T10:00:00Z",
+ budget_month: month,
+ findings: [],
+ jobs: [],
+};
+const job: Job = {
+ id: "run",
+ assessments: [],
+ steps: [],
+ reviews: [],
+ reviewed: 0,
+ reading: [],
+ activities: [],
+ trigger: "manual",
+ attempts: 1,
+ error: "",
+ cost: 0,
+ coverage: {
+ eligible: 10,
+ selected: 10,
+ screened: 10,
+ investigated: 0,
+ inconclusive: 0,
+ grouping_batches: 0,
+ grouped_batches: 0,
+ candidates: 0,
+ partial: 0,
+ unassessable: 0,
+ failed_tasks: 0,
+ },
+ status: "completed",
+ stage: "Complete",
+ created_at: "2026-09-30T10:00:00Z",
+ start: "2026-09-29T10:00:00Z",
+ end: "2026-09-30T10:00:00Z",
+ settings,
+ revision: 1,
+};
+const finding = (kind: Finding["kind"], status: Finding["status"]): Finding => ({
+ id: `${kind}-${status}`,
+ check_id: "check",
+ title: "",
+ description: "",
+ reason: "",
+ suggestion: "",
+ limitation: "",
+ kind,
+ priority: "high",
+ status,
+ revision: 1,
+ first_seen: job.created_at,
+ last_seen: job.created_at,
+ occurrences: [],
+ evidence: [],
+});
+
+const input = (overrides: Partial & { jobPatch?: Partial }): SituationInput => {
+ const { jobPatch, ...rest } = overrides;
+ return { lens, job: { ...job, ...jobPatch }, findings: [], connected: true, ...rest };
+};
+const failed = { status: "failed", error: "Model request failed" } as const;
+const watching = { ...lens, settings: { ...settings, enabled: true } };
+
+describe("runSituation", () => {
+ it.each([
+ ["never", input({ job: undefined }), "run"],
+ ["queued", input({ jobPatch: { status: "queued" } }), "stop"],
+ ["running", input({ jobPatch: { status: "running" } }), "stop"],
+ ["budget", input({ jobPatch: failed, lens: { ...lens, spent: 20 } }), "raiseBudget"],
+ ["budget", input({ jobPatch: { ...failed, error: "Monthly lens budget reached" } }), "raiseBudget"],
+ ["offline", input({ jobPatch: failed, connected: false }), "connectWorker"],
+ ["failed", input({ jobPatch: failed }), "retry"],
+ ["failed", input({ jobPatch: { ...failed, error: "Could not reserve analysis budget" } }), "retry"],
+ ["cancelled", input({ jobPatch: { status: "cancelled" } }), "retry"],
+ ["partial", input({ jobPatch: { error: "Result validation failed after 3 retries" } }), "retry"],
+ ["unknown", input({ findings: null }), null],
+ ["issues", input({ lens: watching, findings: [finding("issue", "open")] }), "reviewIssues"],
+ ["watching", input({ lens: watching, findings: [finding("issue", "resolved")] }), null],
+ ["clean", input({ findings: [finding("pattern", "open")] }), "monitor"],
+ ] as const)("reads %s and offers %s", (expected, situationInput, action) => {
+ const situation = runSituation(situationInput);
+ expect(situation).toBe(expected);
+ expect(NEXT_ACTION[situation]).toBe(action);
+ });
+
+ it("puts a running job ahead of a spent budget, so Stop stays reachable", () => {
+ expect(runSituation(input({ jobPatch: { status: "running" }, lens: { ...lens, spent: 99 } }))).toBe("running");
+ });
+
+ it("ignores spend from an earlier month", () => {
+ expect(runSituation(input({ jobPatch: failed, lens: { ...lens, spent: 99, budget_month: "1999-01" } }))).toBe(
+ "failed",
+ );
+ });
+});
diff --git a/ui/litellm-dashboard/src/components/lens/model/runSituation.ts b/ui/litellm-dashboard/src/components/lens/model/runSituation.ts
new file mode 100644
index 00000000000..f595a92e8cf
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/lens/model/runSituation.ts
@@ -0,0 +1,65 @@
+import { budgetReached, isPartial } from "./status";
+import type { Finding, Job, Lens } from "./types";
+
+export interface SituationInput {
+ readonly lens: Lens;
+ readonly job: Job | undefined;
+ readonly findings: readonly Finding[] | null | undefined;
+ readonly connected: boolean;
+}
+
+export type RunSituation =
+ | "never"
+ | "queued"
+ | "running"
+ | "budget"
+ | "offline"
+ | "failed"
+ | "cancelled"
+ | "partial"
+ | "unknown"
+ | "issues"
+ | "watching"
+ | "clean";
+
+export type RunAction = "run" | "stop" | "retry" | "raiseBudget" | "connectWorker" | "reviewIssues" | "monitor";
+
+const failed = (job: Job | undefined) => job?.status === "failed";
+
+export const openIssues = (findings: readonly Finding[] | null | undefined) =>
+ findings?.filter((finding) => finding.kind === "issue" && finding.status === "open").length ?? 0;
+
+// First match wins, so the order is the precedence between overlapping situations
+const RULES: readonly (readonly [RunSituation, (input: SituationInput) => boolean])[] = [
+ ["never", ({ job }) => !job],
+ ["queued", ({ job }) => job?.status === "queued"],
+ ["running", ({ job }) => job?.status === "running"],
+ ["budget", ({ job, lens }) => failed(job) && (budgetReached(lens) || /budget reached/i.test(job?.error ?? ""))],
+ ["offline", ({ job, connected }) => failed(job) && !connected],
+ ["failed", ({ job }) => failed(job)],
+ ["cancelled", ({ job }) => job?.status === "cancelled"],
+ ["partial", ({ job }) => job !== undefined && isPartial(job)],
+ ["unknown", ({ findings }) => findings == null],
+ ["issues", ({ findings }) => openIssues(findings) > 0],
+ ["watching", ({ lens }) => lens.settings.enabled],
+ ["clean", () => true],
+];
+
+export function runSituation(input: SituationInput): RunSituation {
+ return RULES.find(([, matches]) => matches(input))?.[0] ?? "clean";
+}
+
+export const NEXT_ACTION: Record = {
+ never: "run",
+ queued: "stop",
+ running: "stop",
+ budget: "raiseBudget",
+ offline: "connectWorker",
+ failed: "retry",
+ cancelled: "retry",
+ partial: "retry",
+ unknown: null,
+ issues: "reviewIssues",
+ watching: null,
+ clean: "monitor",
+};
diff --git a/ui/litellm-dashboard/src/components/lens/model/status.ts b/ui/litellm-dashboard/src/components/lens/model/status.ts
index 82541954558..741dedfb6b0 100644
--- a/ui/litellm-dashboard/src/components/lens/model/status.ts
+++ b/ui/litellm-dashboard/src/components/lens/model/status.ts
@@ -120,11 +120,15 @@ export function listPollInterval(list: LensList | undefined, settingsOpen: boole
return running || (settingsOpen && !connected) ? 2000 : 10000;
}
+export function budgetReached(lens: Lens, now = new Date()): boolean {
+ const spent = lens.budget_month === now.toISOString().slice(0, 7) ? lens.spent ?? 0 : 0;
+ return spent >= (lens.settings.monthly_budget ?? 100);
+}
+
export function lensStatus(lens: Lens, connected: boolean): string {
const active = lens.jobs?.find((job) => ["queued", "running"].includes(job.status ?? ""));
if (active) return connected ? active.stage ?? "Queued" : "Waiting for analyzer";
- const spent = lens.budget_month === new Date().toISOString().slice(0, 7) ? lens.spent ?? 0 : 0;
- if (spent >= (lens.settings.monthly_budget ?? 100)) return "Budget reached";
+ if (budgetReached(lens)) return "Budget reached";
const latest = lens.jobs?.[0];
return latest ? runStatus(latest) : "Ready";
}