@wayner6/pi-usage 0.1.0

package/src/modules/provider/adapters/anthropic.ts

@@ -0,0 +1,209 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Metric, UsageAdapter, UsageSnapshot } from "../../../core/types.ts";
+import { safeError, sameOriginFetch } from "../../../core/security.ts";
+
+const ANTHROPIC_API_ORIGIN = "https://api.anthropic.com";
+
+interface StoredAuth {
+  anthropic?: {
+    type?: string;
+    access?: string;
+    refresh?: string;
+    apiKey?: string;
+    key?: string;
+    expires?: number;
+  };
+}
+
+async function resolveLocalAnthropicAuth(): Promise<{ token?: string | undefined; isOAuth: boolean; expires?: number | undefined }> {
+  try {
+    const authPath = join(getAgentDir(), "auth.json");
+    const raw = await readFile(authPath, "utf8");
+    const parsed = JSON.parse(raw) as StoredAuth;
+    const anthropic = parsed.anthropic;
+    if (anthropic) {
+      const isOAuth = anthropic.type === "oauth" || !!anthropic.access;
+      const token = anthropic.access || anthropic.apiKey || anthropic.key;
+      return { token, isOAuth, expires: anthropic.expires };
+    }
+  } catch {
+    // Ignore fallback errors
+  }
+  return { isOAuth: false };
+}
+
+export const anthropicAdapter: UsageAdapter = {
+  id: "anthropic",
+  label: "Anthropic Claude",
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    if (pid === "anthropic" || pid === "claude") return true;
+    if (target.baseUrl) {
+      try {
+        const origin = new URL(target.baseUrl).origin;
+        if (origin.includes("anthropic.com")) return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  },
+  async fetch({ target, signal, fetchFn }): Promise<UsageSnapshot> {
+    const fetchedAt = new Date().toISOString();
+    const authRecord = target.auth?.auth as Record<string, unknown> | undefined;
+    let token = (authRecord?.apiKey ?? authRecord?.access ?? authRecord?.key) as string | undefined;
+    let isOAuth = false;
+    let expires: number | undefined;
+
+    if (!token) {
+      const local = await resolveLocalAnthropicAuth();
+      token = local.token;
+      isOAuth = local.isOAuth;
+      expires = local.expires;
+    } else {
+      const local = await resolveLocalAnthropicAuth();
+      isOAuth = local.isOAuth;
+      expires = local.expires;
+    }
+
+    if (!token) {
+      return {
+        adapterId: this.id,
+        sourceProviderId: target.providerId,
+        displayName: "Claude",
+        state: "unauthorized",
+        fetchedAt,
+        accounts: [],
+        error: "No API key or OAuth subscription found in Pi auth for Anthropic",
+      };
+    }
+
+    try {
+      // For Claude Pro / Max OAuth subscription accounts or API keys:
+      // Send a lightweight headers probe to https://api.anthropic.com/v1/messages
+      // This retrieves active rate-limit headers without consuming tokens or failing unexpectedly
+      const headers: Record<string, string> = {
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+      };
+
+      if (isOAuth) {
+        headers["authorization"] = `Bearer ${token}`;
+      } else {
+        headers["x-api-key"] = token;
+      }
+
+      const res = await sameOriginFetch(
+        new URL("/v1/messages", ANTHROPIC_API_ORIGIN),
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            model: "claude-sonnet-4-6",
+            messages: [{ role: "user", content: "" }],
+            max_tokens: 1,
+          }),
+          signal,
+        },
+        fetchFn,
+        ANTHROPIC_API_ORIGIN,
+      );
+
+      if (res.status === 401) {
+        return {
+          adapterId: this.id,
+          sourceProviderId: target.providerId,
+          displayName: "Claude",
+          state: "unauthorized",
+          fetchedAt,
+          accounts: [],
+          error: "Anthropic returned HTTP 401 Unauthorized (token or key expired)",
+        };
+      }
+
+      // Check standard anthropic rate-limit headers
+      const reqRemaining = res.headers.get("anthropic-ratelimit-requests-remaining");
+      const reqLimit = res.headers.get("anthropic-ratelimit-requests-limit");
+      const reqReset = res.headers.get("anthropic-ratelimit-requests-reset");
+      const tokensRemaining = res.headers.get("anthropic-ratelimit-tokens-remaining");
+      const tokensLimit = res.headers.get("anthropic-ratelimit-tokens-limit");
+      const tokensReset = res.headers.get("anthropic-ratelimit-tokens-reset");
+
+      const metrics: Metric[] = [];
+
+      if (reqRemaining != null && reqLimit != null) {
+        const remaining = Number(reqRemaining);
+        const limit = Number(reqLimit);
+        if (limit > 0) {
+          const m: Metric = {
+            kind: "quota-window",
+            id: "claude-requests",
+            label: "Claude Requests",
+            remainingFraction: Math.max(0, Math.min(1, remaining / limit)),
+            ...(reqReset ? { resetAt: reqReset } : {}),
+          };
+          metrics.push(m);
+        }
+      }
+
+      if (tokensRemaining != null && tokensLimit != null) {
+        const remaining = Number(tokensRemaining);
+        const limit = Number(tokensLimit);
+        if (limit > 0) {
+          const m: Metric = {
+            kind: "quota-window",
+            id: "claude-tokens",
+            label: "Claude Tokens",
+            remainingFraction: Math.max(0, Math.min(1, remaining / limit)),
+            ...(tokensReset ? { resetAt: tokensReset } : {}),
+          };
+          metrics.push(m);
+        }
+      }
+
+      const planType = isOAuth ? "Subscription (Claude Pro/Max)" : "API Key";
+      let summary = `Claude · ${isOAuth ? "Pro/Max" : "Active"}`;
+
+      if (metrics.length > 0) {
+        const primary = metrics[0]!;
+        if (primary.kind === "quota-window") {
+          summary = `Claude ${Math.round(primary.remainingFraction * 100)}%`;
+        }
+      }
+
+      const statusMetric: Metric = {
+        kind: "status",
+        id: "claude-plan",
+        label: "Plan",
+        value: planType,
+        detail: expires ? `Expires in ${Math.max(0, Math.round((expires - Date.now()) / 60000))}m` : "Active",
+      };
+
+      metrics.push(statusMetric);
+
+      const accounts = [
+        {
+          id: isOAuth ? "claude-subscription" : "claude-api-key",
+          provider: "anthropic",
+          label: isOAuth ? "Claude Subscription" : "Claude API Account",
+          status: "available" as const,
+          metrics,
+        },
+      ];
+
+      return {
+        adapterId: this.id,
+        sourceProviderId: target.providerId,
+        displayName: "Claude",
+        state: "ok",
+        fetchedAt,
+        summary,
+        accounts,
+      };
+    } catch (error) {
+      throw new Error(safeError(error));
+    }
+  },
+};

