@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

package/runtime/node_modules/@metro-labs/daemon/src/gateway/text.ts

@@ -0,0 +1,33 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
+export const TOOL_ERROR = '[tool error]';
+
+export interface InlineImage {
+  mediaType: string;
+  data: string;
+}
+
+type Part = Record<string, unknown>;
+type Accepts = (mediaType: string) => boolean;
+const anyImage: Accepts = () => true;
+
+export function inlineImage(block: Part, accepts = anyImage): InlineImage | null {
+  if (block.type !== 'image' || !isRecord(block.source) || block.source.type !== 'base64') return null;
+  const image = { mediaType: stringOf(block.source.media_type), data: stringOf(block.source.data) };
+  return image.mediaType !== '' && image.data !== '' && accepts(image.mediaType) ? image : null;
+}
+
+export const resultParts = (block: Part): Part[] => (Array.isArray(block.content) ? block.content.filter(isRecord) : []);
+
+export const partText = (part: Part, accepts = anyImage): string =>
+  part.type === 'text' ? stringOf(part.text) : part.type === 'image' && inlineImage(part, accepts) === null ? IMAGE_NOTE : '';
+
+export function resultText(block: Part, accepts = anyImage): string {
+  const content = block.content;
+  const text = typeof content === 'string' ? content : resultParts(block).map((part) => partText(part, accepts)).filter((t) => t !== '').join('\n');
+  return block.is_error === true ? `${TOOL_ERROR} ${text}` : text;
+}
+
+export const resultImages = (block: Part, accepts = anyImage): InlineImage[] => resultParts(block).flatMap((part) => inlineImage(part, accepts) ?? []);

package/runtime/node_modules/@metro-labs/daemon/src/gateway/tool-search.ts

