@v1nvn/zai 0.43.0 → 0.45.0

package/src/resolve.ts

@@ -0,0 +1,146 @@
+import {
+  buildCli,
+  type CliRun,
+  type CliSpec,
+  HelpRequested,
+  parseCli,
+} from '@v1nvn/agentic-core';
+
+const DEFAULT_BASE_URL = 'https://api.z.ai';
+
+const GLM_HOSTS = new Set(['api.z.ai', 'dev.bigmodel.cn', 'open.bigmodel.cn']);
+
+export interface ParsedArgs {
+  readonly authToken: string | undefined;
+  readonly baseUrl: string | undefined;
+  readonly command?: 'usage';
+  readonly json: boolean;
+}
+
+export interface ResolvedConfig {
+  readonly token: string;
+  readonly url: string;
+}
+
+interface BaseUrl {
+  readonly glm: boolean;
+  readonly origin: string;
+}
+
+function fromEnv(value: string | undefined): string | undefined {
+  return value ? value : undefined;
+}
+
+function originOf(value: string): string | undefined {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:' || url.protocol === 'http:'
+      ? url.origin
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isGlm(origin: string): boolean {
+  return GLM_HOSTS.has(new URL(origin).hostname);
+}
+
+function resolveBaseUrl(
+  flag: string | undefined,
+  env: NodeJS.ProcessEnv,
+): BaseUrl {
+  if (flag !== undefined) {
+    const origin = originOf(flag);
+    if (origin === undefined) {
+      throw new Error(`invalid base URL: ${flag}`);
+    }
+    return { glm: isGlm(origin), origin };
+  }
+  const inherited = fromEnv(env.ANTHROPIC_BASE_URL);
+  const origin = inherited === undefined ? undefined : originOf(inherited);
+  if (origin !== undefined && isGlm(origin)) {
+    return { glm: true, origin };
+  }
+  return { glm: false, origin: DEFAULT_BASE_URL };
+}
+
+export function cliSpec(run?: CliRun): CliSpec {
+  return {
+    name: 'zai-usage',
+    description: 'GLM Coding Plan usage — one command, usage',
+    commands: [
+      {
+        name: 'usage',
+        description: 'GLM Coding Plan quota and usage report',
+        options: [
+          {
+            flags: '--auth-token <token>',
+            description: 'API key',
+            env: 'ZAI_AUTH_TOKEN',
+          },
+          {
+            flags: '--base-url <url>',
+            description: 'base URL',
+            env: 'ZAI_BASE_URL',
+          },
+          {
+            flags: '--json',
+            description: 'print the report lines as JSON for the zai mod',
+          },
+        ],
+        run,
+      },
+    ],
+  };
+}
+
+export function buildProgram() {
+  return buildCli(cliSpec());
+}
+
+export function parseArgs(
+  args: readonly string[],
+): HelpRequested | ParsedArgs | undefined {
+  const parsed = parseCli(cliSpec(), args);
+  if (parsed === undefined || parsed instanceof HelpRequested) {
+    return parsed;
+  }
+  if (parsed.command !== 'usage') {
+    return {
+      authToken: undefined,
+      baseUrl: undefined,
+      command: undefined,
+      json: false,
+    };
+  }
+  const { authToken, baseUrl, json } = parsed.options as {
+    authToken?: string;
+    baseUrl?: string;
+    json?: boolean;
+  };
+  return {
+    authToken: authToken || undefined,
+    baseUrl: baseUrl || undefined,
+    command: 'usage',
+    json: json === true,
+  };
+}
+
+export function resolveConfig(
+  env: NodeJS.ProcessEnv,
+  parsed: ParsedArgs,
+): ResolvedConfig {
+  const base = resolveBaseUrl(parsed.baseUrl, env);
+  const token =
+    parsed.authToken ??
+    (base.glm ? fromEnv(env.ANTHROPIC_AUTH_TOKEN) : undefined);
+  if (token === undefined) {
+    throw new Error(
+      env.ANTHROPIC_AUTH_TOKEN
+        ? 'ANTHROPIC_AUTH_TOKEN is set, but the resolved base URL does not name a GLM host, so it is not a GLM Coding Plan token — set ZAI_AUTH_TOKEN (or --auth-token)'
+        : 'no API key: set ZAI_AUTH_TOKEN (or --auth-token)',
+    );
+  }
+  return { token, url: base.origin };
+}

package/src/usage.ts

@@ -0,0 +1,163 @@
+/**
+ * Usage query: the three GLM monitor endpoints of the resolved base URL,
+ * assembled into the report input.
+ */
+
+import { pad2 } from '@v1nvn/agentic-core/draw';
+
+import type {
+  RenderInput,
+  ZaiModelUsage,
+  ZaiQuota,
+  ZaiToolUsage,
+} from './format.ts';
+import type { ResolvedConfig } from './resolve.ts';
+
+interface RawLimit {
+  currentValue?: number;
+  nextResetTime?: string;
+  percentage?: number;
+  type?: string;
+  usage?: number;
+  usageDetails?: { modelCode?: string; usage?: number }[];
+}
+
+interface RawQuota {
+  level?: string;
+  limits?: RawLimit[];
+}
+
+// Auth failures arrive as HTTP 200 with success false.
+interface RawEnvelope {
+  code?: number;
+  data?: unknown;
+  msg?: string;
+  success?: boolean;
+}
+
+// The monitor API labels every bucket in Beijing time; the query window runs
+// from yesterday at the current hour to the end of today's current hour.
+function queryParams(now = new Date()): string {
+  const startDate = new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate() - 1,
+    now.getHours(),
+    0,
+    0,
+    0,
+  );
+  const endDate = new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate(),
+    now.getHours(),
+    59,
+    59,
+    999,
+  );
+  function formatDateTime(date: Date): string {
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;
+  }
+  return `?startTime=${encodeURIComponent(formatDateTime(startDate))}&endTime=${encodeURIComponent(formatDateTime(endDate))}`;
+}
+
+// Rename the API's limit kinds to their display names; `totol` is the field the
+// renderer reads (sic — the upstream spelling).
+function processQuotaLimit(data: RawQuota): ZaiQuota {
+  if (!data.limits) {
+    return data;
+  }
+  data.limits = data.limits.map(item => {
+    if (item.type === 'TOKENS_LIMIT') {
+      return {
+        type: 'Token usage(5 Hour)',
+        percentage: item.percentage,
+        nextResetTime: item.nextResetTime,
+      };
+    }
+    if (item.type === 'TIME_LIMIT') {
+      return {
+        type: 'MCP usage(1 Month)',
+        percentage: item.percentage,
+        currentUsage: item.currentValue,
+        totol: item.usage,
+        usageDetails: item.usageDetails,
+        nextResetTime: item.nextResetTime,
+      };
+    }
+    return item;
+  });
+  return data;
+}
+
+async function fetchJson(
+  apiUrl: string,
+  label: string,
+  authToken: string,
+  query = '',
+): Promise<unknown> {
+  const res = await fetch(apiUrl + query, {
+    headers: {
+      Authorization: authToken,
+      'Accept-Language': 'en-US,en',
+      'Content-Type': 'application/json',
+    },
+  });
+  const body = await res.text();
+  if (res.status !== 200) {
+    throw new Error(`[${label}] HTTP ${res.status}\n${body}`);
+  }
+  let json: RawEnvelope;
+  try {
+    json = JSON.parse(body) as RawEnvelope;
+  } catch (e) {
+    throw new Error(
+      `[${label}] could not parse response: ${(e as Error).message}`,
+      { cause: e },
+    );
+  }
+  if (json.success === false) {
+    throw new Error(
+      `[${label}] ${json.msg ?? 'request failed'} (code ${json.code ?? '?'})`,
+    );
+  }
+  return json.data ?? json;
+}
+
+export async function fetchReport(
+  config: ResolvedConfig,
+): Promise<RenderInput> {
+  const platform = config.url.includes('bigmodel') ? 'ZHIPU' : 'ZAI';
+
+  const query = queryParams();
+  try {
+    const [model, tool, quotaRaw] = await Promise.all([
+      fetchJson(
+        `${config.url}/api/monitor/usage/model-usage`,
+        'Model usage',
+        config.token,
+        query,
+      ),
+      fetchJson(
+        `${config.url}/api/monitor/usage/tool-usage`,
+        'Tool usage',
+        config.token,
+        query,
+      ),
+      fetchJson(
+        `${config.url}/api/monitor/usage/quota/limit`,
+        'Quota limit',
+        config.token,
+      ),
+    ]);
+    return {
+      platform,
+      model: model as ZaiModelUsage,
+      tool: tool as ZaiToolUsage,
+      quota: processQuotaLimit(quotaRaw as RawQuota),
+    };
+  } catch (e) {
+    throw new Error(`Request failed: ${(e as Error).message}`, { cause: e });
+  }
+}