flexgate 0.8.0__tar.gz → 0.9.0__tar.gz

{flexgate-0.8.0 → flexgate-0.9.0}/CLAUDE.md

@@ -92,7 +92,7 @@ OpenAI-style client → POST /v1/images/generations
 | `config.py` | Pydantic-like dataclasses (`GatewayConfig`, `ProviderConfig`, `RouteConfig`, `ScheduleEntry`), YAML load/save, `TIER_PATTERNS` regex map, `is_placeholder_key` |
 | `router.py` | `resolve(config, model)` — schedule-first then default routes, first regex match wins; model aliases normalized before matching |
 | `proxy.py` | `handle_request()` — httpx async proxy, per-key fallback retry loop, SSE streaming + JSON pass-through |
-| `usage.py` | `flexgate status` usage queries — per-platform adapters (MiniMax coding_plan API, Kimi Code usages API, z.ai quota API, LiteLLM `/key/info`) plus a minimal chat probe fallback |
+| `usage.py` | `flexgate status` usage queries — per-platform adapters (MiniMax coding_plan API, Kimi Code usages API, z.ai quota API, zhipu team quota API, LiteLLM `/key/info`) plus a minimal chat probe fallback |
 | `server.py` | Starlette app creation, `POST /v1/messages` + `POST /v1/images/{generations,edits}` endpoints, `SIGUSR1` lifespan reload |
 | `images.py` | OpenAI Images API → MiniMax `/v1/image_generation` translation (`image-01`, size→width/height clamped to 512–2048 mult of 8, `data.image_base64[]`→`data[].b64_json`); edits endpoint returns 501; unknown image model names get 501 `model_not_supported` |
 | `fallback.py` | Catch-all route: merged Anthropic/OpenAI-shaped JSON errors for every unserved path — 404 `route_not_found` (lists valid routes), 405 `method_not_allowed`, 501 `endpoint_not_supported` per recognized API family with an actionable reason |