package/src/modules/provider/adapters/cliproxy-pi-bridge.ts

@@ -0,0 +1,76 @@
+import type { Metric, UsageAdapter, UsageSnapshot } from "../../../core/types.ts";
+import { bridgeUrl, safeError, sameOriginFetch } from "../../../core/security.ts";
+
+type BridgeGroup = { id?: string; label?: string; remainingFraction?: number; resetTime?: string; models?: Array<{ id?: string; displayName?: string; remainingFraction?: number; resetTime?: string }> };
+type BridgeAccount = { provider?: string; account?: string; authIndex?: string; label?: string; status?: string; disabled?: boolean; unavailable?: boolean; supported?: boolean; error?: string; groups?: BridgeGroup[] };
+type BridgeUsage = { schemaVersion?: number; generatedAt?: string; cache?: { updatedAt?: string; stale?: boolean; ttlMs?: number }; accounts?: BridgeAccount[]; unsupportedProviders?: string[] };
+
+function metrics(groups: BridgeGroup[]): Metric[] {
+  return groups.flatMap((group, index) => {
+    const base = group.remainingFraction;
+    return typeof base === "number"
+      ? [{ kind: "quota-window" as const, id: group.id ?? `quota-${index}`, label: group.label ?? group.id ?? "Quota", remainingFraction: Math.min(1, Math.max(0, base)), ...(group.resetTime ? { resetAt: group.resetTime } : {}) }]
+      : [];
+  });
+}
+
+export const cliProxyBridgeAdapter: UsageAdapter = {
+  id: "cliproxy-pi-bridge",
+  label: "CLIProxyAPI / pi-bridge",
+  canHandle(target) {
+    // 1. If explicit baseUrl exists and is not official deepseek/openai, it's a potential bridge target
+    if (target.baseUrl) {
+      try {
+        const url = new URL(target.baseUrl);
+        if (url.origin.includes("deepseek.com")) return false;
+      } catch {
+        return false;
+      }
+    }
+    const pid = target.providerId.toLowerCase();
+    // 2. Accept if providerId hints at proxy/bridge or if any custom baseUrl is present
+    return pid.includes("cpa") || pid.includes("cliproxy") || pid.includes("bridge") || pid.includes("proxy") || Boolean(target.baseUrl);
+  },
+  async fetch({ target, signal, force, fetchFn }): Promise<UsageSnapshot> {
+    const fetchedAt = new Date().toISOString();
+    const apiKey = target.auth?.auth.apiKey;
+    const baseUrl = target.auth?.auth.baseUrl ?? target.baseUrl;
+    if (!baseUrl || !apiKey) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: target.providerId, state: "unauthorized", fetchedAt, accounts: [], error: "Missing base URL or API key" };
+    const origin = new URL(baseUrl).origin;
+    try {
+      const response = await sameOriginFetch(bridgeUrl(baseUrl, "usage", force), {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json", "X-Pi-Contract": "2" },
+        signal,
+      }, fetchFn, origin);
+      if (response.status === 404) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: target.providerId, state: "not-installed", fetchedAt, accounts: [], error: "pi-bridge usage endpoint was not found" };
+      if (response.status === 401 || response.status === 403) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: target.providerId, state: "unauthorized", fetchedAt, accounts: [], error: "The API key is not authorized for pi-bridge" };
+      if (!response.ok) throw new Error(`pi-bridge returned HTTP ${response.status}`);
+      const data = await response.json() as BridgeUsage;
+      if (data.schemaVersion !== 1) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: target.providerId, state: "incompatible", fetchedAt, accounts: [], error: `Unsupported pi-bridge schemaVersion ${String(data.schemaVersion)}` };
+      const accounts = (data.accounts ?? []).map((account, index) => ({
+        id: account.authIndex ?? `${account.provider ?? "provider"}-${index}`,
+        provider: account.provider ?? "unknown",
+        label: account.label || account.account || account.provider || `Account ${index + 1}`,
+        ...(account.status ? { status: account.status } : {}),
+        ...(account.disabled !== undefined ? { disabled: account.disabled } : {}),
+        ...(account.unavailable !== undefined ? { unavailable: account.unavailable } : {}),
+        metrics: metrics(account.groups ?? []),
+        rawGroups: account.groups,
+        ...(account.error ? { error: account.error } : {}),
+      }));
+      return {
+        adapterId: this.id,
+        sourceProviderId: target.providerId,
+        displayName: target.providerId,
+        state: accounts.length ? (data.cache?.stale ? "stale" : "ok") : "empty",
+        fetchedAt: data.cache?.updatedAt ?? data.generatedAt ?? fetchedAt,
+        ...(data.cache?.stale ? { stale: true } : {}),
+        accounts,
+        ...(data.unsupportedProviders?.length ? { diagnostic: `Unsupported upstream providers: ${data.unsupportedProviders.join(", ")}` } : {}),
+      };
+    } catch (error) {
+      throw new Error(safeError(error));
+    }
+  },
+};

