@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/adapters/AgentAdapter.ts

@@ -5,20 +5,23 @@
  * Each adapter is responsible for detecting agents of a specific type (e.g., claude).
  */
 
+/** Every built-in harness type, in the order the CLI lists them. */
+export const AGENT_TYPES = [
+  "claude",
+  "codex",
+  "gemini_cli",
+  "grok_cli",
+  "kiro",
+  "antigravity_cli",
+  "opencode",
+  "copilot",
+  "pi",
+] as const;
+
 /**
  * Type of AI agent
  */
-export type AgentType =
-  | "claude"
-  | "gemini_cli"
-  | "grok_cli"
-  | "kiro"
-  | "antigravity_cli"
-  | "codex"
-  | "opencode"
-  | "copilot"
-  | "pi"
-  | "other";
+export type AgentType = (typeof AGENT_TYPES)[number] | "other";
 
 /**
  * Current status of an agent
@@ -97,6 +100,25 @@ export interface ConversationMessage {
   timestamp?: string;
 }
 
+/**
+ * Options for {@link AgentAdapter.getConversation}.
+ */
+export interface ConversationOptions {
+  /** Include tool call/result details */
+  verbose?: boolean;
+  /**
+   * Return only the last `tail` messages (after verbose filtering). When
+   * omitted or not a positive integer, the full conversation is returned.
+   *
+   * JSONL-backed adapters read backward from the end of the file and, on
+   * later calls, parse only appended bytes, so cost is proportional to the
+   * tail rather than the transcript size. Adapters backed by a single JSON
+   * document (Gemini) or a database (OpenCode) still read the whole source
+   * and slice; callers should keep an mtime cache for those.
+   */
+  tail?: number;
+}
+
 /**
  * A historical session discovered on disk (running or not).
  *
@@ -192,12 +214,13 @@ export interface AgentAdapter {
   canHandle(processInfo: ProcessInfo): boolean;
 
   /**
-   * Read the full conversation from a session file
+   * Read the conversation from a session file
    * @param sessionFilePath Path to the session JSONL file
    * @param options.verbose Include tool call/result details
+   * @param options.tail Return only the last N messages (see {@link ConversationOptions.tail})
    * @returns Array of conversation messages
    */
-  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[];
+  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[];
 
   /**
    * Enumerate historical sessions for this tool from disk.
@@ -214,7 +237,7 @@ export interface AgentAdapter {
   /**
    * Resolve exact historical session matches without enumerating every summary.
    *
-   * Built-in adapters implement this using their provider-native storage shape.
+   * Built-in adapters implement this using their harness-native storage shape.
    * The method remains optional so external adapters can fall back to
    * {@link listSessions} until they adopt direct lookup.
    */

package/src/capacity/index.ts

@@ -1,14 +1,25 @@
 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 { codexUnavailableReport, probeCodexCapacity } from "./sources/codex.js";
+import { probeClaudeCapacity, type ClaudeCapacityOptions } from "./sources/claude.js";
+import {
+  probeOpenAiCapacity,
+  probePiAnthropicCapacity,
+  probeZaiCapacity,
+  type PiAnthropicCapacityOptions,
+  type PiOpenAiCapacityOptions,
+  type PiZaiCapacityOptions,
+} from "./sources/pi.js";
 import type { CapacityReport } from "./types.js";
 
 export type { CapacityReport, CapacityWindow } from "./types.js";
