@ai-devkit/agent-manager 0.35.0 → 0.37.0

package/src/capacity/claude.ts

@@ -0,0 +1,313 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import type { Availability, CapacityReport, CapacityWindow } from "./types.js";
+
+const execFileAsync = promisify(execFile);
+
+export type ClaudeCapacityOptions = {
+  env?: NodeJS.ProcessEnv;
+  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+  now?: () => Date;
+  cwd?: string;
+  platform?: NodeJS.Platform;
+  keychainRead?: (service: string) => Promise<string | null>;
+};
+
+export type ClaudeProbeOptions = ClaudeCapacityOptions & {
+  checkedAt: string;
+};
+
+const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+const SESSION_DURATION_MINUTES = 5 * 60;
+const WEEK_DURATION_MINUTES = 7 * 24 * 60;
+
+type Credential = { token: string | null; expired: boolean };
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function percent(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100
+    ? value
+    : null;
+}
+
+function nonEmptyText(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function credentialsPath(options: ClaudeProbeOptions): string {
+  const env = options.env ?? process.env;
+  const configured = nonEmptyText(env.CLAUDE_CONFIG_DIR);
+  if (configured) {
+    const profileRoot = isAbsolute(configured)
+      ? configured
+      : resolve(options.cwd ?? process.cwd(), configured);
+    return join(profileRoot, ".credentials.json");
+  }
+  return join(env.HOME || homedir(), ".claude", ".credentials.json");
+}
+
+function credentialFromPayload(payload: string | null, now: Date): Credential {
+  if (!payload) return { token: null, expired: false };
+  try {
+    return credentialFromRoot(record(JSON.parse(payload)), now);
+  } catch {
+    return { token: null, expired: false };
+  }
+}
+
+async function readProfileCredential(options: ClaudeProbeOptions, now: Date): Promise<Credential> {
+  try {
+    const payload = await (options.readFile ?? readFile)(credentialsPath(options), "utf8");
+    return credentialFromPayload(payload, now);
+  } catch {
+    return { token: null, expired: false };
+  }
+}
+
+async function readKeychainCredential(options: ClaudeProbeOptions, now: Date): Promise<Credential> {
+  const env = options.env ?? process.env;
+  const usesDefaultProfile = !nonEmptyText(env.CLAUDE_CONFIG_DIR);
+  if (!usesDefaultProfile || (options.platform ?? process.platform) !== "darwin") {
+    return { token: null, expired: false };
+  }
+  try {
+    const payload = await (options.keychainRead ?? readClaudeKeychain)(CLAUDE_KEYCHAIN_SERVICE);
+    return credentialFromPayload(payload, now);
+  } catch {
+    return { token: null, expired: false };
+  }
+}
+
+async function resolveToken(options: ClaudeProbeOptions): Promise<string> {
+  const env = options.env ?? process.env;
+  const environmentToken = nonEmptyText(env.CLAUDE_CODE_OAUTH_TOKEN);
+  if (environmentToken) return environmentToken;
+
+  const now = options.now?.() ?? new Date();
+  const profileCredential = await readProfileCredential(options, now);
+  if (profileCredential.token) return profileCredential.token;
+
+  const keychainCredential = await readKeychainCredential(options, now);
+  if (keychainCredential.token) return keychainCredential.token;
+  if (profileCredential.expired || keychainCredential.expired) {
+    throw new Error("Claude OAuth credentials expired");
+  }
+  throw new Error("Claude OAuth credentials not found or malformed");
+}
+
+function credentialFromRoot(root: Record<string, unknown> | null, now: Date): Credential {
+  const oauth = record(root?.claudeAiOauth);
+  const token = nonEmptyText(oauth?.accessToken);
+  if (!token) return { token: null, expired: false };
+  const expired =
+    typeof oauth?.expiresAt === "number" &&
+    Number.isFinite(oauth.expiresAt) &&
+    oauth.expiresAt <= now.getTime();
+  return { token: expired ? null : token, expired };
+}
+
+async function readClaudeKeychain(service: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync(
+      "/usr/bin/security",
+      ["find-generic-password", "-s", service, "-w"],
+      { encoding: "utf8", timeout: 1500, maxBuffer: 1024 * 1024 },
+    );
+    return nonEmptyText(stdout);
+  } catch {
+    return null;
+  }
+}
+
+function resetTime(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const milliseconds = Date.parse(value);
+  return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
+}
+
+function usageWindow(
+  value: unknown,
+  id: string,
+  label: string,
+  durationMinutes: number,
+): CapacityWindow | null {
+  const input = record(value);
+  if (!input) return null;
+  return {
+    id,
+    label,
+    durationMinutes,
+    usedPercent: percent(input.utilization),
+    resetsAt: resetTime(input.resets_at),
+  };
+}
+
+function slug(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function scopedWindows(value: unknown): CapacityWindow[] {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<string>();
+  const windows: CapacityWindow[] = [];
+  for (const entry of value) {
+    const limit = record(entry);
+    const model = record(record(limit?.scope)?.model);
+    const name = nonEmptyText(model?.display_name);
+    const identity = nonEmptyText(model?.id) ?? name;
+    if (limit?.kind !== "weekly_scoped" || limit.group !== "weekly" || !name || !identity) {
+      continue;
+    }
+    const modelSlug = slug(identity);
+    if (!modelSlug || modelSlug === "all-models" || modelSlug.endsWith("-all-models")) {
+      continue;
+    }
+    const id = `claude:weekly:${modelSlug}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    windows.push({
+      id,
+      label: `${name} weekly`,
+      durationMinutes: WEEK_DURATION_MINUTES,
+      usedPercent: percent(limit.percent),
+      resetsAt: resetTime(limit.resets_at),
+    });
+  }
+  return windows;
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function extraUsageWindow(value: unknown): CapacityWindow | null {
+  const extra = record(value);
+  if (!extra || extra.is_enabled !== true) return null;
+  const limitMinor = finiteNumber(extra.monthly_limit);
+  const usedMinor = finiteNumber(extra.used_credits);
+  if (limitMinor === null || usedMinor === null) return null;
+  const total = limitMinor / 100;
+  const current = usedMinor / 100;
+  const currency = nonEmptyText(extra.currency)?.toUpperCase() ?? "USD";
+  return {
+    id: "claude:extra-usage",
+    label: `Extra usage · ${currency}`,
+    limitType: "CREDIT_LIMIT",
+    durationMinutes: null,
+    usedPercent:
+      percent(extra.utilization) ??
+      (total > 0 ? Math.max(0, Math.min(100, (current / total) * 100)) : null),
+    resetsAt: null,
+    total,
+    current,
+    remaining: Math.max(0, total - current),
+  };
+}
+
+function availability(windows: CapacityWindow[]): Availability {
+  const known = windows.flatMap((window) =>
+    window.usedPercent === null ? [] : [window.usedPercent],
+  );
+  if (known.length === 0) return "unknown";
+  return known.some((used) => used < 100) ? "yes" : "no";
+}
+
+function retryAfterTime(response: Response, now: Date): string | null {
+  const raw = response.headers.get("Retry-After")?.trim();
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return new Date(now.getTime() + seconds * 1000).toISOString();
+  }
+  const milliseconds = Date.parse(raw);
+  return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
+}
+
+export function parseClaudeUsage(raw: unknown, checkedAt: string): CapacityReport {
+  const input = record(raw);
+  if (!input) throw new Error("Claude usage response is malformed");
+  const windows = [
+    usageWindow(input.five_hour, "session", "Session", SESSION_DURATION_MINUTES),
+    usageWindow(input.seven_day, "weekly", "Weekly", WEEK_DURATION_MINUTES),
+    usageWindow(
+      input.seven_day_sonnet,
+      "claude:sonnet:weekly",
+      "Sonnet weekly",
+      WEEK_DURATION_MINUTES,
+    ),
+    usageWindow(input.seven_day_opus, "claude:opus:weekly", "Opus weekly", WEEK_DURATION_MINUTES),
+    ...scopedWindows(input.limits),
+    extraUsageWindow(input.extra_usage),
+  ].filter((window): window is CapacityWindow => window !== null);
+  return {
+    harness: "claude",
+    provider: "anthropic",
+    generatedAt: checkedAt,
+    authenticated: true,
+    available: availability(windows),
+    windows,
+    creditsRemaining: null,
+  };
+}
+
+export async function probeClaudeCapacity(options: ClaudeProbeOptions): Promise<CapacityReport> {
+  const token = await resolveToken(options);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 5000);
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(CLAUDE_USAGE_URL, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "User-Agent": "claude-code/2.1.0",
+        "anthropic-beta": "oauth-2025-04-20",
+      },
+      signal: controller.signal,
+    });
+  } catch {
+    throw new Error("Claude OAuth usage request failed");
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 401) {
+    throw new Error("Claude OAuth request unauthorized (HTTP 401)");
+  }
+  if (response.status === 403) {
+    throw new Error("Claude OAuth request forbidden (HTTP 403)");
+  }
+  if (response.status === 429) {
+    const retryAt = retryAfterTime(response, options.now?.() ?? new Date());
+    throw new Error(
+      retryAt
+        ? `Claude OAuth usage rate limited until ${retryAt}`
+        : "Claude OAuth usage rate limited (HTTP 429)",
+    );
+  }
+  if (!response.ok) {
+    throw new Error(`Claude OAuth usage request failed (HTTP ${response.status})`);
+  }
+  let raw: unknown;
+  try {
+    raw = await response.json();
+  } catch {
+    throw new Error("Claude usage response is malformed");
+  }
+  return parseClaudeUsage(raw, options.checkedAt);
+}

package/src/capacity/codex.ts

@@ -1,8 +1,11 @@
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { parseWhamUsage, resetTime, safeIdentifier } from "./wham.js";
 import type { CapacityReport, CapacityWindow } from "./types.js";
 
+export { toRateWindow } from "./wham.js";
+
 type CodexUsageSource = "pat" | "oauth" | "cli";
 type UsageSnapshot = {
   windows: CapacityWindow[];
@@ -15,13 +18,7 @@ type RpcMessage = { id?: number; method: string; params?: UnknownRecord };
 type CliResponses = { rateLimits: unknown; account: unknown };
 type CodexRpc = (messages: RpcMessage[]) => Promise<CliResponses>;
 
-export const CODEX_APP_SERVER_ARGS = [
-  "-s",
-  "read-only",
-  "-a",
-  "untrusted",
-  "app-server",
-] as const;
+export const CODEX_APP_SERVER_ARGS = ["-s", "read-only", "-a", "untrusted", "app-server"] as const;
 
 type CodexProbeOptions = {
   installed: boolean;
@@ -48,91 +45,17 @@ function nonEmptyText(value: unknown): string | null {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
-function resetTime(value: unknown): string | null {
-  const seconds = finiteNumber(value);
-  if (seconds !== null) return new Date(seconds * 1000).toISOString();
-  if (typeof value === "string" && !Number.isNaN(Date.parse(value)))
-    return new Date(value).toISOString();
-  return null;
-}
-
-function safeIdentifier(value: unknown): string | null {
-  const candidate = nonEmptyText(value);
-  if (!candidate || !/^[a-z][a-z0-9_-]{0,63}$/i.test(candidate)) return null;
-  if (/(?:account|token|secret|key)[_-]?\d{6,}/i.test(candidate)) return null;
-  return candidate;
-}
-
-export function resolveCodexAuthPath(
-  env: NodeJS.ProcessEnv = process.env,
-): string {
+export function resolveCodexAuthPath(env: NodeJS.ProcessEnv = process.env): string {
   const root = env.CODEX_HOME || join(env.HOME || "", ".codex");
   return join(root, "auth.json");
 }
 
-export function toRateWindow(
-  value: unknown,
-  id: string,
-  label: string,
-): CapacityWindow | null {
-  const input = record(value);
-  if (!input) return null;
-  const used = finiteNumber(input.used_percent);
-  const seconds = finiteNumber(input.limit_window_seconds);
-  return {
-    id,
-    label,
-    durationMinutes: seconds === null ? null : seconds / 60,
-    usedPercent: used,
-    resetsAt: resetTime(input.reset_at),
-  };
-}
-
-function extraWindows(value: unknown): CapacityWindow[] {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry, index) => {
-    const limit = record(entry);
-    if (!limit) return [];
-    const scope = safeIdentifier(limit.limit_name) ?? `extra-${index + 1}`;
-    const windows = record(limit.rate_limit) ?? limit;
-    return [
-      toRateWindow(
-        windows.primary_window,
-        `${scope}:primary`,
-        `${scope} primary`,
-      ),
-      toRateWindow(
-        windows.secondary_window,
-        `${scope}:secondary`,
-        `${scope} secondary`,
-      ),
-    ].filter((window): window is CapacityWindow => window !== null);
-  });
+export function parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot {
+  const { windows, creditsRemaining } = parseWhamUsage(raw);
+  return { windows, creditsRemaining, source };
 }
 
-export function parseUsage(
-  raw: unknown,
-  source: "pat" | "oauth",
-): UsageSnapshot {
-  const response = record(raw) ?? {};
-  const limits = record(response.rate_limit) ?? {};
-  const credits = record(response.credits) ?? {};
-  return {
-    windows: [
-      toRateWindow(limits.primary_window, "session", "Session"),
-      toRateWindow(limits.secondary_window, "weekly", "Weekly"),
-      ...extraWindows(response.additional_rate_limits),
-    ].filter((window): window is CapacityWindow => window !== null),
-    creditsRemaining: finiteNumber(credits.balance),
-    source,
-  };
-}
-
-function cliWindow(
-  value: unknown,
-  id: string,
-  label: string,
-): CapacityWindow | null {
+function cliWindow(value: unknown, id: string, label: string): CapacityWindow | null {
   const input = record(value);
   if (!input) return null;
   return {
@@ -144,14 +67,10 @@ function cliWindow(
   };
 }
 
-function cliSnapshotWindows(
-  value: unknown,
-  fallbackId: string,
-): CapacityWindow[] {
+function cliSnapshotWindows(value: unknown, fallbackId: string): CapacityWindow[] {
   const snapshot = record(value);
   if (!snapshot) return [];
-  const scope =
-    safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
+  const scope = safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
   return [
     cliWindow(snapshot.primary, `${scope}:primary`, `${scope} primary`),
     cliWindow(snapshot.secondary, `${scope}:secondary`, `${scope} secondary`),
@@ -167,9 +86,7 @@ export function parseCliUsage(raw: unknown): UsageSnapshot {
     for (const [id, snapshot] of Object.entries(buckets))
       windows.push(...cliSnapshotWindows(snapshot, id));
   }
-  const unique = [
-    ...new Map(windows.map((window) => [window.id, window])).values(),
-  ];
+  const unique = [...new Map(windows.map((window) => [window.id, window])).values()];
   return { windows: unique, creditsRemaining: null, source: "cli" };
 }
 
@@ -178,14 +95,11 @@ function capacityFromSnapshot(
   context: CodexProbeOptions,
   raw?: unknown,
 ): CapacityReport {
-  const hasUsage = snapshot.windows.some(
-    (window) => window.usedPercent !== null,
-  );
+  const hasUsage = snapshot.windows.some((window) => window.usedPercent !== null);
   const rateLimits = record(record(raw)?.rateLimits);
   const reached = nonEmptyText(rateLimits?.rateLimitReachedType);
   const resetCredits =
-    record(record(raw)?.rateLimitResetCredits) ??
-    record(record(raw)?.usageLimitResetCredits);
+    record(record(raw)?.rateLimitResetCredits) ?? record(record(raw)?.usageLimitResetCredits);
   return {
     harness: "codex",
     provider: "openai",
@@ -193,8 +107,7 @@ function capacityFromSnapshot(
     authenticated: true,
     available: reached ? "no" : hasUsage ? "yes" : "unknown",
     windows: snapshot.windows,
-    creditsRemaining:
-      snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
+    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
   };
 }
 
@@ -202,9 +115,7 @@ function jwtExpiry(token: string): number | null {
   const part = token.split(".")[1];
   if (!part) return null;
   try {
-    return finiteNumber(
-      record(JSON.parse(Buffer.from(part, "base64url").toString("utf8")))?.exp,
-    );
+    return finiteNumber(record(JSON.parse(Buffer.from(part, "base64url").toString("utf8")))?.exp);
   } catch {
     return null;
   }
@@ -231,10 +142,7 @@ async function fetchJson(
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const response = await fetcher(url, { ...init, signal: controller.signal });
-    if (!response.ok)
-      throw new Error(
-        response.status === 401 ? "unauthorized" : "request failed",
-      );
+    if (!response.ok) throw new Error(response.status === 401 ? "unauthorized" : "request failed");
     return await response.json();
   } finally {
     clearTimeout(timer);
@@ -262,10 +170,7 @@ async function apiSnapshot(
   return parseUsage(raw, source);
 }
 
-function appServerRpc(
-  messages: RpcMessage[],
-  timeoutMs = 5000,
-): Promise<CliResponses> {
+function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResponses> {
   return new Promise((resolve, reject) => {
     const child = spawn("codex", CODEX_APP_SERVER_ARGS, {
       stdio: ["pipe", "pipe", "ignore"],
@@ -281,13 +186,8 @@ function appServerRpc(
       if (error) reject(error);
       else resolve(results as CliResponses);
     };
-    const timer = setTimeout(
-      () => finish(new Error("codex probe timed out")),
-      timeoutMs,
-    );
-    child.once("error", () =>
-      finish(new Error("codex app-server unavailable")),
-    );
+    const timer = setTimeout(() => finish(new Error("codex probe timed out")), timeoutMs);
+    child.once("error", () => finish(new Error("codex app-server unavailable")));
     child.once("exit", () => {
       if (!settled) finish(new Error("codex app-server exited"));
     });
@@ -310,8 +210,7 @@ function appServerRpc(
           for (const request of messages.slice(1))
             child.stdin.write(`${JSON.stringify(request)}\n`);
         } else if (message.id === 2) {
-          if (message.error)
-            finish(new Error("codex rate-limit method failed"));
+          if (message.error) finish(new Error("codex rate-limit method failed"));
           else results.rateLimits = message.result;
         } else if (message.id === 3) {
           if (message.error) finish(new Error("codex account method failed"));
@@ -340,9 +239,7 @@ function unavailable(options: CodexProbeOptions): CapacityReport {
   return codexUnavailableReport(options.checkedAt);
 }
 
-async function cliFallback(
-  options: CodexProbeOptions,
-): Promise<CapacityReport> {
+async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport> {
   if (!options.installed) return unavailable(options);
   const messages: RpcMessage[] = [
     {
@@ -358,8 +255,7 @@ async function cliFallback(
     { id: 3, method: "account/read" },
   ];
   try {
-    const rpc =
-      options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
+    const rpc = options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
     const response = await rpc(messages);
     const result = capacityFromSnapshot(
       parseCliUsage(response.rateLimits),
@@ -381,9 +277,7 @@ async function cliFallback(
   }
 }
 
-export async function probeCodexCapacity(
-  options: CodexProbeOptions,
-): Promise<CapacityReport> {
+export async function probeCodexCapacity(options: CodexProbeOptions): Promise<CapacityReport> {
   let parsed: UnknownRecord | null = null;
   try {
     const contents = await (options.readFile ?? readFile)(
@@ -410,10 +304,7 @@ export async function probeCodexCapacity(
       );
       const accountId = nonEmptyText(whoami?.chatgpt_account_id);
       if (!accountId) throw new Error("account unavailable");
-      return capacityFromSnapshot(
-        await apiSnapshot(pat, accountId, "pat", options),
-        options,
-      );
+      return capacityFromSnapshot(await apiSnapshot(pat, accountId, "pat", options), options);
     } catch {
       // Continue to a separately available OAuth credential before using the CLI.
     }

package/src/capacity/index.ts

@@ -2,10 +2,13 @@ import { constants } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
 import path from "node:path";
 import { codexUnavailableReport, probeCodexCapacity } from "./codex.js";
+import { probeClaudeCapacity, type ClaudeCapacityOptions } from "./claude.js";
+import { probeOpenAiCapacity } from "./openai.js";
 import { probeZaiCapacity } from "./zai.js";
 import type { CapacityReport } from "./types.js";
 
 export type { CapacityReport, CapacityWindow } from "./types.js";
+export type { ClaudeCapacityOptions } from "./claude.js";
 
 export type CapacityProbeOptions = {
   now?: () => Date;
@@ -22,6 +25,14 @@ export type ZaiCapacityOptions = {
   timeoutMs?: number;
 };
 
+export type OpenAiCapacityOptions = {
+  now?: () => Date;
+  env?: NodeJS.ProcessEnv;
+  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
 async function canAccess(target: string, mode: number): Promise<boolean> {
   try {
     await fsAccess(target, mode);
@@ -55,10 +66,7 @@ export async function getCodexCapacityReport(
   options: CapacityProbeOptions = {},
 ): Promise<CapacityReport> {
   const generatedAt = (options.now?.() ?? new Date()).toISOString();
-  const installed = await isCodexInstalled(
-    options.path ?? process.env.PATH ?? "",
-    options.access,
-  );
+  const installed = await isCodexInstalled(options.path ?? process.env.PATH ?? "", options.access);
   try {
     return await (options.probe ?? probeCodexCapacity)({
       installed,
@@ -78,3 +86,24 @@ export async function getZaiCapacityReport(
     checkedAt: (now?.() ?? new Date()).toISOString(),
   });
 }
+
+export async function getOpenAiCapacityReport(
+  options: OpenAiCapacityOptions = {},
+): Promise<CapacityReport> {
+  const { now, ...probeOptions } = options;
+  return probeOpenAiCapacity({
+    ...probeOptions,
+    checkedAt: (now?.() ?? new Date()).toISOString(),
+  });
+}
+
+export async function getClaudeCapacityReport(
+  options: ClaudeCapacityOptions = {},
+): Promise<CapacityReport> {
+  const { now, ...probeOptions } = options;
+  return probeClaudeCapacity({
+    ...probeOptions,
+    checkedAt: (now?.() ?? new Date()).toISOString(),
+    now,
+  });
+}