@@ -0,0 +1,126 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Body = Record<string, unknown>;
+
+const TOOL_SEARCH_BETA = /^(advanced-tool-use|tool-search-tool|mid-conversation-tool-changes)-/;
+const PLACEHOLDER = 'DeferredToolPlaceholder';
+const NOTHING_FOUND = 'No matching deferred tools found';
+
+const blocksOf = (message: unknown): unknown[] => (isRecord(message) && Array.isArray(message.content) ? message.content : []);
+
+const isResult = (block: unknown): block is Body & { content: unknown[] } => isRecord(block) && block.type === 'tool_result' && Array.isArray(block.content);
+
+const inlineDefinition = (block: unknown): Body | null =>
+  isRecord(block) && block.type === 'tool_addition' && isRecord(block.tool) && block.tool.type === 'tool_definition' && isRecord(block.tool.definition) ? block.tool.definition : null;
+
+function loadedName(block: unknown): string | null {
+  if (!isRecord(block)) return null;
+  if (block.type === 'tool_reference') return stringOf(block.tool_name);
+  if (block.type !== 'tool_addition' || !isRecord(block.tool)) return null;
+  return stringOf(inlineDefinition(block)?.name ?? block.tool.name);
+}
+
+const removedName = (block: unknown): string | null => (isRecord(block) && block.type === 'tool_removal' && isRecord(block.tool) ? stringOf(block.tool.name) : null);
+
+const changes = (block: unknown): boolean => loadedName(block) !== null || removedName(block) !== null;
+
+const changing = (message: unknown): boolean => blocksOf(message).some((block) => changes(block) || (isResult(block) && block.content.some(changes)));
+
+const functionLine = (tool: Body): string =>
+  `<function>${JSON.stringify({ description: stringOf(tool.description), name: tool.name, parameters: isRecord(tool.input_schema) ? tool.input_schema : {} })}</function>`;
+
+function functionsText(blocks: unknown[], catalog: Map<string, Body>): string {
+  const lines = blocks.flatMap((block) => {
+    const tool = catalog.get(loadedName(block) ?? '');
+    return tool === undefined ? [] : [functionLine(tool)];
+  });
+  return lines.length === 0 ? NOTHING_FOUND : ['<functions>', ...lines, '</functions>'].join('\n');
+}
+
+const cacheOf = (blocks: unknown[]): Body => {
+  const marked = blocks.find((block) => isRecord(block) && block.cache_control !== undefined);
+  return isRecord(marked) ? { cache_control: marked.cache_control } : {};
+};
+
+function expanded(blocks: unknown[], catalog: Map<string, Body>): unknown[] {
+  const found = blocks.filter((block) => loadedName(block) !== null);
+  return blocks.flatMap((block) => {
+    if (block === found[0]) return [{ type: 'text', text: functionsText(found, catalog), ...cacheOf(found) }];
+    if (loadedName(block) !== null) return [];
+    const removed = removedName(block);
+    return removed === null ? [block] : [{ type: 'text', text: `Tool ${removed} is no longer available.`, ...cacheOf([block]) }];
+  });
+}
+
+const expandedBlock = (block: unknown, catalog: Map<string, Body>): unknown =>
+  isResult(block) && block.content.some(changes) ? { ...block, content: expanded(block.content, catalog) } : block;
+
+function expandedMessage(message: unknown, catalog: Map<string, Body>): unknown {
+  if (!changing(message) || !isRecord(message)) return message;
+  return { ...message, content: expanded(blocksOf(message).map((block) => expandedBlock(block, catalog)), catalog) };
+}
+
+interface Found {
+  names: Set<string>;
+  inline: Map<string, Body>;
+}
+
+function foundIn(messages: unknown[]): Found {
+  const found: Found = { names: new Set(), inline: new Map() };
+  const blocks = messages.flatMap(blocksOf).flatMap((block) => (isResult(block) ? block.content : [block]));
+  for (const block of blocks) {
+    const name = loadedName(block);
+    const definition = inlineDefinition(block);
+    if (name !== null) found.names.add(name);
+    if (definition !== null) found.inline.set(stringOf(definition.name), definition);
+    const removed = removedName(block);
+    if (removed === null) continue;
+    found.names.delete(removed);
+    found.inline.delete(removed);
+  }
+  return found;
+}
+
+const deferred = (tool: unknown): boolean => isRecord(tool) && tool.defer_loading === true;
+
+const loaded = (tool: unknown): unknown =>
+  isRecord(tool) && 'defer_loading' in tool ? Object.fromEntries(Object.entries(tool).filter(([key]) => key !== 'defer_loading')) : tool;
+
+const deferring = (tools: unknown): boolean => Array.isArray(tools) && tools.some((tool) => isRecord(tool) && 'defer_loading' in tool);
+
+const nameOf = (tool: unknown): string => (isRecord(tool) ? stringOf(tool.name) : '');
+
+export function resolveToolSearch(body: Body): Body {
+  const messages: unknown[] = Array.isArray(body.messages) ? body.messages : [];
+  if (!deferring(body.tools) && !messages.some(changing)) return body;
+  const declared: unknown[] = Array.isArray(body.tools) ? body.tools : [];
+  const found = foundIn(messages);
+  const shown = declared.filter((tool) => nameOf(tool) !== PLACEHOLDER && (!deferred(tool) || found.names.has(nameOf(tool)))).map(loaded);
+  const known = new Set(shown.map(nameOf));
+  const inline = [...found.inline.values()].filter((tool) => !known.has(nameOf(tool))).map(loaded);
+  const tools = [...shown, ...inline];
+  const catalog = new Map([...declared, ...inline].filter(isRecord).map((tool) => [nameOf(tool), tool]));
+  return {
+    ...body,
+    ...(Array.isArray(body.tools) || inline.length > 0 ? { tools } : {}),
+    ...(Array.isArray(body.messages) ? { messages: messages.map((message) => expandedMessage(message, catalog)) } : {}),
+  };
+}
+
+function dropToolSearchBeta(req: IncomingMessage): void {
+  const raw = req.headers['anthropic-beta'];
+  if (typeof raw !== 'string') return;
+  const kept = raw
+    .split(',')
+    .map((beta) => beta.trim())
+    .filter((beta) => beta !== '' && !TOOL_SEARCH_BETA.test(beta));
+  if (kept.length > 0) req.headers['anthropic-beta'] = kept.join(',');
+  else delete req.headers['anthropic-beta'];
+}
+
+export function fitToolSearch(req: IncomingMessage, body: Body): Body {
+  dropToolSearchBeta(req);
+  return resolveToolSearch(body);
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/usage-refresh.ts

@@ -0,0 +1,95 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { readClaudeUsage } from '../claude/usage-probe.js';
+import { openrouterKey } from './openrouter.js';
+import { claudeLoginUsage, keepProbeAnswer, mayProbe, mergeUsage, noteUsage, openrouterUsage, probeAnswer, usageOf } from './usage.js';
+import { loginRef, primaryRoute, SESSION_LOGIN, type Connection, type ModelSetup } from './model-config.js';
+import { probeClaudeLogin, type ClaudeLoginDeps } from './claude-logins.js';
+import type { ClaudeLogin } from './claude-store.js';
+
+export const CREDITS_TTL_MS = 5 * 60_000;
+const WAIT_MS = 4_000;
+const LOGIN_PROBE = 'claude-login';
+
+export interface UsageDeps {
+  fetchImpl?: typeof fetch;
+  openrouterBase?: string;
+  claudeUsage?: (env?: Record<string, string>) => Promise<unknown>;
+  claudeLogins?: ClaudeLoginDeps;
+  usageWaitMs?: number;
+}
+
+const fresh = (id: string, now: number): boolean => {
+  const seen = usageOf(id);
+  return seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS;
+};
+
+const due = (id: string, now: number): boolean => !fresh(id, now) && mayProbe(id, now, CREDITS_TTL_MS);
+
+async function probe(what: string, run: () => Promise<void>): Promise<void> {
+  try {
+    await run();
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, `model-api: could not read the ${what}`);
+  }
+}
+
+async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
+  if (conn.provider !== 'openrouter' || conn.apiKey === '' || !due(conn.id, now)) return;
+  await probe('OpenRouter key spend', async () => {
+    noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
+  });
+}
+
+const hasFallbacks = (setup: ModelSetup): boolean => setup.fallbacks.length > 0;
+
+async function refreshOwnLogin(login: string, setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
+  const key = loginRef(login);
+  if ((fresh(key, now) && !hasFallbacks(setup)) || !mayProbe(key, now, CREDITS_TTL_MS)) return;
+  await probe('usage of a Claude login', async () => {
+    const usage = claudeLoginUsage(await probeClaudeLogin(login, deps.claudeLogins), new Date(now));
+    if (usage !== null) mergeUsage(key, usage);
+  });
+}
+
+const ridesSession = (setup: ModelSetup): boolean => primaryRoute(setup) === null || setup.connections.some((c) => c.id === SESSION_LOGIN);
+
+async function refreshSession(setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
+  if (!ridesSession(setup) || (fresh(SESSION_LOGIN, now) && !hasFallbacks(setup))) return;
+  if (mayProbe(LOGIN_PROBE, now, CREDITS_TTL_MS))
+    await probe('usage of the Claude Code login', async () => {
+      const usage = claudeLoginUsage(await (deps.claudeUsage ?? (() => readClaudeUsage()))(), new Date(now));
+      if (usage !== null) keepProbeAnswer(LOGIN_PROBE, usage);
+    });
+  const usage = probeAnswer(LOGIN_PROBE);
+  if (usage !== undefined && now - Date.parse(usage.at) < CREDITS_TTL_MS) mergeUsage(SESSION_LOGIN, usage);
+}
+
+async function within(ms: number, work: Promise<unknown>): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const waited = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, ms);
+  });
+  await Promise.race([work, waited]);
+  clearTimeout(timer);
+}
+
+export async function refreshUsage(setup: ModelSetup, logins: ClaudeLogin[], deps: UsageDeps = {}, now = Date.now()): Promise<void> {
+  const own = new Set([...logins.map((l) => l.id), ...setup.connections.flatMap((c) => (c.claude === null || c.signedOut ? [] : [c.claude]))]);
+  const work = Promise.all([
+    ...setup.connections.map((conn) => refreshKey(conn, deps, now)),
+    ...[...own].map((login) => refreshOwnLogin(login, setup, deps, now)),
+    refreshSession(setup, deps, now),
+  ]);
+  await within(deps.usageWaitMs ?? WAIT_MS, work);
+}
+
+export function watchFallbackUsage(setup: () => ModelSetup, logins: () => ClaudeLogin[], deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
+  const run = (): void => {
+    const current = setup();
+    if (!hasFallbacks(current)) return;
+    refreshUsage(current, logins(), deps).catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'model-api: could not refresh the usage of the fallback models');
+    });
+  };
+  setInterval(run, every).unref();
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/usage.ts

