@ai-devkit/agent-manager 0.37.0 → 0.39.0

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/{claude.ts → providers/anthropic.ts}

@@ -1,34 +1,15 @@
-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";
+import type { Availability, CapacityWindow, ProviderCapacitySnapshot } from "../types.js";
 
-const execFileAsync = promisify(execFile);
+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 ClaudeCapacityOptions = {
-  env?: NodeJS.ProcessEnv;
-  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+export type AnthropicCapacityRequestOptions = {
   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>)
@@ -45,91 +26,6 @@ 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);
@@ -173,9 +69,7 @@ function scopedWindows(value: unknown): CapacityWindow[] {
       continue;
     }
     const modelSlug = slug(identity);
-    if (!modelSlug || modelSlug === "all-models" || modelSlug.endsWith("-all-models")) {
-      continue;
-    }
+    if (!modelSlug || modelSlug === "all-models" || modelSlug.endsWith("-all-models")) continue;
     const id = `claude:weekly:${modelSlug}`;
     if (seen.has(id)) continue;
     seen.add(id);
@@ -237,7 +131,7 @@ function retryAfterTime(response: Response, now: Date): string | null {
   return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
 }
 
-export function parseClaudeUsage(raw: unknown, checkedAt: string): CapacityReport {
+export function parseAnthropicCapacity(raw: unknown): ProviderCapacitySnapshot {
   const input = record(raw);
   if (!input) throw new Error("Claude usage response is malformed");
   const windows = [
@@ -254,9 +148,6 @@ export function parseClaudeUsage(raw: unknown, checkedAt: string): CapacityRepor
     extraUsageWindow(input.extra_usage),
   ].filter((window): window is CapacityWindow => window !== null);
   return {
-    harness: "claude",
-    provider: "anthropic",
-    generatedAt: checkedAt,
     authenticated: true,
     available: availability(windows),
     windows,
@@ -264,13 +155,13 @@ export function parseClaudeUsage(raw: unknown, checkedAt: string): CapacityRepor
   };
 }
 
-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);
+export async function fetchAnthropicCapacity(
+  token: string,
+  options: AnthropicCapacityRequestOptions = {},
+): Promise<ProviderCapacitySnapshot> {
   let response: Response;
   try {
-    response = await (options.fetch ?? globalThis.fetch)(CLAUDE_USAGE_URL, {
+    response = await (options.fetch ?? globalThis.fetch)(ANTHROPIC_USAGE_URL, {
       method: "GET",
       headers: {
         Accept: "application/json",
@@ -279,19 +170,13 @@ export async function probeClaudeCapacity(options: ClaudeProbeOptions): Promise<
         "User-Agent": "claude-code/2.1.0",
         "anthropic-beta": "oauth-2025-04-20",
       },
-      signal: controller.signal,
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
     });
   } 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 === 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(
@@ -309,5 +194,5 @@ export async function probeClaudeCapacity(options: ClaudeProbeOptions): Promise<
   } catch {
     throw new Error("Claude usage response is malformed");
   }
-  return parseClaudeUsage(raw, options.checkedAt);
+  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/{wham.ts → providers/openai-subscription.ts}

@@ -1,6 +1,19 @@
-import type { CapacityWindow } from "./types.js";
+import type { CapacityWindow, ProviderCapacitySnapshot } from "../types.js";
 
-type WhamUsageSnapshot = {
+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;
 };
@@ -24,8 +37,9 @@ function nonEmptyText(value: unknown): string | 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)))
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
     return new Date(value).toISOString();
+  }
   return null;
 }
 
@@ -64,11 +78,6 @@ function extraWindows(value: unknown): CapacityWindow[] {
   });
 }
 
-/**
- * Parses the chatgpt.com backend wham/usage payload shared by every
- * OAuth-backed OpenAI consumer (codex harness and pi login) into generic
- * capacity windows plus the credit balance.
- */
 export function parseWhamUsage(raw: unknown): WhamUsageSnapshot {
   const response = record(raw) ?? {};
   const limits = record(response.rate_limit) ?? {};
@@ -82,3 +91,72 @@ export function parseWhamUsage(raw: unknown): WhamUsageSnapshot {
     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;
+}