@@ -111,8 +111,8 @@ OpenAI-style client → POST /v1/images/generations
 - **Model alias normalization** (`router.py`): before matching, bare aliases (`sonnet`/`opus`/`haiku`/`default`, case-insensitive, optional `[plan]` suffix) map to `claude-<tier>` prefixes (`default` → sonnet, Claude Code's default tier), and legacy numbered names (`claude-3-7-sonnet-latest`) reduce to their tier prefix; everything else passes through unchanged, so custom patterns and the catch-all behave exactly as before.
 - **Model resolution & `available_models` fallback**: A route may omit `model`; `router.resolve()` then falls back to the provider's first `available_models` entry, so `model_override` handed to the proxy is always a concrete name. `config._parse_routes` rejects routes that omit `model` on a provider with no `available_models` — so adding a provider without models requires an explicit `model` on every route using it.
 - **Proxy rewrite contract** (`proxy.py`): the upstream request gets the provider's `x-api-key` plus a fixed header set, and the JSON `model` field is rewritten only when the route set an override. Streaming responses are forwarded as raw bytes (`aiter_bytes`), never parsed.
-- **Key fallback** (`proxy.py`): a provider's `api_keys` list holds one or more keys for the same upstream (entries are key strings or `{key, note}` mappings; `note` is a free-form label shown by `flexgate status` and in fallback logs). Multiple accounts on one upstream — e.g. several MiniMax subscriptions — belong in ONE provider, not separate ones. Each *route* has an active-key pointer (`active_key` in YAML, 1-based; `RouteConfig.key_index` 0-based, default first key): requests on that route start from the pointed key, and on a retryable failure (HTTP 401/402/403/429/500/502/503/529, connect error, or timeout) the next key is tried and the pointer advances with it (in memory only, wrapping around — it is not written back to the file); every key is tried at most once and a full circle of failures returns the last error. The pointer is set interactively via `flexgate config edit` → "api keys" (pick a route, with live per-key usage) or by editing the route's `active_key` directly. `resolve()` (`router.py`) returns the matched `RouteConfig` so the proxy can read/advance its pointer. Streaming requests can only fall back before the upstream returns 200. `_regular_proxy`/`_stream_proxy` return `(response, retryable)`; `handle_request` owns the loop and returns the last error when all keys fail. The legacy `api_key` + `fallback_keys` schema is still parsed (`config._parse_api_keys`); migration v3 → v4 rewrites it to `api_keys`. `ProviderConfig.api_key` remains as a first-key property (getter/setter) for the settings import code.
-- **Usage inspection** (`usage.py`): `flexgate status` maps `base_url` to a platform adapter (`_ADAPTERS`): MiniMax → `{origin}/v1/api/openplatform/coding_plan/remains` (only the "general" text-model quota entry is used; its counts are usually 0/0, so usage is read from the `*_remaining_percent` fields), Kimi Code → `{base}/v1/usages` (undocumented, same endpoint as the CLI's `/usage`; reports weekly quota, 5-hour window and parallel limit), z.ai/bigmodel → `{origin}/api/monitor/usage/quota/limit` (undocumented but used by z.ai's own plugin), USTC/LiteLLM → `{origin}/key/info`. Hosts in `_PROBE_ONLY_MARKERS` (e.g. xiaomimimo.com — no key-based usage API) and unknown platforms get the minimal chat probe: `POST /v1/messages` with input `"hi"`, `max_tokens=128`. A failed adapter call also degrades to the probe. Any key whose usage query errored — a hard failure (adapter AND probe), or an adapter error merely recovered by the probe — is recorded in `~/.flexgate/usage-cache.json` (sha256 fingerprint, never key material; entry keeps the `ok` flag and output lines) and skipped by later `status`/`usage` runs, shown as `cached (… ago)` / `cached failure (… ago)` with a hint; `flexgate usage --force` rechecks them and a clean success clears the entry. Placeholder keys are never cached.
+- **Key fallback** (`proxy.py`): a provider's `api_keys` list holds one or more keys for the same upstream (entries are key strings or `{key, note}` mappings — plus optional `organization`/`project` on zhipu team keys, used only by the usage check; `note` is a free-form label shown by `flexgate status` and in fallback logs). Multiple accounts on one upstream — e.g. several MiniMax subscriptions — belong in ONE provider, not separate ones. Each *route* has an active-key pointer (`active_key` in YAML, 1-based; `RouteConfig.key_index` 0-based, default first key): requests on that route start from the pointed key, and on a retryable failure (HTTP 401/402/403/429/500/502/503/529, connect error, or timeout) the next key is tried and the pointer advances with it (in memory only, wrapping around — it is not written back to the file); every key is tried at most once and a full circle of failures returns the last error. The pointer is set interactively via `flexgate config edit` → "api keys" (pick a route, with live per-key usage) or by editing the route's `active_key` directly. `resolve()` (`router.py`) returns the matched `RouteConfig` so the proxy can read/advance its pointer. Streaming requests can only fall back before the upstream returns 200. `_regular_proxy`/`_stream_proxy` return `(response, retryable)`; `handle_request` owns the loop and returns the last error when all keys fail. The legacy `api_key` + `fallback_keys` schema is still parsed (`config._parse_api_keys`); migration v3 → v4 rewrites it to `api_keys`. `ProviderConfig.api_key` remains as a first-key property (getter/setter) for the settings import code.
+- **Usage inspection** (`usage.py`): `flexgate status` maps `base_url` to a platform adapter (`_ADAPTERS`): MiniMax → `{origin}/v1/api/openplatform/coding_plan/remains` (only the "general" text-model quota entry is used; its counts are usually 0/0, so usage is read from the `*_remaining_percent` fields), Kimi Code → `{base}/v1/usages` (undocumented, same endpoint as the CLI's `/usage`; reports weekly quota, 5-hour window and parallel limit), z.ai → `{origin}/api/monitor/usage/quota/limit` (undocumented but used by z.ai's own plugin; personal coding plans only), bigmodel.cn → the same endpoint with `?type=2` plus `bigmodel-organization`/`bigmodel-project` headers read from the key entry's `organization`/`project` fields (team plans; also fetches the team subscription detail for plan name/expiry — a key entry without both fields gets no adapter at all and goes straight to the probe, with a hint line), USTC/LiteLLM → `{origin}/key/info`. Hosts in `_PROBE_ONLY_MARKERS` (e.g. xiaomimimo.com — no key-based usage API) and unknown platforms get the minimal chat probe: `POST /v1/messages` with input `"hi"`, `max_tokens=128`. A failed adapter call also degrades to the probe. Any key whose usage query errored — a hard failure (adapter AND probe), or an adapter error merely recovered by the probe — is recorded in `~/.flexgate/usage-cache.json` (sha256 fingerprint, never key material; entry keeps the `ok` flag and output lines) and skipped by later `status`/`usage` runs, shown as `cached (… ago)` / `cached failure (… ago)` with a hint; `flexgate usage --force` rechecks them and a clean success clears the entry. Placeholder keys are never cached.
 - **Multimodal degradation**: `MULTIMODAL_MODELS` (currently `{"MiniMax-M3", "glm-4.6v"}`) is the allowlist. Requests carrying image blocks aimed at any other model have images stripped and a `[flexgate]` text note injected into both the outgoing request and the returned response, so non-multimodal backends don't 4xx.
 - **Schedule-based overrides**: Optional time windows (e.g. 22:00-06:00) override default routes. Overnight wrap is supported.
 - **Service-first lifecycle**: `flexgate.service` is the sole persistent runtime. systemd owns restart, boot startup, logs, and process state.

{flexgate-0.8.0 → flexgate-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flexgate
-Version: 0.8.0
+Version: 0.9.0
 Summary: Flexible local API gateway for Claude Code — route models to different providers
 Project-URL: Homepage, https://github.com/Agony5757/flexible-gateway
 Project-URL: Repository, https://github.com/Agony5757/flexible-gateway
@@ -337,6 +337,13 @@ providers:
       - key: "your-minimax-api-key-2"
         note: "备用账号"
       - "your-minimax-api-key-3"   # 纯字符串写法（无备注）
+  zhipu-team:
+    base_url: "https://open.bigmodel.cn/api/anthropic"
+    api_keys:
+      - key: "your-zhipu-team-api-key"
+        note: "队友名"
+        organization: "org-XXXXXXXX"  # 智谱团队版 key：组织/项目 ID
+        project: "proj_XXXXXXXX"      # （flexgate usage 查团队套餐额度用）
 
 claude_settings:
   default_opus_model: "claude-opus-4-7"
@@ -376,7 +383,7 @@ routes:                          # 从上到下匹配，首个命中生效
 |------|------|
 | `server.host/port` | 网关监听地址 |
 | `providers.<name>.base_url` | Provider 的 API 地址 |
-| `providers.<name>.api_keys` | API key 列表（一个或多个，互为 fallback）；每项为 key 字符串或 `{key, note}`，`note` 是存在配置里的备注 |
+| `providers.<name>.api_keys` | API key 列表（一个或多个，互为 fallback）；每项为 key 字符串或 `{key, note}`（`note` 是备注）。智谱团队版 key 还可加 `organization`/`project`（团队组织/项目 ID），供 `flexgate usage` 查询团队套餐额度 |
 | `providers.<name>.available_models` | 该 provider 的可用模型列表，首个条目作为路由省略 `model` 时的回退模型 |
 | `claude_settings.*` | 写入 settings.json 的模型和超时配置 |
 | `routes[].pattern` | 正则匹配请求中的 model 字段（匹配前归一化裸别名 `sonnet`/`opus`/`haiku`/`default` 与旧编号名） |
@@ -410,6 +417,10 @@ routes:                          # 从上到下匹配，首个命中生效
 - 每次切换都会在服务日志中留下记录（key 只显示前后各 4 位）。
 - 用 `flexgate status` 可以查看每个 provider 的 fallback 链和每个 key 的
   实时用量。
+- 智谱 GLM Coding Plan **团队版** key 在条目上配 `organization`/`project`
+  （团队组织/项目 ID）后，`flexgate status`/`usage` 会用团队版接口查询
+  套餐名、有效期和 5 小时/每周积分窗口；未配置这两个字段的 key 只做
+  连通性探测。
 - 旧版 `api_key` + `fallback_keys` 写法仍然兼容，`flexgate update` 会
   自动迁移为 `api_keys` 列表（config_version 3 → 4）。
 

{flexgate-0.8.0 → flexgate-0.9.0}/README.md

@@ -320,6 +320,13 @@ providers:
       - key: "your-minimax-api-key-2"
         note: "备用账号"
       - "your-minimax-api-key-3"   # 纯字符串写法（无备注）
+  zhipu-team:
+    base_url: "https://open.bigmodel.cn/api/anthropic"
+    api_keys:
+      - key: "your-zhipu-team-api-key"
+        note: "队友名"
+        organization: "org-XXXXXXXX"  # 智谱团队版 key：组织/项目 ID
+        project: "proj_XXXXXXXX"      # （flexgate usage 查团队套餐额度用）
 
 claude_settings:
   default_opus_model: "claude-opus-4-7"
@@ -359,7 +366,7 @@ routes:                          # 从上到下匹配，首个命中生效
 |------|------|
 | `server.host/port` | 网关监听地址 |
 | `providers.<name>.base_url` | Provider 的 API 地址 |
-| `providers.<name>.api_keys` | API key 列表（一个或多个，互为 fallback）；每项为 key 字符串或 `{key, note}`，`note` 是存在配置里的备注 |
+| `providers.<name>.api_keys` | API key 列表（一个或多个，互为 fallback）；每项为 key 字符串或 `{key, note}`（`note` 是备注）。智谱团队版 key 还可加 `organization`/`project`（团队组织/项目 ID），供 `flexgate usage` 查询团队套餐额度 |
 | `providers.<name>.available_models` | 该 provider 的可用模型列表，首个条目作为路由省略 `model` 时的回退模型 |
 | `claude_settings.*` | 写入 settings.json 的模型和超时配置 |
 | `routes[].pattern` | 正则匹配请求中的 model 字段（匹配前归一化裸别名 `sonnet`/`opus`/`haiku`/`default` 与旧编号名） |
@@ -393,6 +400,10 @@ routes:                          # 从上到下匹配，首个命中生效
 - 每次切换都会在服务日志中留下记录（key 只显示前后各 4 位）。
 - 用 `flexgate status` 可以查看每个 provider 的 fallback 链和每个 key 的
   实时用量。
+- 智谱 GLM Coding Plan **团队版** key 在条目上配 `organization`/`project`
+  （团队组织/项目 ID）后，`flexgate status`/`usage` 会用团队版接口查询
+  套餐名、有效期和 5 小时/每周积分窗口；未配置这两个字段的 key 只做
+  连通性探测。
 - 旧版 `api_key` + `fallback_keys` 写法仍然兼容，`flexgate update` 会
   自动迁移为 `api_keys` 列表（config_version 3 → 4）。
 

{flexgate-0.8.0 → flexgate-0.9.0}/config.yaml.template

@@ -8,6 +8,9 @@ server:
 # 日志都会显示）。某个 key 遇到 401/402/403/429/5xx/529 或连接错误（如额度
 # 用尽、平台过载）时，按顺序自动切换到下一个 key 重试。同一上游的多个账号
 # 应这样配置，而不是拆成多个 provider。
+# 智谱 GLM Coding Plan 团队版 key 还需在 key 条目上配置 organization 和
+# project（团队组织/项目 ID，从团队用量页的浏览器请求头里一次性获取）；
+# flexgate usage 依赖这两个字段查询团队套餐额度，未配置则只做连通性探测。
 providers:
   minimax:
     base_url: "https://api.minimaxi.com/anthropic"
@@ -26,6 +29,15 @@ providers:
     available_models:
       - "glm-5.3"      # 路由省略 model 时的回退模型
       - "glm-4.6v"
+  zhipu-team:
+    base_url: "https://open.bigmodel.cn/api/anthropic"
+    api_keys:
+      - key: "your-zhipu-team-api-key"
+        note: "队友名"
+        organization: "org-XXXXXXXX"    # 智谱团队版：组织 ID
+        project: "proj_XXXXXXXX"        # 智谱团队版：项目 ID
+    available_models:
+      - "glm-5.3"
   xiaomi:
     base_url: "https://token-plan-cn.xiaomimimo.com/anthropic"
     api_keys:

{flexgate-0.8.0 → flexgate-0.9.0}/docs/configuration.md

@@ -37,6 +37,13 @@ providers:
       - key: "your-minimax-api-key-2"
         note: "备用账号"
       - "your-minimax-api-key-3"   # 纯字符串写法（无备注）
+  zhipu-team:
+    base_url: "https://open.bigmodel.cn/api/anthropic"
+    api_keys:
+      - key: "your-zhipu-team-api-key"
+        note: "队友名"
+        organization: "org-XXXXXXXX"  # 智谱团队版 key：组织/项目 ID
+        project: "proj_XXXXXXXX"      # （flexgate usage 查团队套餐额度用）
 
 claude_settings:
   default_opus_model: "claude-opus-4-7"
@@ -76,7 +83,7 @@ routes:                          # 从上到下匹配，首个命中生效
 |------|------|
 | `server.host/port` | 网关监听地址 |
 | `providers.<name>.base_url` | Provider 的 API 地址 |
-| `providers.<name>.api_keys` | API key 列表（一个或多个，互为 fallback）；每项为 key 字符串或 `{key, note}`，`note` 是存在配置里的备注 |
+| `providers.<name>.api_keys` | API key 列表（一个或多个，互为 fallback）；每项为 key 字符串或 `{key, note}`（`note` 是备注）。智谱团队版 key 还可加 `organization`/`project`（团队组织/项目 ID），供 `flexgate usage` 查询团队套餐额度 |
 | `providers.<name>.available_models` | 该 provider 的可用模型列表，首个条目作为路由省略 `model` 时的回退模型 |
 | `claude_settings.*` | 写入 settings.json 的模型和超时配置 |
 | `routes[].pattern` | 正则匹配请求中的 model 字段 |
@@ -109,6 +116,10 @@ routes:                          # 从上到下匹配，首个命中生效
   当前使用的 key 和每个 key 的实时用量；在 `flexgate config edit` 交互
   界面的「api keys」入口可以按路由查看各 key 的实时用量/有效性并切换
   active key。
+- 智谱 GLM Coding Plan **团队版** key 在条目上配 `organization`/`project`
+  （团队组织/项目 ID）后，`flexgate status`/`usage` 会用团队版接口查询
+  套餐名、有效期和 5 小时/每周积分窗口；未配置这两个字段的 key 只做
+  连通性探测（团队 key 不适用个人版查询接口）。
 - 旧版 `api_key` + `fallback_keys` 写法仍然兼容，`flexgate update` 会
   自动迁移为 `api_keys` 列表（config_version 3 → 4）；路由上的
   `active_key` 字段在 config_version 5 引入，旧配置的每条路由默认指向

{flexgate-0.8.0 → flexgate-0.9.0}/docs/usage.md

@@ -8,7 +8,8 @@
 |------|----------|------|
 | MiniMax（api.minimaxi.com / api.minimax.io） | `GET /v1/api/openplatform/coding_plan/remains`（Bearer 认证，复用 provider key） | 官方 token plan 接口，返回 5 小时窗口和周窗口的**剩余**次数（注意响应里 `*_usage_count` 字段实际是剩余量） |
 | Kimi Code（api.kimi.com） | `GET {base}/v1/usages`（Bearer 认证，复用 provider key） | 未公开文档、与 Kimi Code CLI `/usage` 相同的接口，返回周配额、5 小时滚动窗口剩余量和并发上限 |
-| z.ai / 智谱（api.z.ai / open.bigmodel.cn） | `GET /api/monitor/usage/quota/limit`（Authorization 直接带 key） | 未公开文档、但 z.ai 官方 coding 插件在用的接口，返回各窗口已用百分比与重置时间。**仅对 GLM Coding Plan 订阅有效**：普通按量付费 key 会返回"当前用户不存在coding plan"并退化为 probe（余额只能在网页控制台查看） |
+| z.ai 个人版（api.z.ai） | `GET /api/monitor/usage/quota/limit`（Authorization 直接带 key） | 未公开文档、但 z.ai 官方 coding 插件在用的接口，返回各窗口已用百分比与重置时间。**仅对 GLM Coding Plan 个人订阅有效**：按量付费 key 会返回"当前用户不存在coding plan"并退化为 probe |
+| 智谱团队版（open.bigmodel.cn） | `GET /api/monitor/usage/quota/limit?type=2`，带 `bigmodel-organization`/`bigmodel-project` 头（取自 key 条目的 `organization`/`project` 字段） | 同一 monitor 接口的团队版变体，返回 5 小时/每周窗口的积分用量（绝对值 + 百分比 + 重置时间）；另查 `querySubscribeDetail` 显示套餐名与有效期。**key 条目未配 `organization`/`project` 时不查询**，退化为 probe（团队 key 不适用个人版接口） |
 | USTC（api.llm.ustc.edu.cn，LiteLLM） | `GET /key/info`（Bearer 认证） | LiteLLM proxy 自带的 key 信息接口，返回 spend / max_budget / 限速等 |
 | 小米 MiMo（token-plan-cn.xiaomimimo.com） | **无 key 可用的官方接口**（控制台内部接口需要浏览器 cookie，不采用） | 退化为 minimal probe |
 | 其他/未知平台 | minimal chat probe | 发一条输入 `"hi"`、`max_tokens=128` 的最小 `/v1/messages` 请求，验证 key 是否还能正常服务（会消耗极少量额度） |
@@ -31,8 +32,8 @@
 ```text
 Usage (timeout 15s per key)
   2 key(s) skipped — last check failed (recheck with: flexgate usage --force)
-  zhipu
-    ✓ key #1 (0b4d***MZTV) [fangyuan]  cached (15s ago)
+  zai
+    ✓ key #1 (9f2c***abCD)  cached (15s ago)
         z.ai quota API (unofficial) failed (platform error: 当前用户不存在coding plan); probe: key can serve glm-5.3
         recheck with: flexgate usage --force
   ustc
@@ -60,11 +61,17 @@ Usage (timeout 15s per key):
         weekly remaining 63/100 (reset 08-28 22:17)
         5h window remaining 74/100 (reset 08-23 14:17)
         parallel limit: 30
+  zhipu-team:
+    ✓ key #2 (ddb6***oZoj) [zhangsiyi]  zhipu team quota API (unofficial)
+        plan: 团队套餐高级版 (until 2026-10-14, auto-renew off)
+        5h window: used 264/35000 credits (1%), reset 09-25 14:00
+        weekly window: used 93043/155000 credits (60%), reset 09-28 16:17
 ```
 
 ## 新增平台适配器
 
 适配器登记在 `flexgate/usage.py` 的 `_ADAPTERS` 列表中：每条是
-`(url 子串, 适配器协程, 方法标签)`，首个命中生效。已知没有 key 可用接口的
-平台放入 `_PROBE_ONLY_MARKERS`，直接走 probe，避免浪费一次失败的 HTTP
-请求。
+`(url 子串, 适配器协程, 方法标签)`，首个命中生效。bigmodel.cn 的团队版
+适配器额外要求 key 条目上配置 `organization`/`project`，否则视为无适配
+接口。已知没有 key 可用接口的平台放入 `_PROBE_ONLY_MARKERS`，直接走
+probe，避免浪费一次失败的 HTTP 请求。

{flexgate-0.8.0 → flexgate-0.9.0}/flexgate/__init__.py

@@ -1,3 +1,3 @@
 """Flexgate — Flexible API Gateway for Claude Code."""
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"

{flexgate-0.8.0 → flexgate-0.9.0}/flexgate/config.py

@@ -35,9 +35,16 @@ def is_placeholder_key(key: str) -> bool:
 
 @dataclass
 class ApiKey:
-    """One API key for a provider, with an optional human-readable note."""
+    """One API key for a provider, with an optional human-readable note.
+
+    ``organization``/``project`` identify the team a zhipu (bigmodel.cn)
+    GLM Coding Plan *team* key belongs to; the usage check passes them as the
+    bigmodel-organization/bigmodel-project headers of the team quota query.
+    """
     key: str
     note: str = ""
+    organization: str = ""
+    project: str = ""
 
 
 @dataclass
@@ -122,7 +129,9 @@ def _parse_api_keys(name: str, prov: dict) -> list[ApiKey]:
     """Parse a provider's key list.
 
     Current schema: ``api_keys`` — a list whose entries are either a plain
-    key string or a mapping ``{key: ..., note: ...}``. The legacy schema
+    key string or a mapping ``{key: ..., note: ..., organization: ...,
+    project: ...}`` (``note`` free-form; ``organization``/``project`` are the
+    zhipu team IDs used by the usage check). The legacy schema
     (``api_key`` plus optional ``fallback_keys``) is still accepted.
     """
     raw = prov.get("api_keys")
@@ -136,7 +145,19 @@ def _parse_api_keys(name: str, prov: dict) -> list[ApiKey]:
         if isinstance(item, str):
             keys.append(ApiKey(key=item))
         elif isinstance(item, dict) and isinstance(item.get("key"), str):
-            keys.append(ApiKey(key=item["key"], note=str(item.get("note") or "")))
+            organization = str(item.get("organization") or "")
+            project = str(item.get("project") or "")
+            if bool(organization) != bool(project):
+                raise ValueError(
+                    f"Provider '{name}': api_keys entry '{item['key'][:4]}***' sets "
+                    f"only one of 'organization'/'project' — set both or neither"
+                )
+            keys.append(ApiKey(
+                key=item["key"],
+                note=str(item.get("note") or ""),
+                organization=organization,
+                project=project,
+            ))
         else:
             raise ValueError(
                 f"Provider '{name}': each api_keys entry must be a key string "
@@ -262,6 +283,21 @@ def _format_hhmm(minutes: int) -> str:
     return f"{minutes // 60:02d}:{minutes % 60:02d}"
 
 
+def _serialize_key(k: ApiKey) -> dict | str:
+    """Key entry → YAML value: a plain string, or a mapping that keeps the
+    note and the zhipu-team organization/project fields."""
+    if not (k.note or k.organization or k.project):
+        return k.key
+    data: dict = {"key": k.key}
+    if k.note:
+        data["note"] = k.note
+    if k.organization:
+        data["organization"] = k.organization
+    if k.project:
+        data["project"] = k.project
+    return data
+
+
 def save_config(cfg: GatewayConfig, path: str | None = None) -> None:
     import yaml
 
@@ -287,10 +323,7 @@ def save_config(cfg: GatewayConfig, path: str | None = None) -> None:
     for name, prov in cfg.providers.items():
         entry: dict = {
             "base_url": prov.base_url,
-            "api_keys": [
-                {"key": k.key, "note": k.note} if k.note else k.key
-                for k in prov.api_keys
-            ],
+            "api_keys": [_serialize_key(k) for k in prov.api_keys],
         }
         if prov.available_models:
             entry["available_models"] = list(prov.available_models)
@@ -329,7 +362,11 @@ server:
 # a plain key string or {key, note} where `note` is a free-form label stored
 # in the config (shown by `flexgate status`, included in fallback logs).
 # Multiple accounts on the same upstream should be configured this way
-# instead of as separate providers. A route's `active_key` (see below)
+# instead of as separate providers. zhipu GLM Coding Plan *team* keys also
+# carry `organization`/`project` — the team IDs copied once from the team
+# usage page's request headers; `flexgate usage` needs them to query the
+# team plan quota, and without them the key only gets an availability probe.
+# A route's `active_key` (see below)
 # selects which key its requests start from; when that key fails with a
 # retryable error (401/402/403/429/5xx/529 or a connection error — e.g.
 # quota exhausted or provider overloaded), the request is retried with the
@@ -353,6 +390,15 @@ providers:
     available_models:
       - "glm-5.3"      # used as fallback when a route omits `model`
       - "glm-4.6v"
+  zhipu-team:
+    base_url: "https://open.bigmodel.cn/api/anthropic"
+    api_keys:
+      - key: "your-zhipu-team-api-key"
+        note: "teammate name"
+        organization: "org-XXXXXXXX"   # zhipu team IDs (see comment above)
+        project: "proj_XXXXXXXX"
+    available_models:
+      - "glm-5.3"
   xiaomi:
     base_url: "https://token-plan-cn.xiaomimimo.com/anthropic"
     api_keys:

{flexgate-0.8.0 → flexgate-0.9.0}/flexgate/usage.py

@@ -14,6 +14,11 @@ known adapter and queries it with the provider's own API key:
               returns weekly quota, 5-hour window and parallel limit)
 * z.ai      → GET {origin}/api/monitor/usage/quota/limit
               (undocumented but used by z.ai's own coding plugin)
+* zhipu team→ GET {origin}/api/monitor/usage/quota/limit?type=2 with
+              bigmodel-organization/bigmodel-project headers taken from the
+              key entry's organization/project fields, plus the team
+              subscription detail for the plan name/expiry; keys without
+              both fields cannot be queried and get the plain probe
 * LiteLLM   → GET {origin}/key/info   (e.g. USTC api.llm.ustc.edu.cn)
 * anything else (e.g. Xiaomi MiMo, which has no key-based usage API)
             → minimal chat probe: POST /v1/messages with input "hi" and
@@ -176,8 +181,9 @@ async def _get_json(
 
 
 async def _usage_minimax(
-    client: httpx.AsyncClient, provider: ProviderConfig, key: str, timeout: float
+    client: httpx.AsyncClient, provider: ProviderConfig, entry: ApiKey, timeout: float
 ) -> tuple[list[str], str | None]:
+    key = entry.key
     url = f"{_origin(provider.base_url)}/v1/api/openplatform/coding_plan/remains"
     headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
     data, err = await _get_json(client, url, headers, timeout)
@@ -217,8 +223,9 @@ async def _usage_minimax(
 
 
 async def _usage_zai(
-    client: httpx.AsyncClient, provider: ProviderConfig, key: str, timeout: float
+    client: httpx.AsyncClient, provider: ProviderConfig, entry: ApiKey, timeout: float
 ) -> tuple[list[str], str | None]:
+    key = entry.key
     url = f"{_origin(provider.base_url)}/api/monitor/usage/quota/limit"
     headers = {"Authorization": key, "Content-Type": "application/json"}
     data, err = await _get_json(client, url, headers, timeout)
@@ -247,9 +254,75 @@ async def _usage_zai(
     return lines or ["no quota data"], None
 
 
+def _zhipu_team_headers(entry: ApiKey) -> dict[str, str]:
+    return {
+        "Authorization": entry.key,
+        "Content-Type": "application/json",
+        "bigmodel-organization": entry.organization,
+        "bigmodel-project": entry.project,
+    }
+
+
+async def _zhipu_team_plan(
+    client: httpx.AsyncClient, provider: ProviderConfig, entry: ApiKey, timeout: float
+) -> str | None:
+    """Best-effort team subscription detail: plan name and expiry."""
+    url = f"{_origin(provider.base_url)}/api/biz/team/subscribe/product/querySubscribeDetail"
+    data, err = await _get_json(client, url, _zhipu_team_headers(entry), timeout)
+    if err or not data.get("success", False):
+        return None
+    detail = data.get("data") or {}
+    name = detail.get("productName")
+    if not name:
+        return None
+    line = f"plan: {name}"
+    end = detail.get("subscribeEndTime")
+    if end:
+        line += f" (until {end}"
+        if detail.get("autoRenew") == 0:
+            line += ", auto-renew off"
+        line += ")"
+    return line
+
+
+async def _usage_zhipu_team(
+    client: httpx.AsyncClient, provider: ProviderConfig, entry: ApiKey, timeout: float
+) -> tuple[list[str], str | None]:
+    url = f"{_origin(provider.base_url)}/api/monitor/usage/quota/limit?type=2"
+    data, err = await _get_json(client, url, _zhipu_team_headers(entry), timeout)
+    if err:
+        return [], err
+    if not data.get("success", False):
+        return [], f"platform error: {data.get('msg', 'unknown')}"
+    payload = data.get("data", {}) or {}
+    limits = payload.get("limits") or []
+    if not limits:
+        # type=2 answers success with empty limits when the key does not
+        # belong to the configured organization/project.
+        return [], "empty limits — key is not a member of the configured organization/project"
+    lines: list[str] = []
+    plan = await _zhipu_team_plan(client, provider, entry, timeout)
+    if plan:
+        lines.append(plan)
+    for limit in limits:
+        if not isinstance(limit, dict):
+            continue
+        # team plans are credit-metered; keep TOKENS_LIMIT handling anyway
+        if limit.get("type") not in ("CREDIT_LIMIT", "TOKENS_LIMIT"):
+            continue
+        # unit 3 = N-hour rolling window, unit 6 = weekly window
+        window = f"{limit.get('number', '?')}h" if limit.get("unit") == 3 else "weekly"
+        lines.append(
+            f"{window} window: used {limit.get('currentValue', '?')}/{limit.get('usage', '?')} "
+            f"credits ({limit.get('percentage', '?')}%), reset {_fmt_epoch_ms(limit.get('nextResetTime'))}"
+        )
+    return lines or ["no quota data"], None
+
+
 async def _usage_litellm(
-    client: httpx.AsyncClient, provider: ProviderConfig, key: str, timeout: float
+    client: httpx.AsyncClient, provider: ProviderConfig, entry: ApiKey, timeout: float
 ) -> tuple[list[str], str | None]:
+    key = entry.key
     url = f"{_origin(provider.base_url)}/key/info"
     headers = {"Authorization": f"Bearer {key}"}
     data, err = await _get_json(client, url, headers, timeout)
@@ -278,8 +351,9 @@ async def _usage_litellm(
 
 
 async def _usage_kimi(
-    client: httpx.AsyncClient, provider: ProviderConfig, key: str, timeout: float
+    client: httpx.AsyncClient, provider: ProviderConfig, entry: ApiKey, timeout: float
 ) -> tuple[list[str], str | None]:
+    key = entry.key
     base = provider.base_url.rstrip("/")
     url = f"{base}/usages" if base.endswith("/v1") else f"{base}/v1/usages"
     headers = {"Authorization": f"Bearer {key}"}
@@ -323,18 +397,31 @@ _ADAPTERS = [
     ("minimax.io", _usage_minimax, "MiniMax coding_plan API"),
     ("api.kimi.com", _usage_kimi, "Kimi Code usages API (unofficial)"),
     ("z.ai", _usage_zai, "z.ai quota API (unofficial)"),
-    ("bigmodel.cn", _usage_zai, "z.ai quota API (unofficial)"),
+    ("bigmodel.cn", _usage_zhipu_team, "zhipu team quota API (unofficial)"),
     ("llm.ustc.edu.cn", _usage_litellm, "LiteLLM /key/info"),
 ]
 
 # Platforms known to have NO key-based usage API — go straight to the probe.
 _PROBE_ONLY_MARKERS = ("xiaomimimo.com",)
 
+# bigmodel.cn marker, reused to explain why a key got no quota adapter.
+_ZHIPU_MARKER = "bigmodel.cn"
+
 
-def _find_adapter(base_url: str):
+def _find_adapter(base_url: str, entry: ApiKey):
+    """First matching adapter for a base_url. Returns (adapter, label).
+
+    A bigmodel.cn (zhipu) team key whose entry lacks organization/project has
+    no quota endpoint to query — the personal coding-plan endpoint does not
+    apply to team keys — so it returns (None, None) and falls through to the
+    availability probe.
+    """
     for marker, adapter, label in _ADAPTERS:
-        if marker in base_url:
-            return adapter, label
+        if marker not in base_url:
+            continue
+        if adapter is _usage_zhipu_team and not (entry.organization and entry.project):
+            return None, None
+        return adapter, label
     return None, None
 
 
@@ -391,10 +478,10 @@ async def check_key_usage(
     if any(marker in provider.base_url for marker in _PROBE_ONLY_MARKERS):
         adapter, method = None, None
     else:
-        adapter, method = _find_adapter(provider.base_url)
+        adapter, method = _find_adapter(provider.base_url, entry)
 
     if adapter is not None:
-        lines, err = await adapter(client, provider, key, timeout)
+        lines, err = await adapter(client, provider, entry, timeout)
         if err is None:
             return UsageResult(provider.name, label, method, True, lines)
         logger.debug("usage adapter %s failed for %s: %s; falling back to probe", method, provider.name, err)
@@ -410,6 +497,10 @@ async def check_key_usage(
     lines, err = await _probe_chat(client, provider, key, timeout)
     method = f'minimal chat probe ("{_PROBE_INPUT}", max_tokens={_PROBE_MAX_TOKENS})'
     if err is None:
+        if _ZHIPU_MARKER in provider.base_url and not (entry.organization and entry.project):
+            lines = lines + [
+                "team quota not queried: set organization/project on this key entry"
+            ]
         return UsageResult(provider.name, label, method, True, lines)
     return UsageResult(provider.name, label, method, False, [err])