@ai-devkit/agent-manager 0.33.0 → 0.34.0

package/src/__tests__/utils/AgentRegistry.test.ts

@@ -92,24 +92,34 @@ describe("AgentRegistry", () => {
       });
     });
 
-    it("lets a Herdr managed start replace an existing same-pid name", () => {
+    it("preserves existing identity and routing fields for same-pid refreshes", () => {
       const runtimeRef = { session: "default", paneId: "w1:p2", agentName: "requested-name" };
 
-      registry.register(makeEntry({ name: "old-name", pid: process.pid }));
+      registry.register(
+        makeEntry({
+          name: "old-name",
+          pid: process.pid,
+          runtime: "tmux",
+          runtimeRef: { session: "old-name" },
+          cwd: "/original",
+        }),
+      );
       registry.register(
         makeEntry({
           name: "requested-name",
           pid: process.pid,
           runtime: "herdr",
           runtimeRef,
+          cwd: "/incoming",
         }),
       );
 
-      expect(registry.lookup("old-name")).toBeNull();
-      expect(registry.lookup("requested-name")).toMatchObject({
+      expect(registry.lookup("requested-name")).toBeNull();
+      expect(registry.lookup("old-name")).toMatchObject({
         pid: process.pid,
-        runtime: "herdr",
-        runtimeRef,
+        runtime: "tmux",
+        runtimeRef: { session: "old-name" },
+        cwd: "/original",
       });
     });
 
@@ -127,11 +137,11 @@ describe("AgentRegistry", () => {
       expect(registry.lookup("a")?.runtimeRef).toBeNull();
     });
 
-    it("lets a managed start entry replace a generated fallback for the same pid", () => {
+    it("preserves an existing generated fallback for the same pid", () => {
       registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, runtimeRef: null }));
       registry.register(makeEntry({ name: "custom-name", runtimeRef: { session: "custom-name" } }));
-      expect(registry.lookup("custom-name")?.runtimeRef).toEqual({ session: "custom-name" });
-      expect(registry.lookup(`ai-devkit-${process.pid}`)).toBeNull();
+      expect(registry.lookup("custom-name")).toBeNull();
+      expect(registry.lookup(`ai-devkit-${process.pid}`)?.runtimeRef).toBeNull();
       expect(registry.list()).toHaveLength(1);
     });
 
@@ -186,7 +196,7 @@ describe("AgentRegistry", () => {
       registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, runtimeRef: null }));
 
       expect(registry.list()).toHaveLength(1);
-      expect(registry.lookup("custom-name")?.pid).toBe(process.pid);
+      expect(registry.lookup(`ai-devkit-${process.pid}`)?.pid).toBe(process.pid);
     });
 
     it("cleans up a cross-type row when its pid has been reused", () => {

package/src/adapters/index.ts

@@ -1,9 +1,9 @@
 export { ClaudeCodeAdapter } from "../providers/claude/ClaudeCodeAdapter.js";
 export { CodexAdapter } from "../providers/codex/CodexAdapter.js";
-export { CopilotAdapter } from "./CopilotAdapter.js";
-export { GeminiCliAdapter } from "./GeminiCliAdapter.js";
+export { CopilotAdapter } from "../providers/copilot/CopilotAdapter.js";
+export { GeminiCliAdapter } from "../providers/gemini/GeminiCliAdapter.js";
 export { GrokCliAdapter } from "./GrokCliAdapter.js";
-export { OpenCodeAdapter } from "./OpenCodeAdapter.js";
+export { OpenCodeAdapter } from "../providers/opencode/OpenCodeAdapter.js";
 export { PiAdapter } from "../providers/pi/PiAdapter.js";
 export { AgentStatus } from "./AgentAdapter.js";
 export type {

package/src/capacity/codex.ts

@@ -15,7 +15,13 @@ 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;
@@ -57,12 +63,18 @@ function safeIdentifier(value: unknown): string | 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 {
+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);
@@ -84,13 +96,24 @@ function extraWindows(value: unknown): CapacityWindow[] {
     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`),
+      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 {
+export function parseUsage(
+  raw: unknown,
+  source: "pat" | "oauth",
+): UsageSnapshot {
   const response = record(raw) ?? {};
   const limits = record(response.rate_limit) ?? {};
   const credits = record(response.credits) ?? {};
@@ -105,7 +128,11 @@ export function parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot
   };
 }
 
-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 {
@@ -117,10 +144,14 @@ function cliWindow(value: unknown, id: string, label: string): CapacityWindow |
   };
 }
 
-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`),
@@ -136,7 +167,9 @@ 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" };
 }
 
@@ -145,18 +178,23 @@ 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 {
-    provider: "codex",
+    harness: "codex",
+    provider: "openai",
     generatedAt: context.checkedAt,
     authenticated: true,
     available: reached ? "no" : hasUsage ? "yes" : "unknown",
     windows: snapshot.windows,
-    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
+    creditsRemaining:
+      snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
   };
 }
 
@@ -164,7 +202,9 @@ 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;
   }