@@ -0,0 +1,330 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Key = string;
+
+export interface UsageWindow {
+  label: string;
+  used: number | null;
+  resetAt: string | null;
+  detail: string | null;
+}
+
+interface Tally {
+  requests: number;
+  input: number;
+  output: number;
+  cached: number;
+  since: string;
+}
+
+export interface ProviderUsage {
+  windows: UsageWindow[];
+  note: string | null;
+  at: string;
+  tally: Tally | null;
+}
+
+export type Reported = Omit<ProviderUsage, 'tally'>;
+
+const latest = new Map<Key, Reported>();
+const stamps = new Map<Key, Map<string, number>>();
+const tallies = new Map<Key, Tally>();
+const probed = new Map<Key, number>();
+const answers = new Map<Key, Reported>();
+
+export const noteUsage = (key: Key, usage: Reported): void => {
+  latest.set(key, usage);
+  stamps.set(key, new Map(usage.windows.map((w) => [w.label, Date.parse(usage.at)])));
+};
+
+export function mergeUsage(key: Key, usage: Reported): void {
+  const seen = latest.get(key);
+  const marks = stamps.get(key);
+  if (seen === undefined || marks === undefined) {
+    noteUsage(key, usage);
+    return;
+  }
+  const at = Date.parse(usage.at);
+  const newer = new Map(usage.windows.filter((w) => (marks.get(w.label) ?? Number.NEGATIVE_INFINITY) <= at).map((w) => [w.label, w]));
+  for (const label of newer.keys()) marks.set(label, at);
+  const kept = seen.windows.map((w) => newer.get(w.label) ?? w);
+  const added = [...newer.values()].filter((w) => !seen.windows.some((old) => old.label === w.label));
+  const later = Date.parse(seen.at) <= at;
+  latest.set(key, { windows: [...kept, ...added], note: later ? usage.note : seen.note, at: later ? usage.at : seen.at });
+}
+
+export function usageSeen(): Record<Key, ProviderUsage> {
+  const out: Record<Key, ProviderUsage> = {};
+  for (const key of new Set<Key>([...latest.keys(), ...tallies.keys()])) {
+    const reported = latest.get(key);
+    const tally = tallies.get(key) ?? null;
+    out[key] = reported === undefined ? { windows: [], note: null, at: tally?.since ?? new Date().toISOString(), tally } : { ...reported, tally };
+  }
+  return out;
+}
+
+export const usageOf = (key: Key): Reported | undefined => latest.get(key);
+
+export const forgetOne = (key: Key): void => {
+  latest.delete(key);
+  stamps.delete(key);
+  tallies.delete(key);
+  probed.delete(key);
+};
+
+export const forgetReported = (key: Key): void => {
+  latest.delete(key);
+  stamps.delete(key);
+  probed.delete(key);
+};
+
+export const forgetUsage = (): void => {
+  latest.clear();
+  stamps.clear();
+  tallies.clear();
+  probed.clear();
+  answers.clear();
+};
+
+export function mayProbe(key: Key, now: number, every: number): boolean {
+  if (now - (probed.get(key) ?? Number.NEGATIVE_INFINITY) < every) return false;
+  probed.set(key, now);
+  return true;
+}
+
+export const probeAnswer = (key: Key): Reported | undefined => answers.get(key);
+
+export const keepProbeAnswer = (key: Key, usage: Reported): void => {
+  answers.set(key, usage);
+};
+
+export interface Counted {
+  input: number;
+  output: number;
+  cached: number;
+}
+
+export function tallyTokens(key: Key, counted: Counted, now = new Date()): void {
+  const so = tallies.get(key) ?? { requests: 0, input: 0, output: 0, cached: 0, since: now.toISOString() };
+  tallies.set(key, {
+    requests: so.requests + 1,
+    input: so.input + counted.input,
+    output: so.output + counted.output,
+    cached: so.cached + counted.cached,
+    since: so.since,
+  });
+}
+
+const TOKEN_FIELD = /"(input_tokens|output_tokens|cache_read_input_tokens|cache_creation_input_tokens)"\s*:\s*(\d+)/g;
+
+export class UsageScanner {
+  private carry = '';
+  private readonly max = { input: 0, output: 0, read: 0, creation: 0 };
+  private touched = false;
+
+  constructor(private readonly key: Key) {}
+
+  private scan(text: string): void {
+    for (const hit of text.matchAll(TOKEN_FIELD)) {
+      const value = Number(hit[2]);
+      if (!Number.isFinite(value)) continue;
+      this.touched = true;
+      if (hit[1] === 'input_tokens') this.max.input = Math.max(this.max.input, value);
+      else if (hit[1] === 'output_tokens') this.max.output = Math.max(this.max.output, value);
+      else if (hit[1] === 'cache_read_input_tokens') this.max.read = Math.max(this.max.read, value);
+      else this.max.creation = Math.max(this.max.creation, value);
+    }
+  }
+
+  feed(text: string): void {
+    const joined = this.carry + text;
+    const cut = joined.lastIndexOf('\n');
+    if (cut === -1) {
+      this.carry = joined;
+      return;
+    }
+    this.scan(joined.slice(0, cut));
+    this.carry = joined.slice(cut + 1);
+  }
+
+  done(now = new Date()): void {
+    if (this.carry !== '') this.scan(this.carry);
+    this.carry = '';
+    if (!this.touched) return;
+    tallyTokens(this.key, { input: this.max.input, output: this.max.output, cached: this.max.read + this.max.creation }, now);
+    this.touched = false;
+  }
+}
+
+const clamp = (value: number): number => Math.min(1, Math.max(0, value));
+
+function fraction(raw: string | null): number | null {
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? clamp(value) : null;
+}
+
+const MS_THRESHOLD = 1e12;
+
+function whenFrom(raw: string | null, now: Date, relative = false): string | null {
+  if (raw === null || raw.trim() === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) {
+    const absolute = numeric > MS_THRESHOLD ? numeric : numeric * 1000;
+    const ms = relative ? now.getTime() + numeric * 1000 : absolute;
+    return new Date(ms).toISOString();
+  }
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}
+
+const ANTHROPIC_WINDOWS: [string, string][] = [
+  ['5h', '5-hour window'],
+  ['7d', 'Weekly, all models'],
+  ['7d_sonnet', 'Weekly, Sonnet'],
+];
+
+function anthropicUnified(headers: Headers, now: Date): { windows: UsageWindow[]; note: string | null } {
+  const windows: UsageWindow[] = [];
+  let note: string | null = null;
+  for (const [key, label] of ANTHROPIC_WINDOWS) {
+    const used = fraction(headers.get(`anthropic-ratelimit-unified-${key}-utilization`));
+    if (used === null) continue;
+    const status = headers.get(`anthropic-ratelimit-unified-${key}-status`);
+    const blocked = status !== null && status !== 'allowed' ? status.replaceAll('_', ' ') : null;
+    if (blocked !== null && note === null) note = `${label}: ${blocked}`;
+    windows.push({ label, used, resetAt: whenFrom(headers.get(`anthropic-ratelimit-unified-${key}-reset`), now), detail: blocked });
+  }
+  return { windows, note };
+}
+
+export const PER_MINUTE = 'Tokens per minute';
+
+function anthropicKeyed(headers: Headers, now: Date): UsageWindow[] {
+  const limit = Number(headers.get('anthropic-ratelimit-tokens-limit'));
+  const remaining = Number(headers.get('anthropic-ratelimit-tokens-remaining'));
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining) || limit <= 0) return [];
+  return [
+    {
+      label: PER_MINUTE,
+      used: clamp(1 - remaining / limit),
+      resetAt: whenFrom(headers.get('anthropic-ratelimit-tokens-reset'), now),
+      detail: `${remaining.toLocaleString('en-US')} of ${limit.toLocaleString('en-US')} left`,
+    },
+  ];
+}
+
+export function anthropicUsage(headers: Headers, now = new Date()): Reported | null {
+  const unified = anthropicUnified(headers, now);
+  if (unified.windows.length > 0) return { ...unified, at: now.toISOString() };
+  const keyed = anthropicKeyed(headers, now);
+  return keyed.length === 0 ? null : { windows: keyed, note: null, at: now.toISOString() };
+}
+
+const MINUTES_PER_HOUR = 60;
+const MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
+const MINUTES_PER_WEEK = 7 * MINUTES_PER_DAY;
+
+export function windowLabel(minutes: number | null): string {
+  if (minutes === null || !Number.isFinite(minutes) || minutes <= 0) return 'Usage window';
+  if (minutes === MINUTES_PER_WEEK) return 'Weekly';
+  if (minutes % MINUTES_PER_DAY === 0) return `${String(minutes / MINUTES_PER_DAY)}-day window`;
+  if (minutes % MINUTES_PER_HOUR === 0) return `${String(minutes / MINUTES_PER_HOUR)}-hour window`;
+  return `${String(minutes)}-minute window`;
+}
+
+function codexWindow(headers: Headers, kind: 'primary' | 'secondary', now: Date): UsageWindow | null {
+  const raw = headers.get(`x-codex-${kind}-used-percent`);
+  if (raw === null) return null;
+  const percent = Number(raw);
+  if (!Number.isFinite(percent)) return null;
+  const used = clamp(percent / 100);
+  const minutes = Number(headers.get(`x-codex-${kind}-window-minutes`) ?? 'none');
+  const absolute = whenFrom(headers.get(`x-codex-${kind}-reset-at`), now);
+  const resetAt = absolute ?? whenFrom(headers.get(`x-codex-${kind}-reset-after-seconds`), now, true);
+  return { label: windowLabel(Number.isFinite(minutes) ? minutes : null), used, resetAt, detail: null };
+}
+
+function creditsLeft(hasCredits: boolean, raw: string | null): UsageWindow | null {
+  if (!hasCredits) return null;
+  const balance = Number(raw ?? 'none');
+  if (!Number.isFinite(balance)) return null;
+  return { label: 'Credits', used: null, resetAt: null, detail: `${balance.toLocaleString('en-US')} left` };
+}
+
+const codexCredits = (headers: Headers): UsageWindow | null =>
+  creditsLeft(headers.get('x-codex-credits-has-credits') === 'true', headers.get('x-codex-credits-balance'));
+
+export function codexUsage(headers: Headers, now = new Date()): Reported | null {
+  const windows = [codexWindow(headers, 'primary', now), codexWindow(headers, 'secondary', now), codexCredits(headers)].filter(
+    (w): w is UsageWindow => w !== null,
+  );
+  if (windows.length === 0) return null;
+  const reached = headers.get('x-codex-rate-limit-reached-type');
+  return { windows, note: reached === null || reached === '' ? null : reached.replaceAll('_', ' '), at: now.toISOString() };
+}
+
+const present = (w: UsageWindow | null): w is UsageWindow => w !== null;
+
+const textOf = (raw: unknown): string | null => (typeof raw === 'number' || typeof raw === 'string' ? String(raw) : null);
+
+const numberOf = (raw: unknown): number | null => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
+
+const CLAUDE_WINDOWS: [string, string][] = [
+  ['five_hour', '5-hour window'],
+  ['seven_day', 'Weekly, all models'],
+  ['seven_day_sonnet', 'Weekly, Sonnet'],
+  ['seven_day_opus', 'Weekly, Opus'],
+];
+
+function percentWindow(label: string, raw: unknown, now: Date): UsageWindow | null {
+  if (!isRecord(raw)) return null;
+  const percent = numberOf(raw.utilization) ?? numberOf(raw.percent);
+  if (percent === null) return null;
+  return { label, used: clamp(percent / 100), resetAt: whenFrom(textOf(raw.resets_at), now), detail: null };
+}
+
+function scopedName(entry: Record<string, unknown>): string {
+  if (stringOf(entry.display_name) !== '') return stringOf(entry.display_name);
+  if (entry.kind !== 'weekly_scoped' || !isRecord(entry.scope) || !isRecord(entry.scope.model)) return '';
+  return stringOf(entry.scope.model.display_name);
+}
+
+function scopedWindows(limits: Record<string, unknown>, now: Date): (UsageWindow | null)[] {
+  const listed = [limits.model_scoped, limits.limits].flatMap((list): unknown[] => (Array.isArray(list) ? (list as unknown[]) : []));
+  return listed.map((entry) => {
+    const name = isRecord(entry) ? scopedName(entry) : '';
+    return name === '' ? null : percentWindow(`Weekly, ${name}`, entry, now);
+  });
+}
+
+export function claudeLoginUsage(limits: unknown, now = new Date()): Reported | null {
+  if (!isRecord(limits)) return null;
+  const all = [...CLAUDE_WINDOWS.map(([key, label]) => percentWindow(label, limits[key], now)), ...scopedWindows(limits, now)].filter(present);
+  const windows = all.filter((w, index) => all.findIndex((other) => other.label === w.label) === index);
+  return windows.length === 0 ? null : { windows, note: null, at: now.toISOString() };
+}
+
+export function noteUsageHeaders(kind: 'anthropic' | 'codex', key: Key, headers: Headers, now = new Date()): void {
+  const usage = kind === 'anthropic' ? anthropicUsage(headers, now) : codexUsage(headers, now);
+  if (usage === null) return;
+  if (kind === 'anthropic') mergeUsage(key, usage);
+  else noteUsage(key, usage);
+}
+
+const dollars = (value: number): string => `$${value.toFixed(2)}`;
+
+export interface KeySpend {
+  limit: number | null;
+  remaining: number | null;
+  spent: number;
+}
+
+function keyWindow(key: KeySpend): UsageWindow {
+  if (key.limit === null || key.limit <= 0) return { label: 'Credits', used: null, resetAt: null, detail: `${dollars(key.spent)} used, no limit on this key` };
+  const spent = key.remaining === null ? key.spent : Math.max(0, key.limit - key.remaining);
+  return { label: 'Credits', used: clamp(spent / key.limit), resetAt: null, detail: `${dollars(spent)} of ${dollars(key.limit)} used` };
+}
+
+export const openrouterUsage = (key: KeySpend, now = new Date()): Reported => ({ windows: [keyWindow(key)], note: null, at: now.toISOString() });