import { describe, expect, test } from "vitest";

import {

asDateTimestampMs,

asFiniteNumber,

asFiniteNumberInRange,

asSafeIntegerInRange,

});

test("timestamp ISO helper rejects Date-invalid timestamps", () => {

expect(asDateTimestampMs(0)).toBe(0);

expect(asDateTimestampMs(8_640_000_000_000_000)).toBe(8_640_000_000_000_000);

expect(asDateTimestampMs(8_640_000_000_000_001)).toBeUndefined();

expect(asDateTimestampMs(Number.POSITIVE_INFINITY)).toBeUndefined();

expect(asDateTimestampMs("0")).toBeUndefined();

expect(timestampMsToIsoString(0)).toBe("1970-01-01T00:00:00.000Z");

expect(timestampMsToIsoString(8_640_000_000_000_000)).toBe("+275760-09-13T00:00:00.000Z");

expect(timestampMsToIsoString(8_640_000_000_000_001)).toBeUndefined();

export const MAX_TIMER_TIMEOUT_SECONDS = Math.floor(MAX_TIMER_TIMEOUT_MS / 1000);

export const MAX_DATE_TIMESTAMP_MS = 8_640_000_000_000_000;

export function timestampMsToIsoString(value: unknown): string | undefined {

const timestampMs = asFiniteNumberInRange(value, {

export function asDateTimestampMs(value: unknown): number | undefined {

return asFiniteNumberInRange(value, {

min: -MAX_DATE_TIMESTAMP_MS,

max: MAX_DATE_TIMESTAMP_MS,

});

}

export function timestampMsToIsoString(value: unknown): string | undefined {

const timestampMs = asDateTimestampMs(value);

return timestampMs === undefined ? undefined : new Date(timestampMs).toISOString();

}

import { describe, expect, it } from "vitest";

import {

formatMs,

formatRelativeTimestamp,

formatUnknownText,

parseSessionKeyParts,

});

});

describe("formatMs", () => {

it("formats epoch timestamps", () => {

expect(formatMs(0)).not.toBe("n/a");

});

it("returns n/a for Date-invalid timestamps", () => {

expect(formatMs(8_640_000_000_000_001)).toBe("n/a");

expect(formatMs(Number.POSITIVE_INFINITY)).toBe("n/a");

});

});

describe("stripThinkingTags", () => {

it("strips <think>…</think> segments", () => {

const input = ["<think>", "secret", "</think>", "", "Hello"].join("\n");

import { formatDurationHuman } from "../../../src/infra/format-time/format-duration.ts";

import { formatRelativeTimestamp } from "../../../src/infra/format-time/format-relative.ts";

import { asDateTimestampMs } from "../../../src/shared/number-coercion.js";

import { t } from "../i18n/index.ts";

export { formatRelativeTimestamp, formatDurationHuman };

}

export function formatMs(ms?: number | null): string {

if (!ms && ms !== 0) {

const timestampMs = asDateTimestampMs(ms);

if (timestampMs === undefined) {

return t("common.na");

}

return new Date(ms).toLocaleString();

return new Date(timestampMs).toLocaleString();

}

export function formatList(values?: Array<string | null | undefined>): string {

import { afterEach, describe, expect, it, vi } from "vitest";

import { formatQuotaReset } from "./provider-quota-summary.ts";

describe("formatQuotaReset", () => {

afterEach(() => {

vi.restoreAllMocks();

});

it("returns compact relative reset windows", () => {

vi.spyOn(Date, "now").mockReturnValue(Date.parse("2026-05-30T12:00:00.000Z"));

expect(formatQuotaReset(Date.now() + 30 * 60_000)).toBe("30m");

expect(formatQuotaReset(Date.now() + 2 * 60 * 60_000 + 15 * 60_000)).toBe("2h 15m");

});

it("ignores Date-invalid reset timestamps", () => {

expect(formatQuotaReset(8_640_000_000_000_001)).toBeNull();

expect(formatQuotaReset(Number.POSITIVE_INFINITY)).toBeNull();

});

});

import { asDateTimestampMs } from "../../../src/shared/number-coercion.js";

import type { ModelAuthStatusProvider, ModelAuthStatusResult } from "./types.ts";

export type QuotaWindowSummary = {

};

export function formatQuotaReset(resetAt?: number): string | null {

if (!resetAt || !Number.isFinite(resetAt)) {

const timestampMs = asDateTimestampMs(resetAt);

if (timestampMs === undefined) {

return null;

}

const diffMs = resetAt - Date.now();

const diffMs = timestampMs - Date.now();

if (diffMs <= 0) {

return "now";

}

const remainingHours = hours % 24;

return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;

}

return new Date(resetAt).toLocaleDateString(undefined, { month: "short", day: "numeric" });

return new Date(timestampMs).toLocaleDateString(undefined, { month: "short", day: "numeric" });

}

export function collectQuotaWindows(

import { html, nothing, type TemplateResult } from "lit";

import { unsafeHTML } from "lit/directives/unsafe-html.js";

import { asDateTimestampMs } from "../../../../src/shared/number-coercion.js";

import { t } from "../../i18n/index.ts";

import { resolveCronJobLastRunStatus } from "../cron-status.ts";

import { formatCost, formatTokens, formatRelativeTimestamp } from "../format.ts";

// Hidden for windows with plenty of headroom to keep the hint readable;

// shown when a window is below 25% to signal urgency.

const formatReset = (resetAt: number | undefined, pctLeft: number): string | null => {

if (!resetAt || !Number.isFinite(resetAt) || pctLeft >= 25) {

const timestampMs = asDateTimestampMs(resetAt);

if (timestampMs === undefined || pctLeft >= 25) {

return null;

}

const d = new Date(resetAt);

if (Number.isNaN(d.getTime())) {

return null;

}

const withinADay = resetAt - Date.now() < 24 * 60 * 60 * 1000;

const d = new Date(timestampMs);

const withinADay = timestampMs - Date.now() < 24 * 60 * 60 * 1000;

return withinADay

? d.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" })

: d.toLocaleDateString(undefined, { month: "short", day: "numeric" });