package/src/modules/provider/adapters/deepseek.ts

@@ -0,0 +1,66 @@
+import type { UsageAdapter, UsageSnapshot } from "../../../core/types.ts";
+import { safeError, sameOriginFetch } from "../../../core/security.ts";
+
+type BalanceInfo = {
+  currency?: string;
+  total_balance?: string | number | null;
+  granted_balance?: string | number | null;
+  topped_up_balance?: string | number | null;
+};
+type BalanceResponse = { is_available?: boolean; balance_infos?: BalanceInfo[] };
+
+const OFFICIAL_ORIGIN = "https://api.deepseek.com";
+
+function number(value: unknown): number | undefined {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function format(amount: number, currency: string): string {
+  return `${currency === "CNY" || currency === "RMB" ? "¥" : currency === "USD" ? "$" : `${currency} `}${amount.toFixed(2)}`;
+}
+
+export const deepSeekAdapter: UsageAdapter = {
+  id: "deepseek",
+  label: "DeepSeek",
+  canHandle(target) {
+    const origin = target.baseUrl ? new URL(target.baseUrl).origin : undefined;
+    return target.providerId.toLowerCase() === "deepseek" && (!origin || origin === OFFICIAL_ORIGIN);
+  },
+  async fetch({ target, signal, fetchFn }): Promise<UsageSnapshot> {
+    const fetchedAt = new Date().toISOString();
+    const apiKey = target.auth?.auth.apiKey;
+    if (!apiKey) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: "DeepSeek", state: "unauthorized", fetchedAt, accounts: [], error: "No API key resolved from Pi provider auth" };
+    try {
+      const response = await sameOriginFetch(new URL("/user/balance", OFFICIAL_ORIGIN), {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+        signal,
+      }, fetchFn, OFFICIAL_ORIGIN);
+      if (response.status === 401 || response.status === 403) return { adapterId: this.id, sourceProviderId: target.providerId, displayName: "DeepSeek", state: "unauthorized", fetchedAt, accounts: [], error: `DeepSeek returned HTTP ${response.status}` };
+      if (!response.ok) throw new Error(`DeepSeek returned HTTP ${response.status}`);
+      const data = await response.json() as BalanceResponse;
+      const metrics = (data.balance_infos ?? []).flatMap((info, index) => {
+        const total = number(info.total_balance);
+        if (total === undefined) return [];
+        const currency = (info.currency ?? "credits").toUpperCase();
+        const granted = number(info.granted_balance);
+        const topped = number(info.topped_up_balance);
+        const detail = [topped !== undefined ? `Paid ${format(topped, currency)}` : undefined, granted !== undefined ? `Granted ${format(granted, currency)}` : undefined].filter(Boolean).join(" · ");
+        return [{ kind: "balance" as const, id: `balance-${currency}-${index}`, label: "Balance", amount: total, currency, ...(detail ? { detail } : {}) }];
+      });
+      const summary = metrics.map((metric) => format(metric.amount, metric.currency)).join(" · ");
+      return {
+        adapterId: this.id,
+        sourceProviderId: target.providerId,
+        displayName: "DeepSeek",
+        state: metrics.length ? "ok" : "empty",
+        fetchedAt,
+        accounts: [{ id: target.providerId, provider: "deepseek", label: "DeepSeek API", status: data.is_available === false ? "unavailable" : "available", metrics }],
+        ...(summary ? { summary: `Balance ${summary}` } : {}),
+      };
+    } catch (error) {
+      throw new Error(safeError(error));
+    }
+  },
+};