@@ -191,7 +231,10 @@ 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);
@@ -209,14 +252,20 @@ async function apiSnapshot(
     fetcher,
     "https://chatgpt.com/backend-api/wham/usage",
     {
-      headers: { Authorization: `Bearer ${token}`, "ChatGPT-Account-Id": accountId },
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "ChatGPT-Account-Id": accountId,
+      },
     },
     options.timeoutMs ?? 5000,
   );
   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"],
@@ -232,8 +281,13 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
       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"));
     });
@@ -256,7 +310,8 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
           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"));
@@ -269,10 +324,11 @@ function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResp
   });
 }
 
-function unavailable(options: CodexProbeOptions): CapacityReport {
+export function codexUnavailableReport(checkedAt: string): CapacityReport {
   return {
-    provider: "codex",
-    generatedAt: options.checkedAt,
+    harness: "codex",
+    provider: "openai",
+    generatedAt: checkedAt,
     authenticated: null,
     available: "unknown",
     windows: [],
@@ -280,7 +336,13 @@ function unavailable(options: CodexProbeOptions): CapacityReport {
   };
 }
 
-async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport> {
+function unavailable(options: CodexProbeOptions): CapacityReport {
+  return codexUnavailableReport(options.checkedAt);
+}
+
+async function cliFallback(
+  options: CodexProbeOptions,
+): Promise<CapacityReport> {
   if (!options.installed) return unavailable(options);
   const messages: RpcMessage[] = [
     {
@@ -296,7 +358,8 @@ async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport>
     { 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),
@@ -318,7 +381,9 @@ async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport>
   }
 }
 
-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)(
@@ -345,7 +410,10 @@ export async function probeCodexCapacity(options: CodexProbeOptions): Promise<Ca
       );
       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

@@ -1,7 +1,8 @@
 import { constants } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
 import path from "node:path";
-import { probeCodexCapacity } from "./codex.js";
+import { codexUnavailableReport, probeCodexCapacity } from "./codex.js";
+import { probeZaiCapacity } from "./zai.js";
 import type { CapacityReport } from "./types.js";
 
 export type { CapacityReport, CapacityWindow } from "./types.js";
@@ -13,6 +14,14 @@ 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;
+};
+
 async function canAccess(target: string, mode: number): Promise<boolean> {
   try {
     await fsAccess(target, mode);
@@ -46,17 +55,26 @@ 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, checkedAt: generatedAt });
+    return await (options.probe ?? probeCodexCapacity)({
+      installed,
+      checkedAt: generatedAt,
+    });
   } catch {
-    return {
-      provider: "codex",
-      generatedAt,
-      authenticated: null,
-      available: "unknown",
-      windows: [],
-      creditsRemaining: null,
-    };
+    return codexUnavailableReport(generatedAt);
   }
 }
+
+export async function getZaiCapacityReport(
+  options: ZaiCapacityOptions = {},
+): Promise<CapacityReport> {
+  const { now, ...probeOptions } = options;
+  return probeZaiCapacity({
+    ...probeOptions,
+    checkedAt: (now?.() ?? new Date()).toISOString(),
+  });
+}

package/src/capacity/types.ts

@@ -1,4 +1,5 @@
 export type Availability = "yes" | "no" | "unknown";
