@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/capacity/providers/zai.ts

@@ -0,0 +1,155 @@
+import type {
+  Availability,
+  CapacityLimitType,
+  CapacityWindow,
+  ProviderCapacitySnapshot,
+} from "../types.js";
+
+const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+const LIMIT_METADATA = {
+  TOKENS_LIMIT: { id: "tokens", label: "Tokens" },
+  CREDIT_LIMIT: { id: "credit", label: "Credit" },
+  TIME_LIMIT: { id: "time", label: "Time" },
+} as const satisfies Record<CapacityLimitType, { id: string; label: string }>;
+const UNIT_METADATA = new Map<number, { minutes: number; label: string }>([
+  [1, { minutes: 24 * 60, label: "day" }],
+  [3, { minutes: 60, label: "hour" }],
+  [5, { minutes: 1, label: "minute" }],
+  [6, { minutes: 7 * 24 * 60, label: "week" }],
+]);
+type UnknownRecord = Record<string, unknown>;
+
+export type ZaiRequestOptions = {
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+function record(value: unknown): UnknownRecord | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as UnknownRecord)
+    : null;
+}
+
+function optionalNumber(value: unknown, field: string): number | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid z.ai quota ${field}`);
+  }
+  return value;
+}
+
+function integer(value: unknown): number | null {
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+
+function isCapacityLimitType(value: string): value is CapacityLimitType {
+  return Object.hasOwn(LIMIT_METADATA, value);
+}
+
+function durationMinutes(unit: number, count: number, type: CapacityLimitType): number | null {
+  if (type === "TIME_LIMIT" && unit === 5 && count === 1) return 30 * 24 * 60;
+  const metadata = UNIT_METADATA.get(unit);
+  return metadata === undefined || count <= 0 ? null : metadata.minutes * count;
+}
+
+function windowLabel(type: CapacityLimitType, unit: number, count: number): string {
+  if (type === "TIME_LIMIT" && unit === 5 && count === 1) return "MCP · monthly";
+  const kind = LIMIT_METADATA[type].label;
+  const unitLabel = UNIT_METADATA.get(unit)?.label;
+  if (!unitLabel) return kind;
+  return `${kind} · ${count} ${unitLabel}${count === 1 ? "" : "s"}`;
+}
+
+function resetTime(value: unknown): string | null {
+  const milliseconds = optionalNumber(value, "limit nextResetTime");
+  if (milliseconds === null) return null;
+  const date = new Date(milliseconds);
+  if (Number.isNaN(date.getTime())) throw new Error("Invalid z.ai quota limit nextResetTime");
+  return date.toISOString();
+}
+
+function availability(windows: CapacityWindow[]): Availability {
+  if (windows.length === 0) return "unknown";
+  return windows.some((window) => window.usedPercent !== null && window.usedPercent < 100)
+    ? "yes"
+    : "no";
+}
+
+function parseLimit(value: unknown, index: number): CapacityWindow | null {
+  const limit = record(value);
+  if (!limit) throw new Error("Invalid z.ai quota limit entry");
+  const unit = integer(limit.unit);
+  const count = integer(limit.number);
+  if (typeof limit.type !== "string" || unit === null || count === null) {
+    throw new Error("Invalid z.ai quota limit entry");
+  }
+  const serverPercent = optionalNumber(limit.percentage, "limit percentage");
+  if (serverPercent === null) throw new Error("Invalid z.ai quota limit percentage");
+  if (!isCapacityLimitType(limit.type)) return null;
+
+  const total = optionalNumber(limit.usage, "limit usage");
+  const current = optionalNumber(limit.currentValue, "limit currentValue");
+  const remaining = optionalNumber(limit.remaining, "limit remaining");
+  let consumed = total !== null && remaining !== null ? total - remaining : null;
+  if (current !== null) consumed = Math.max(consumed ?? current, current);
+  let usedPercent = serverPercent;
+  if (total !== null && total > 0 && consumed !== null) {
+    usedPercent = (consumed / total) * 100;
+  }
+  const metadata = LIMIT_METADATA[limit.type];
+  return {
+    id: `zai:${metadata.id}:${index + 1}`,
+    label: windowLabel(limit.type, unit, count),
+    limitType: limit.type,
+    durationMinutes: durationMinutes(unit, count, limit.type),
+    usedPercent: Math.max(0, Math.min(100, usedPercent)),
+    resetsAt: resetTime(limit.nextResetTime),
+    total,
+    current,
+    remaining,
+  };
+}
+
+export function parseZaiCapacity(raw: unknown): ProviderCapacitySnapshot {
+  const root = record(raw);
+  const data = record(root?.data);
+  if (root?.success !== true || root.code !== 200 || !data || !Array.isArray(data.limits)) {
+    throw new Error("Invalid z.ai quota response");
+  }
+  const windows = data.limits
+    .map(parseLimit)
+    .filter((window): window is CapacityWindow => window !== null);
+  return {
+    authenticated: true,
+    available: availability(windows),
+    windows,
+    creditsRemaining: null,
+  };
+}
+
+export async function fetchZaiCapacity(
+  key: string,
+  options: ZaiRequestOptions = {},
+): Promise<ProviderCapacitySnapshot> {
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(ZAI_QUOTA_URL, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+    });
+  } catch {
+    throw new Error("z.ai quota request failed");
+  }
+  if (response.status !== 200) {
+    throw new Error(`z.ai quota request failed: HTTP ${response.status}`);
+  }
+  try {
+    return parseZaiCapacity(await response.json());
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("z.ai quota response is not valid JSON");
+    }
+    throw error;
+  }
+}

package/src/capacity/sources/claude.ts

@@ -0,0 +1,30 @@
+import {
+  fetchAnthropicCapacity,
+  type AnthropicCapacityRequestOptions,
+} from "../providers/anthropic.js";
+import type { CapacityReport, ProviderCapacitySnapshot } from "../types.js";
+import {
+  resolveClaudeAnthropicToken,
+  type ClaudeCredentialOptions,
+} from "../../harnesses/claude/credentials.js";
+
+export type ClaudeCapacityOptions = ClaudeCredentialOptions & AnthropicCapacityRequestOptions;
+
+export type ClaudeProbeOptions = ClaudeCapacityOptions & {
+  checkedAt: string;
+};
+
+function claudeReport(snapshot: ProviderCapacitySnapshot, checkedAt: string): CapacityReport {
+  return {
+    harness: "claude",
+    provider: "anthropic",
+    generatedAt: checkedAt,
+    ...snapshot,
+  };
+}
+
+export async function probeClaudeCapacity(options: ClaudeProbeOptions): Promise<CapacityReport> {
+  const token = await resolveClaudeAnthropicToken(options);
+  const snapshot = await fetchAnthropicCapacity(token, options);
+  return claudeReport(snapshot, options.checkedAt);
+}

package/src/capacity/sources/codex.ts

@@ -0,0 +1,262 @@
+import { spawn } from "node:child_process";
+import {
+  fetchOpenAiPatAccountId,
+  fetchOpenAiSubscriptionCapacity,
+  parseWhamUsage,
+  resetTime,
+  safeIdentifier,
+} from "../providers/openai-subscription.js";
+import type { CapacityReport, CapacityWindow } from "../types.js";
+import {
+  resolveCodexCredentials,
+  type CodexCredentialOptions,
+} from "../../harnesses/codex/credentials.js";
+
+type CodexUsageSource = "pat" | "oauth" | "cli";
+type UsageSnapshot = {
+  windows: CapacityWindow[];
+  creditsRemaining: number | null;
+  source: CodexUsageSource;
+};
+
+type UnknownRecord = Record<string, unknown>;
+type RpcMessage = { id?: number; method: string; params?: UnknownRecord };
+type CliResponses = { rateLimits: unknown; account: unknown };
+type CodexRpc = (messages: RpcMessage[]) => Promise<CliResponses>;
+
+export type CodexProbeOptions = CodexCredentialOptions & {
+  installed: boolean;
+  checkedAt: string;
+  fetch?: typeof globalThis.fetch;
+  rpc?: CodexRpc;
+  timeoutMs?: number;
+};
+
+export const CODEX_APP_SERVER_ARGS = ["-s", "read-only", "-a", "untrusted", "app-server"] as const;
+
+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 parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot {
+  const { windows, creditsRemaining } = parseWhamUsage(raw);
+  return { windows, creditsRemaining, source };
+}
+
+function cliWindow(value: unknown, id: string, label: string): CapacityWindow | null {
+  const input = record(value);
+  if (!input) return null;
+  return {
+    id,
+    label,
+    durationMinutes: finiteNumber(input.windowDurationMins),
+    usedPercent: finiteNumber(input.usedPercent),
+    resetsAt: resetTime(input.resetsAt),
+  };
+}
+
+function cliSnapshotWindows(value: unknown, fallbackId: string): CapacityWindow[] {
+  const snapshot = record(value);
+  if (!snapshot) return [];
+  const scope = safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
+  return [
+    cliWindow(snapshot.primary, `${scope}:primary`, `${scope} primary`),
+    cliWindow(snapshot.secondary, `${scope}:secondary`, `${scope} secondary`),
+  ].filter((item): item is CapacityWindow => item !== null);
+}
+
+function parseCliUsage(raw: unknown): UsageSnapshot {
+  const response = record(raw) ?? {};
+  const primary = record(response.rateLimits);
+  const windows = primary ? cliSnapshotWindows(primary, "codex") : [];
+  const buckets = record(response.rateLimitsByLimitId);
+  if (buckets) {
+    for (const [id, snapshot] of Object.entries(buckets)) {
+      windows.push(...cliSnapshotWindows(snapshot, id));
+    }
+  }
+  const unique = [...new Map(windows.map((window) => [window.id, window])).values()];
+  return { windows: unique, creditsRemaining: null, source: "cli" };
+}
+
+function capacityFromSnapshot(
+  snapshot: UsageSnapshot,
+  options: CodexProbeOptions,
+  raw?: unknown,
+): CapacityReport {
+  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);
+  return {
+    harness: "codex",
+    provider: "openai",
+    generatedAt: options.checkedAt,
+    authenticated: true,
+    available: reached ? "no" : hasUsage ? "yes" : "unknown",
+    windows: snapshot.windows,
+    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
+  };
+}
+
+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"] });
+    const results: Partial<CliResponses> = {};
+    let buffer = "";
+    let settled = false;
+    const finish = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill();
+      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")));
+    child.once("exit", () => {
+      if (!settled) finish(new Error("codex app-server exited"));
+    });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      buffer += chunk;
+      for (;;) {
+        const newline = buffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        let message: UnknownRecord;
+        try {
+          message = JSON.parse(line) as UnknownRecord;
+        } catch {
+          continue;
+        }
+        if (message.id === 1) {
+          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"));
+          else results.rateLimits = message.result;
+        } else if (message.id === 3) {
+          if (message.error) finish(new Error("codex account method failed"));
+          else results.account = message.result;
+        }
+        if ("rateLimits" in results && "account" in results) finish();
+      }
+    });
+    child.stdin.write(`${JSON.stringify(messages[0])}\n`);
+  });
+}
+
+export function codexUnavailableReport(checkedAt: string): CapacityReport {
+  return {
+    harness: "codex",
+    provider: "openai",
+    generatedAt: checkedAt,
+    authenticated: null,
+    available: "unknown",
+    windows: [],
+    creditsRemaining: null,
+  };
+}
+
+async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport> {
+  if (!options.installed) return codexUnavailableReport(options.checkedAt);
+  const messages: RpcMessage[] = [
+    {
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: { name: "ai-devkit", title: null, version: "1" },
+        capabilities: null,
+      },
+    },
+    { method: "initialized" },
+    { id: 2, method: "account/rateLimits/read" },
+    { id: 3, method: "account/read" },
+  ];
+  try {
+    const rpc = options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
+    const response = await rpc(messages);
+    const result = capacityFromSnapshot(
+      parseCliUsage(response.rateLimits),
+      options,
+      response.rateLimits,
+    );
+    const accountEnvelope = record(response.account);
+    if (
+      accountEnvelope &&
+      Object.hasOwn(accountEnvelope, "account") &&
+      !record(accountEnvelope.account)
+    ) {
+      result.authenticated = false;
+      result.available = "unknown";
+    }
+    return result;
+  } catch {
+    return codexUnavailableReport(options.checkedAt);
+  }
+}
+
+async function subscriptionSnapshot(
+  access: string,
+  accountId: string,
+  source: "pat" | "oauth",
+  options: CodexProbeOptions,
+): Promise<UsageSnapshot> {
+  const snapshot = await fetchOpenAiSubscriptionCapacity({ access, accountId }, options);
+  if (snapshot.authenticated === false) throw new Error("unauthorized");
+  return {
+    windows: snapshot.windows,
+    creditsRemaining: snapshot.creditsRemaining,
+    source,
+  };
+}
+
+export async function probeCodexCapacity(options: CodexProbeOptions): Promise<CapacityReport> {
+  const credentials = await resolveCodexCredentials(options);
+  if (!credentials) return cliFallback(options);
+
+  if (credentials.personalAccessToken) {
+    try {
+      const accountId = await fetchOpenAiPatAccountId(credentials.personalAccessToken, options);
+      const snapshot = await subscriptionSnapshot(
+        credentials.personalAccessToken,
+        accountId,
+        "pat",
+        options,
+      );
+      return capacityFromSnapshot(snapshot, options);
+    } catch {
+      // Continue to a separately available OAuth credential before using the CLI.
+    }
+  }
+
+  if (credentials.oauth) {
+    try {
+      const snapshot = await subscriptionSnapshot(
+        credentials.oauth.access,
+        credentials.oauth.accountId,
+        "oauth",
+        options,
+      );
+      return capacityFromSnapshot(snapshot, options);
+    } catch {
+      return cliFallback(options);
+    }
+  }
+  return cliFallback(options);
+}

package/src/capacity/sources/pi.ts

@@ -0,0 +1,131 @@
+import { fetchAnthropicCapacity } from "../providers/anthropic.js";
+import { fetchOpenAiPlatformCapacity } from "../providers/openai-platform.js";
+import { fetchOpenAiSubscriptionCapacity } from "../providers/openai-subscription.js";
+import { fetchZaiCapacity } from "../providers/zai.js";
+import type { CapacityReport, ProviderCapacitySnapshot } from "../types.js";
+import {
+  resolvePiAnthropicCredential,
+  resolvePiOpenAiCredential,
+  resolvePiZaiApiKey,
+  type PiCredentialOptions,
+  type PiOpenAiCredential,
+} from "../../harnesses/pi/credentials.js";
+
+export type PiAnthropicCapacityOptions = PiCredentialOptions & {
+  now?: () => Date;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+export type PiAnthropicProbeOptions = PiAnthropicCapacityOptions & {
+  checkedAt: string;
+};
+
+export type PiOpenAiCapacityOptions = PiCredentialOptions & {
+  now?: () => Date;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+export type PiOpenAiProbeOptions = PiOpenAiCapacityOptions & {
+  checkedAt: string;
+};
+
+export type PiZaiCapacityOptions = PiCredentialOptions & {
+  now?: () => Date;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+};
+
+export type PiZaiProbeOptions = PiZaiCapacityOptions & {
+  checkedAt: string;
+};
+
+export async function probePiAnthropicCapacity(
+  options: PiAnthropicProbeOptions,
+): Promise<CapacityReport> {
+  const credential = await resolvePiAnthropicCredential(options);
+  const now = options.now?.() ?? new Date();
+  if (credential.expiresMs !== null && credential.expiresMs <= now.getTime()) {
+    return {
+      harness: "pi",
+      provider: "anthropic",
+      generatedAt: options.checkedAt,
+      authenticated: true,
+      available: "unknown",
+      windows: [],
+      creditsRemaining: null,
+    };
+  }
+  const snapshot = await fetchAnthropicCapacity(credential.access, options);
+  return {
+    harness: "pi",
+    provider: "anthropic",
+    generatedAt: options.checkedAt,
+    ...snapshot,
+  };
+}
+
+function piOpenAiReport(snapshot: ProviderCapacitySnapshot, checkedAt: string): CapacityReport {
+  return {
+    harness: "pi",
+    provider: "openai",
+    generatedAt: checkedAt,
+    ...snapshot,
+  };
+}
+
+function jwtExpiryMs(token: string): number | null {
+  const part = token.split(".")[1];
+  if (!part) return null;
+  try {
+    const payload = JSON.parse(Buffer.from(part, "base64url").toString("utf8")) as unknown;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
+    const exp = (payload as Record<string, unknown>).exp;
+    return typeof exp === "number" && Number.isFinite(exp) ? exp * 1000 : null;
+  } catch {
+    return null;
+  }
+}
+
+function oauthExpired(
+  credential: Extract<PiOpenAiCredential, { kind: "oauth" }>,
+  nowMs: number,
+): boolean {
+  const expiryMs = credential.expiresMs ?? jwtExpiryMs(credential.access);
+  return expiryMs !== null && expiryMs <= nowMs;
+}
+
+export async function probeOpenAiCapacity(options: PiOpenAiProbeOptions): Promise<CapacityReport> {
+  const credential = await resolvePiOpenAiCredential(options);
+  if (credential.kind === "platform") {
+    const snapshot = await fetchOpenAiPlatformCapacity(credential.key, options);
+    return piOpenAiReport(snapshot, options.checkedAt);
+  }
+
+  const nowMs = Date.parse(options.checkedAt);
+  if (Number.isNaN(nowMs) || oauthExpired(credential, nowMs)) {
+    return piOpenAiReport(
+      {
+        authenticated: true,
+        available: "unknown",
+        windows: [],
+        creditsRemaining: null,
+      },
+      options.checkedAt,
+    );
+  }
+  const snapshot = await fetchOpenAiSubscriptionCapacity(credential, options);
+  return piOpenAiReport(snapshot, options.checkedAt);
+}
+
+export async function probeZaiCapacity(options: PiZaiProbeOptions): Promise<CapacityReport> {
+  const key = await resolvePiZaiApiKey(options);
+  const snapshot = await fetchZaiCapacity(key, options);
+  return {
+    harness: "pi",
+    provider: "zai",
+    generatedAt: options.checkedAt,
+    ...snapshot,
+  };
+}

package/src/capacity/types.ts

@@ -24,3 +24,6 @@ export interface CapacityReport {
   windows: CapacityWindow[];
   creditsRemaining: number | null;
 }
+
+/** Provider quota data before a harness/source identity is attached. */
+export type ProviderCapacitySnapshot = Omit<CapacityReport, "harness" | "provider" | "generatedAt">;

package/src/harnesses/antigravity/AntigravityAgentMapper.ts

@@ -0,0 +1,34 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import { processOnlyAgent } from "../shared.js";
+import { AntigravitySessionParser, type AntigravitySession } from "./AntigravitySessionParser.js";
+
+export interface AntigravitySessionAgentInput {
+  session: AntigravitySession;
+  processInfo: ProcessInfo;
+}
+
+export class AntigravityAgentMapper {
+  constructor(private readonly parser: AntigravitySessionParser = new AntigravitySessionParser()) {}
+
+  mapSessionToAgent({ session, processInfo }: AntigravitySessionAgentInput): AgentInfo {
+    return {
+      name: generateAgentName(session.projectPath, processInfo.pid),
+      type: "antigravity_cli",
+      status: this.parser.determineStatus(session),
+      summary: session.lastUserMessage || "Antigravity CLI session active",
+      pid: processInfo.pid,
+      projectPath: session.projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: session.sessionFilePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo, cwd: string): AgentInfo {
+    return processOnlyAgent("antigravity_cli", processInfo, {
+      summary: "Antigravity CLI process running",
+      cwd,
+    });
+  }
+}