package/src/modules/provider/adapters/glm.ts

@@ -0,0 +1,291 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Metric, UsageAdapter, UsageSnapshot } from "../../../core/types.ts";
+import { safeError, sameOriginFetch } from "../../../core/security.ts";
+
+const BIGMODEL_API_ORIGIN = "https://open.bigmodel.cn";
+const ZAI_API_ORIGIN = "https://api.z.ai";
+
+interface StoredAuth {
+  [key: string]: {
+    type?: string;
+    apiKey?: string;
+    key?: string;
+  };
+}
+
+interface QuotaLimitResponse {
+  code: number;
+  msg?: string;
+  success?: boolean;
+  data?: {
+    level?: string;
+    limits?: Array<{
+      type: string;
+      percentage: number;
+      nextResetTime?: number;
+      currentValue?: number;
+      usage?: number;
+      remaining?: number;
+    }>;
+  };
+}
+
+async function resolveLocalGLMAuth(): Promise<string | undefined> {
+  try {
+    const authPath = join(getAgentDir(), "auth.json");
+    const raw = await readFile(authPath, "utf8");
+    const parsed = JSON.parse(raw) as StoredAuth;
+    const candidates = [
+      parsed.glm,
+      parsed["zai-coding-cn"],
+      parsed.zai,
+      parsed.zhipu,
+      parsed.bigmodel,
+    ];
+    for (const item of candidates) {
+      if (item) {
+        const key = item.apiKey || item.key;
+        if (key) return key;
+      }
+    }
+  } catch {
+    // Ignore fallback errors
+  }
+  return undefined;
+}
+
+export const glmAdapter: UsageAdapter = {
+  id: "glm",
+  label: "GLM / 智谱 BigModel",
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    if (
+      pid === "glm" ||
+      pid === "zhipu" ||
+      pid === "bigmodel" ||
+      pid === "zai" ||
+      pid === "zai-coding-cn"
+    ) {
+      return true;
+    }
+    if (target.baseUrl) {
+      try {
+        const host = new URL(target.baseUrl).host;
+        if (host.includes("bigmodel.cn") || host.includes("z.ai")) return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  },
+  async fetch({ target, signal, fetchFn }): Promise<UsageSnapshot> {
+    const fetchedAt = new Date().toISOString();
+    const authRecord = target.auth?.auth as Record<string, unknown> | undefined;
+    let apiKey = (authRecord?.apiKey ?? authRecord?.key) as string | undefined;
+
+    if (!apiKey) {
+      apiKey = await resolveLocalGLMAuth();
+    }
+
+    if (!apiKey) {
+      return {
+        adapterId: this.id,
+        sourceProviderId: target.providerId,
+        displayName: "GLM",
+        state: "unauthorized",
+        fetchedAt,
+        accounts: [],
+        error: "No API key found in Pi auth for GLM / Zhipu",
+      };
+    }
+
+    try {
+      // Determine base URL: choose between open.bigmodel.cn or api.z.ai based on target.baseUrl
+      const isZai = target.baseUrl?.includes("api.z.ai");
+      const baseOrigin = isZai ? ZAI_API_ORIGIN : BIGMODEL_API_ORIGIN;
+
+      // 1. Priority: Query official GLM Coding Plan usage quota limit endpoint
+      // GET /api/monitor/usage/quota/limit
+      // Authorization: <apiKey> (or Bearer <apiKey>)
+      try {
+        const quotaRes = await sameOriginFetch(
+          new URL("/api/monitor/usage/quota/limit", baseOrigin),
+          {
+            method: "GET",
+            headers: {
+              Authorization: apiKey,
+              Accept: "application/json",
+            },
+            signal,
+          },
+          fetchFn,
+          baseOrigin,
+        );
+
+        if (quotaRes.ok) {
+          const quotaJson = (await quotaRes.json()) as QuotaLimitResponse;
+          if (quotaJson.success && quotaJson.data?.limits) {
+            const limits = quotaJson.data.limits;
+            const tokenLimits = limits
+              .filter((l) => l.type === "TOKENS_LIMIT")
+              .sort((a, b) => (a.nextResetTime ?? 0) - (b.nextResetTime ?? 0));
+
+            const metrics: Metric[] = [];
+            const planLevel = quotaJson.data.level ? quotaJson.data.level.toUpperCase() : "Coding Plan";
+
+            // Multi-window tokens limit (e.g. 5h and weekly/7d)
+            if (tokenLimits.length > 0) {
+              tokenLimits.forEach((tl, idx) => {
+                const label = idx === 0 ? "GLM 5h" : "GLM 7d";
+                const used = Math.max(0, Math.min(100, tl.percentage));
+                const remainingFraction = (100 - used) / 100;
+                const resetAt = tl.nextResetTime ? new Date(tl.nextResetTime).toISOString() : undefined;
+                metrics.push({
+                  kind: "quota-window",
+                  id: `glm-window-${idx}`,
+                  label,
+                  remainingFraction,
+                  ...(resetAt ? { resetAt } : {}),
+                });
+              });
+            }
+
+            // MCP monthly limit
+            const mcp = limits.find((l) => l.type === "TIME_LIMIT");
+            if (mcp && mcp.usage && mcp.usage > 0) {
+              const remaining = mcp.remaining ?? (mcp.usage - (mcp.currentValue ?? 0));
+              metrics.push({
+                kind: "quota-window",
+                id: "glm-mcp",
+                label: "MCP Monthly",
+                remainingFraction: Math.max(0, Math.min(1, remaining / mcp.usage)),
+                detail: `${mcp.currentValue ?? 0}/${mcp.usage}`,
+              });
+            }
+
+            metrics.push({
+              kind: "status",
+              id: "glm-plan-level",
+              label: "Plan",
+              value: planLevel,
+            });
+
+            // Format summary
+            let summary = `GLM · ${planLevel}`;
+            if (metrics.length > 0 && metrics[0]!.kind === "quota-window") {
+              const parts = metrics
+                .filter((m): m is Extract<Metric, { kind: "quota-window" }> => m.kind === "quota-window" && m.id.startsWith("glm-window"))
+                .map((m) => {
+                  const sub = m.label.replace(/^GLM\s+/, "");
+                  return `${sub} ${Math.round(m.remainingFraction * 100)}%`;
+                });
+              if (parts.length > 0) {
+                summary = `GLM ${parts.join(" · ")}`;
+              }
+            }
+
+            return {
+              adapterId: this.id,
+              sourceProviderId: target.providerId,
+              displayName: "GLM",
+              state: "ok",
+              fetchedAt,
+              summary,
+              accounts: [
+                {
+                  id: "glm-coding-plan",
+                  provider: "glm",
+                  label: `GLM ${planLevel}`,
+                  status: "available",
+                  metrics,
+                },
+              ],
+            };
+          }
+        }
+      } catch {
+        // Fallback to Pay-as-you-go verification
+      }
+
+      // 2. Fallback: Pay-As-You-Go standard API Key probe via completions
+      const probeRes = await sameOriginFetch(
+        new URL(target.baseUrl ? new URL(target.baseUrl).pathname + "/chat/completions" : "/api/paas/v4/chat/completions", baseOrigin),
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            model: "glm-4.7",
+            messages: [{ role: "user", content: "hi" }],
+            max_tokens: 1,
+          }),
+          signal,
+        },
+        fetchFn,
+        baseOrigin,
+      );
+
+      if (probeRes.status === 401 || probeRes.status === 403) {
+        return {
+          adapterId: this.id,
+          sourceProviderId: target.providerId,
+          displayName: "GLM",
+          state: "unauthorized",
+          fetchedAt,
+          accounts: [],
+          error: `GLM returned HTTP ${probeRes.status} (API key invalid or expired)`,
+        };
+      }
+
+      // Read rate-limit headers if returned by proxy/gateway
+      const reqRemaining = probeRes.headers.get("x-ratelimit-remaining-requests");
+      const reqLimit = probeRes.headers.get("x-ratelimit-limit-requests");
+      const metrics: Metric[] = [];
+
+      if (reqRemaining != null && reqLimit != null) {
+        const rem = Number(reqRemaining);
+        const lim = Number(reqLimit);
+        if (lim > 0) {
+          metrics.push({
+            kind: "quota-window",
+            id: "glm-rpm",
+            label: "GLM Requests",
+            remainingFraction: Math.max(0, Math.min(1, rem / lim)),
+          });
+        }
+      }
+
+      metrics.push({
+        kind: "status",
+        id: "glm-plan-type",
+        label: "Notice",
+        value: "Quota display only supported for Coding Plan",
+        detail: "GLM official API does not provide quota/balance query for standard Pay-as-you-go keys",
+      });
+
+      return {
+        adapterId: this.id,
+        sourceProviderId: target.providerId,
+        displayName: "GLM",
+        state: "ok",
+        fetchedAt,
+        summary: "GLM · Coding Plan Only",
+        accounts: [
+          {
+            id: "glm-payg-account",
+            provider: "glm",
+            label: "GLM (BigModel)",
+            status: "available",
+            metrics,
+          },
+        ],
+      };
+    } catch (error) {
+      throw new Error(safeError(error));
+    }
+  },
+};