+export type CapacityLimitType = "TOKENS_LIMIT" | "CREDIT_LIMIT" | "TIME_LIMIT";
 
 export interface CapacityWindow {
   id: string;
@@ -6,9 +7,16 @@ export interface CapacityWindow {
   durationMinutes: number | null;
   usedPercent: number | null;
   resetsAt: string | null;
+  limitType?: CapacityLimitType;
+  total?: number | null;
+  current?: number | null;
+  remaining?: number | null;
 }
 
 export interface CapacityReport {
+  /** Harness whose quota pool is measured, e.g. "pi" or "codex". */
+  harness: string;
+  /** Model provider backing the harness, e.g. "zai" or "openai". */
   provider: string;
   generatedAt: string;
   authenticated: boolean | null;

package/src/capacity/zai.ts

@@ -0,0 +1,237 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type {
+  Availability,
+  CapacityLimitType,
+  CapacityReport,
+  CapacityWindow,
+} from "./types.js";
+
+const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+const MISSING_API_KEY_MESSAGE =
+  "z.ai API key not found; set Z_AI_API_KEY or configure Pi provider zai";
+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 ZaiCredentialOptions = {
+  env?: NodeJS.ProcessEnv;
+  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+};
+
+export type ZaiProbeOptions = ZaiCredentialOptions & {
+  checkedAt: string;
+  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 nonEmptyText(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : 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 clampPercent(value: number): number {
+  return Math.max(0, Math.min(100, 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,
+  number: number,
+  type: CapacityLimitType,
+): number | null {
+  if (type === "TIME_LIMIT" && unit === 5 && number === 1) return 30 * 24 * 60;
+  const metadata = UNIT_METADATA.get(unit);
+  return metadata === undefined || number <= 0
+    ? null
+    : metadata.minutes * number;
+}
+
+function windowLabel(
+  type: CapacityLimitType,
+  unit: number,
+  number: number,
+): string {
+  if (type === "TIME_LIMIT" && unit === 5 && number === 1)
+    return "MCP · monthly";
+  const kind = LIMIT_METADATA[type].label;
+  const unitLabel = UNIT_METADATA.get(unit)?.label;
+  if (!unitLabel) return kind;
+  return `${kind} · ${number} ${unitLabel}${number === 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";
+  if (
+    windows.some(
+      (window) => window.usedPercent !== null && window.usedPercent < 100,
+    )
+  ) {
+    return "yes";
+  }
+  return "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: clampPercent(usedPercent),
+    resetsAt: resetTime(limit.nextResetTime),
+    total,
+    current,
+    remaining,
+  };
+}
+
+export async function resolveZaiApiKey(
+  options: ZaiCredentialOptions = {},
+): Promise<string> {
+  const env = options.env ?? process.env;
+  const environmentKey = nonEmptyText(env.Z_AI_API_KEY);
+  if (environmentKey) return environmentKey;
+
+  const authPath = join(env.HOME || homedir(), ".pi", "agent", "auth.json");
+  let parsed: UnknownRecord;
+  try {
+    const contents = await (options.readFile ?? readFile)(authPath, "utf8");
+    const root = record(JSON.parse(contents));
+    if (!root) throw new Error("invalid");
+    parsed = root;
+  } catch (error) {
+    if (record(error)?.code === "ENOENT") {
+      throw new Error(MISSING_API_KEY_MESSAGE);
+    }
+    throw new Error("z.ai Pi auth file is malformed");
+  }
+
+  const credential = record(parsed.zai);
+  if (!credential) {
+    throw new Error(MISSING_API_KEY_MESSAGE);
+  }
+  const key =
+    credential.type === "api_key" ? nonEmptyText(credential.key) : null;
+  if (!key) throw new Error("z.ai Pi auth file has a malformed zai credential");
+  return key;
+}
+
+export function parseZaiQuota(raw: unknown, checkedAt: string): CapacityReport {
+  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 {
+    harness: "pi",
+    provider: "zai",
+    generatedAt: checkedAt,
+    authenticated: true,
+    available: availability(windows),
+    windows,
+    creditsRemaining: null,
+  };
+}
+
+export async function probeZaiCapacity(
+  options: ZaiProbeOptions,
+): Promise<CapacityReport> {
+  const key = await resolveZaiApiKey(options);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 5000);
+  let response: Response;
+  try {
+    response = await (options.fetch ?? globalThis.fetch)(ZAI_QUOTA_URL, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+      signal: controller.signal,
+    });
+  } catch {
+    throw new Error("z.ai quota request failed");
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status !== 200) {
+    throw new Error(`z.ai quota request failed: HTTP ${response.status}`);
+  }
+  let raw: unknown;
+  try {
+    raw = await response.json();
+  } catch {
+    throw new Error("z.ai quota response is not valid JSON");
+  }
+  return parseZaiQuota(raw, options.checkedAt);
+}