-export type { ClaudeCapacityOptions } from "./claude.js";
+export type { ClaudeCapacityOptions } from "./sources/claude.js";
+export type { PiAnthropicCapacityOptions as AnthropicCapacityOptions } from "./sources/pi.js";
+export type {
+  PiOpenAiCapacityOptions as OpenAiCapacityOptions,
+  PiZaiCapacityOptions as ZaiCapacityOptions,
+} from "./sources/pi.js";
 
 export type CapacityProbeOptions = {
   now?: () => Date;
@@ -17,22 +28,6 @@ export type CapacityProbeOptions = {
   probe?: typeof probeCodexCapacity;
 };
 
-export type ZaiCapacityOptions = {
-  now?: () => Date;
-  env?: NodeJS.ProcessEnv;
-  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
-  fetch?: typeof globalThis.fetch;
-  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);
@@ -78,7 +73,7 @@ export async function getCodexCapacityReport(
 }
 
 export async function getZaiCapacityReport(
-  options: ZaiCapacityOptions = {},
+  options: PiZaiCapacityOptions = {},
 ): Promise<CapacityReport> {
   const { now, ...probeOptions } = options;
   return probeZaiCapacity({
@@ -88,7 +83,7 @@ export async function getZaiCapacityReport(
 }
 
 export async function getOpenAiCapacityReport(
-  options: OpenAiCapacityOptions = {},
+  options: PiOpenAiCapacityOptions = {},
 ): Promise<CapacityReport> {
   const { now, ...probeOptions } = options;
   return probeOpenAiCapacity({
@@ -107,3 +102,14 @@ export async function getClaudeCapacityReport(
     now,
   });
 }
+
+export async function getAnthropicCapacityReport(
+  options: PiAnthropicCapacityOptions = {},
+): Promise<CapacityReport> {
+  const { now, ...probeOptions } = options;
+  return probePiAnthropicCapacity({
+    ...probeOptions,
+    checkedAt: (now?.() ?? new Date()).toISOString(),
+    now,
+  });
+}

package/src/capacity/providers/anthropic.ts

@@ -0,0 +1,198 @@
+import type { Availability, CapacityWindow, ProviderCapacitySnapshot } from "../types.js";
+
+const SESSION_DURATION_MINUTES = 5 * 60;
+const WEEK_DURATION_MINUTES = 7 * 24 * 60;
+const ANTHROPIC_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+
+export type AnthropicCapacityRequestOptions = {
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+  now?: () => Date;
+};
+
+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 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 parseAnthropicCapacity(raw: unknown): ProviderCapacitySnapshot {
+  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 {
+    authenticated: true,
+    available: availability(windows),
+    windows,
+    creditsRemaining: null,
+  };
+}
+
+export async function fetchAnthropicCapacity(
+  token: string,
+  options: AnthropicCapacityRequestOptions = {},
+): Promise<ProviderCapacitySnapshot> {
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(ANTHROPIC_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: AbortSignal.timeout(options.timeoutMs ?? 5000),
+    });
+  } catch {
+    throw new Error("Claude OAuth usage request failed");
+  }
+  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 parseAnthropicCapacity(raw);
+}

package/src/capacity/providers/openai-platform.ts

@@ -0,0 +1,150 @@
+import type { CapacityWindow, ProviderCapacitySnapshot } from "../types.js";
+
+const OPENAI_USAGE_BASE_URL = "https://api.openai.com/v1/organization/usage";
+const OPENAI_MODELS_URL = "https://api.openai.com/v1/models";
+const OPENAI_USAGE_ENDPOINTS = ["completions", "responses"] as const;
+const USAGE_WINDOW_DAYS = 7;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+export type OpenAiUsageBucket = { startMs: number; tokens: number };
+export type OpenAiPlatformCapacityOptions = {
+  checkedAt: string;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+type UnknownRecord = Record<string, unknown>;
+
+function record(value: unknown): UnknownRecord | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as UnknownRecord)
+    : null;
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function bucketTokens(value: unknown): number {
+  const results = Array.isArray(value) ? value : [];
+  return results.reduce(
+    (total, entry) =>
+      total +
+      (finiteNumber(record(entry)?.input_tokens) ?? 0) +
+      (finiteNumber(record(entry)?.output_tokens) ?? 0),
+    0,
+  );
+}
+
+export function parseOpenAiUsage(raw: unknown): OpenAiUsageBucket[] {
+  const data = record(raw)?.data;
+  if (!Array.isArray(data)) throw new Error("Invalid OpenAI usage response");
+  const buckets: OpenAiUsageBucket[] = [];
+  for (const entry of data) {
+    const seconds = finiteNumber(record(entry)?.aggregation_timestamp);
+    if (seconds === null) continue;
+    buckets.push({ startMs: seconds * 1000, tokens: bucketTokens(record(entry)?.results) });
+  }
+  return buckets;
+}
+
+function emptySnapshot(authenticated: boolean): ProviderCapacitySnapshot {
+  return {
+    authenticated,
+    available: "unknown",
+    windows: [],
+    creditsRemaining: null,
+  };
+}
+
+export function buildOpenAiPlatformCapacity(
+  buckets: OpenAiUsageBucket[],
+  checkedAt: string,
+): ProviderCapacitySnapshot {
+  const nowMs = Date.parse(checkedAt);
+  const todayStartMs = Math.floor(nowMs / DAY_MS) * DAY_MS;
+  const weekStartMs = todayStartMs - (USAGE_WINDOW_DAYS - 1) * DAY_MS;
+  let todayTokens = 0;
+  let weekTokens = 0;
+  for (const bucket of buckets) {
+    if (bucket.startMs === todayStartMs) todayTokens += bucket.tokens;
+    if (bucket.startMs >= weekStartMs) weekTokens += bucket.tokens;
+  }
+  const windows: CapacityWindow[] = [
+    {
+      id: "openai:tokens:today",
+      label: "Tokens · today (UTC)",
+      limitType: "TOKENS_LIMIT",
+      durationMinutes: 24 * 60,
+      usedPercent: null,
+      resetsAt: new Date(todayStartMs + DAY_MS).toISOString(),
+      total: null,
+      current: todayTokens,
+      remaining: null,
+    },
+    {
+      id: "openai:tokens:week",
+      label: "Tokens · 7 days",
+      limitType: "TOKENS_LIMIT",
+      durationMinutes: USAGE_WINDOW_DAYS * 24 * 60,
+      usedPercent: null,
+      resetsAt: null,
+      total: null,
+      current: weekTokens,
+      remaining: null,
+    },
+  ];
+  return {
+    authenticated: true,
+    available: "yes",
+    windows,
+    creditsRemaining: null,
+  };
+}
+
+async function request(
+  url: string,
+  key: string,
+  options: OpenAiPlatformCapacityOptions,
+): Promise<Response> {
+  try {
+    return await (options.fetch ?? globalThis.fetch)(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+    });
+  } catch {
+    throw new Error("OpenAI usage request failed");
+  }
+}
+
+async function verifyKey(key: string, options: OpenAiPlatformCapacityOptions): Promise<boolean> {
+  const response = await request(OPENAI_MODELS_URL, key, options);
+  return response.status !== 401;
+}
+
+export async function fetchOpenAiPlatformCapacity(
+  key: string,
+  options: OpenAiPlatformCapacityOptions,
+): Promise<ProviderCapacitySnapshot> {
+  const endSeconds = Math.floor(Date.parse(options.checkedAt) / 1000);
+  const startSeconds = endSeconds - USAGE_WINDOW_DAYS * 24 * 60 * 60;
+  const query = `start_time=${startSeconds}&end_time=${endSeconds}`;
+  const payloads: unknown[] = [];
+
+  for (const endpoint of OPENAI_USAGE_ENDPOINTS) {
+    const response = await request(`${OPENAI_USAGE_BASE_URL}/${endpoint}?${query}`, key, options);
+    if (response.status === 401) return emptySnapshot(false);
+    if (response.status === 403) return emptySnapshot(await verifyKey(key, options));
+    if (response.status !== 200) {
+      throw new Error(`OpenAI usage request failed: HTTP ${response.status}`);
+    }
+    try {
+      payloads.push(await response.json());
+    } catch {
+      throw new Error("OpenAI usage response is not valid JSON");
+    }
+  }
+
+  return buildOpenAiPlatformCapacity(payloads.flatMap(parseOpenAiUsage), options.checkedAt);
+}

package/src/capacity/providers/openai-subscription.ts

@@ -0,0 +1,162 @@
+import type { CapacityWindow, ProviderCapacitySnapshot } from "../types.js";
+
+const WHAM_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const OPENAI_WHOAMI_URL = "https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami";
+
+export type OpenAiSubscriptionCredential = {
+  access: string;
+  accountId: string;
+};
+
+export type OpenAiSubscriptionCapacityOptions = {
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+export type WhamUsageSnapshot = {
+  windows: CapacityWindow[];
+  creditsRemaining: number | null;
+};
+
+type UnknownRecord = Record<string, unknown>;
+
+function record(value: unknown): UnknownRecord | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as UnknownRecord)
+    : null;
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function nonEmptyText(value: unknown): string | null {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+export 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;
+}
+
+export 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 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 parseWhamUsage(raw: unknown): WhamUsageSnapshot {
+  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),
+  };
+}
+
+export async function fetchOpenAiSubscriptionCapacity(
+  credential: OpenAiSubscriptionCredential,
+  options: OpenAiSubscriptionCapacityOptions = {},
+): Promise<ProviderCapacitySnapshot> {
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(WHAM_USAGE_URL, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${credential.access}`,
+        "ChatGPT-Account-Id": credential.accountId,
+      },
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+    });
+  } catch {
+    throw new Error("OpenAI usage request failed");
+  }
+  if (response.status === 401 || response.status === 403) {
+    return {
+      authenticated: false,
+      available: "unknown",
+      windows: [],
+      creditsRemaining: null,
+    };
+  }
+  if (response.status !== 200) {
+    throw new Error(`OpenAI usage request failed: HTTP ${response.status}`);
+  }
+  let raw: unknown;
+  try {
+    raw = await response.json();
+  } catch {
+    throw new Error("OpenAI usage response is not valid JSON");
+  }
+  const snapshot = parseWhamUsage(raw);
+  const hasUsage = snapshot.windows.some((window) => window.usedPercent !== null);
+  return {
+    authenticated: true,
+    available: hasUsage ? "yes" : "unknown",
+    windows: snapshot.windows,
+    creditsRemaining: snapshot.creditsRemaining,
+  };
+}
+
+export async function fetchOpenAiPatAccountId(
+  token: string,
+  options: OpenAiSubscriptionCapacityOptions = {},
+): Promise<string> {
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(OPENAI_WHOAMI_URL, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+    });
+  } catch {
+    throw new Error("OpenAI account request failed");
+  }
+  if (!response.ok) throw new Error("OpenAI account request failed");
+  let raw: unknown;
+  try {
+    raw = await response.json();
+  } catch {
+    throw new Error("OpenAI account response is not valid JSON");
+  }
+  const accountId = nonEmptyText(record(raw)?.chatgpt_account_id);
+  if (!accountId) throw new Error("OpenAI account unavailable");
+  return accountId;
+}