wenil/clawdmeter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

v3 M3: finalize z.ai against the real usage endpoint (monitor/quota/limit)

Browse Source 
Probing a live GLM Coding Plan key showed the Anthropic-compat /v1/messages
response carries NO rate-limit headers. z.ai instead exposes a dedicated status
endpoint (found via github.com/rygel/AIUsageTracker):

    GET https://api.z.ai/api/monitor/usage/quota/limit
    Authorization: <raw key>   (no "Bearer")   Accept-Language: en-US,en
    -> data.limits[] of TOKENS_LIMIT windows {percentage 0-100, nextResetTime ms, unit,number}
       + data.level (plan tier)

ZaiProvider now GETs that: the shortest TOKENS_LIMIT window -> the 5h bar (s/sr),
the longest -> the weekly bar (w/wr); the monthly TIME_LIMIT (web-tool quota) is
ignored; level -> status ("Lite"/"Pro"/…), any window at 100% -> "limited". It's
a status GET, so it does NOT spend the prompt-metered plan — no self-throttle
needed, polls on the normal cadence. Monitor URL derives from the configured
base host.

Verified live: s=1% (5h, resets ~4.9h), w=2% (weekly, resets ~6.5d), st="Lite".
test_zai rewritten for the JSON envelope (9 tests). probe_zai.py repointed to the
monitor endpoint. 122 passed, 2 Linux-only failures (baseline).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
wenil
2026-07-10 08:53:32 +03:00
co-authored by Claude Opus 4.8
parent ac0742d92c
commit 4eeb6e242b
3 changed files with 192 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files
daemon/providers/zai.py
+84 -76
View File
@@ -1,34 +1,51 @@
"""z.ai (GLM Coding Plan) provider (v3 M3).
z.ai exposes an Anthropic-compatible endpoint (default
``https://api.z.ai/api/anthropic``), so we reach it the same way Claude Code does
with ``ANTHROPIC_BASE_URL`` pointed at z.ai: a ``/v1/messages`` POST with a Bearer
API key. The key + base URL come from the config the control panel writes
(``providers.zai.base_url`` / ``.api_key``) — the "paste your key" field.
z.ai exposes a dedicated usage endpoint that returns the Coding Plan's rate-limit
windows directly — no need to send a (quota-consuming) chat request:
Two z.ai-specific cares vs. Anthropic:
* Auth is a static API key (Bearer), not the OAuth token — no self-refresh.
* The GLM Coding Plan meters by *prompts*, so polling every 60s would burn the
user's quota. We self-throttle: hit the network at most once per
``poll_interval_s`` (default 15 min) and serve a cached status in between.
GET https://api.z.ai/api/monitor/usage/quota/limit
Authorization: <api_key> # raw key, NOT "Bearer …"
Accept-Language: en-US,en
Rate-limit parsing assumes z.ai proxies Anthropic's unified rate-limit headers.
If a real z.ai response doesn't carry them, poll() still reports "connected" and
logs the limit-ish headers it DID return, so the mapping can be finalized against
a live key (see tools/probe_zai.py).
{"code":200,"success":true,"data":{"level":"lite","limits":[
{"type":"TIME_LIMIT", "unit":5,"number":1, ...}, # monthly web-tool quota (ignored)
{"type":"TOKENS_LIMIT","unit":3,"number":5,"percentage":1,"nextResetTime":<ms>}, # 5h window
{"type":"TOKENS_LIMIT","unit":6,"number":1,"percentage":2,"nextResetTime":<ms>}]}} # weekly window
We surface the two TOKENS_LIMIT windows as Claude's short (5h) + weekly bars: of
the token windows, the shortest is the 5h bar and the longest the weekly bar.
``percentage`` is already 0-100; ``nextResetTime`` is epoch ms. The key + base URL
come from the config the control panel's z.ai field writes. This is a status GET,
so — unlike a chat call — it doesn't spend the prompt-metered plan, and can poll
on the normal cadence.
Discovered from github.com/rygel/AIUsageTracker (ZaiProvider.cs).
"""
from __future__ import annotations
import time
from urllib.parse import urlsplit
import httpx
from .base import Provider, ProviderStatus
DEFAULT_BASE = "https://api.z.ai/api/anthropic"
DEFAULT_MODEL = "glm-4.6"
DEFAULT_POLL_INTERVAL_S = 900 # protect the prompt-metered plan: >= 15 min between calls
DEFAULT_HOST = "https://api.z.ai"
_MONITOR_PATH = "/api/monitor/usage/quota/limit"
# z.ai window "unit" enum → seconds, used only to rank the token windows by length
# (shortest = the 5h bar, longest = the weekly bar). Best-effort; unknown → hours.
_UNIT_SECONDS = {1: 1, 2: 60, 3: 3600, 4: 86400, 5: 2_592_000, 6: 604_800}
def _monitor_url(base_url: str) -> str:
"""The usage endpoint on the same host as the configured (Anthropic-compat)
base URL, or the public z.ai host when unset."""
parts = urlsplit(base_url or "")
if parts.scheme and parts.netloc:
return f"{parts.scheme}://{parts.netloc}{_MONITOR_PATH}"
return DEFAULT_HOST + _MONITOR_PATH
class ZaiProvider(Provider):
@@ -38,8 +55,6 @@ class ZaiProvider(Provider):
def __init__(self, transport: httpx.BaseTransport | None = None) -> None:
self._transport = transport # tests inject an httpx.MockTransport
self._cache: ProviderStatus | None = None
self._cache_at = 0.0
async def poll(self) -> ProviderStatus:
from daemon.claude_usage_daemon_windows import log
@@ -50,45 +65,20 @@ class ZaiProvider(Provider):
conf = provider_conf(load_config(), "zai")
key = (conf.get("api_key") or "").strip()
base = (conf.get("base_url") or "").strip().rstrip("/") or DEFAULT_BASE
model = (conf.get("model") or "").strip() or DEFAULT_MODEL
try:
interval = float(conf.get("poll_interval_s") or DEFAULT_POLL_INTERVAL_S)
except (TypeError, ValueError):
interval = DEFAULT_POLL_INTERVAL_S
base = (conf.get("base_url") or "").strip()
if not key:
return ProviderStatus(ok=False, st="no key", auth_problem=True)
# Self-throttle: reuse the cached reading until the interval elapses, so the
# prompt-metered plan isn't drained by the 60s daemon poll.
now = time.time()
if self._cache is not None and (now - self._cache_at) < interval:
return self._cache
st = await self._fetch(base, key, model, log)
# Cache stable outcomes (fresh data or a definitive auth failure); leave a
# transient blip uncached so it retries on the next tick.
if st.ok or st.auth_problem:
self._cache, self._cache_at = st, now
return st
async def _fetch(self, base: str, key: str, model: str, log) -> ProviderStatus:
url = f"{base}/v1/messages"
headers = {
"Authorization": f"Bearer {key}",
"anthropic-version": "2023-06-01",
"Content-Type": "application/json",
}
body = {"model": model, "max_tokens": 1, "messages": [{"role": "user", "content": "hi"}]}
url = _monitor_url(base)
headers = {"Authorization": key, "Accept-Language": "en-US,en"}
client_kw = {"timeout": 20.0}
if self._transport is not None:
client_kw["transport"] = self._transport
try:
async with httpx.AsyncClient(**client_kw) as http:
resp = await http.post(url, headers=headers, json=body)
resp = await http.get(url, headers=headers)
except httpx.HTTPError as e:
log(f"z.ai call failed: {e}") # transient — no auth flag
log(f"z.ai call failed: {e}") # transient — retry next tick
return ProviderStatus(ok=False, st="offline")
if resp.status_code in (401, 403):
log(f"z.ai auth rejected: HTTP {resp.status_code}")
@@ -96,40 +86,58 @@ class ZaiProvider(Provider):
if resp.status_code >= 400:
log(f"z.ai HTTP {resp.status_code}: {resp.text[:150]}")
return ProviderStatus(ok=False, st=f"http {resp.status_code}")
return self._parse(resp, log)
try:
body = resp.json()
except ValueError:
log("z.ai: non-JSON usage response")
return ProviderStatus(ok=False, st="error")
if not body.get("success") or not isinstance(body.get("data"), dict):
# e.g. {"code":401,...,"success":false} → treat as an auth/config problem
code = body.get("code")
log(f"z.ai usage error: code={code} msg={body.get('msg')!r}")
return ProviderStatus(ok=False, st="bad key",
auth_problem=code in (401, 403))
return self._to_status(body["data"])
@staticmethod
def _parse(resp: httpx.Response, log) -> ProviderStatus:
h = resp.headers
now = time.time()
def _to_status(data: dict) -> ProviderStatus:
limits = data.get("limits") or []
# Only the token windows are the coding rate limit; TIME_LIMIT is the
# separate monthly web-tool quota.
toks = [l for l in limits if isinstance(l, dict) and l.get("type") == "TOKENS_LIMIT"]
def pct(util: str) -> float:
# Anthropic reports utilization as a 0-1 fraction.
def win_seconds(l: dict) -> int:
return _UNIT_SECONDS.get(l.get("unit"), 3600) * int(l.get("number") or 1)
def pct(l: dict | None) -> float:
if not l:
return 0.0
try:
return round(float(util) * 100.0, 1)
return round(float(l.get("percentage") or 0.0), 1)
except (TypeError, ValueError):
return 0.0
def reset_min(ts: str) -> int:
try:
m = (float(ts) - now) / 60.0
except (TypeError, ValueError):
def reset_min(l: dict | None) -> int:
ts = l.get("nextResetTime") if l else None
if not isinstance(ts, (int, float)):
return -1
if ts > 1e10: # epoch ms → s
ts = ts / 1000.0
m = (ts - time.time()) / 60.0
return int(round(m)) if m > 0 else -1
# Assume z.ai proxies Anthropic's unified rate-limit headers.
if h.get("anthropic-ratelimit-unified-5h-utilization") is not None:
return ProviderStatus(
s=pct(h.get("anthropic-ratelimit-unified-5h-utilization")),
sr=reset_min(h.get("anthropic-ratelimit-unified-5h-reset")),
w=pct(h.get("anthropic-ratelimit-unified-7d-utilization")),
wr=reset_min(h.get("anthropic-ratelimit-unified-7d-reset")),
st=h.get("anthropic-ratelimit-unified-5h-status", "allowed"),
ok=True,
)
# Connected but no known limit headers — surface what z.ai DID return so the
# mapping can be finalized against a live response (tools/probe_zai.py).
limitish = sorted(k for k in h.keys()
if any(w in k.lower() for w in ("limit", "rate", "quota", "usage")))
log(f"z.ai: no unified rate-limit headers; limit-ish headers = {limitish or '<none>'}")
return ProviderStatus(ok=True, st="allowed")
short = min(toks, key=win_seconds) if toks else None
weekly = max(toks, key=win_seconds) if len(toks) > 1 else None
level = str(data.get("level") or "").strip()
st = level.capitalize() if level else "allowed"
if pct(short) >= 100 or pct(weekly) >= 100:
st = "limited"
if not toks: # authenticated but no token windows reported
return ProviderStatus(ok=True, st=st or "allowed")
return ProviderStatus(
s=pct(short), sr=reset_min(short),
w=pct(weekly), wr=reset_min(weekly),
st=st, ok=True,
)