coding-proxy 0.4.1a8__tar.gz → 0.4.1a10__tar.gz

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ## [Unreleased]
 
+- feat(zhipu): 新增每模型并发限制（默认 3，可通过 `vendors[zhipu].concurrency` 配置），基于 `asyncio.Semaphore` 实现 FIFO 公平排队，流式与非流式共用同一槽位，与 429 重试机制兼容。
+
 ## [v0.4.0](https://github.com/ThreeFish-AI/coding-proxy/releases/tag/v0.4.0) — 2026-05-01
 
 > [!IMPORTANT]

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-proxy
-Version: 0.4.1a8
+Version: 0.4.1a10
 Summary: A High-Availability, Transparent, and Smart Multi-Vendor Proxy for Claude Code. Support Claude Plans, GitHub Copilot, Google Antigravity, ZAI/GLM, MiniMax, Qwen, Xiaomi, Kimi, Doubao...
 Project-URL: Source Code, https://github.com/ThreeFish-AI/coding-proxy
 Project-URL: User Guide, https://github.com/ThreeFish-AI/coding-proxy/blob/master/docs/user-guide.md

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/docs/agents/issue.md

@@ -230,3 +230,47 @@ SUM(input_tokens + output_tokens
 
 - 历次 PR 中 cache token 字段的引入是渐进式的（schema 已有四列、`log()` 入参齐全、Overview 已全口径消费），但部分聚合视图的口径升级被遗漏；任何向 `usage_log` 增列后，**必须**审计所有 `SUM(input_tokens` / `SUM(output_tokens` 出现处的聚合表达式是否需要同步更新。
 - 跨标签页同一指标（如"总 Tokens"）的口径一致性，建议在添加新视图时主动与 Overview 现有口径做交叉核对，必要时在 SQL 注释中标注口径来源，便于后续 review。
+
+---
+
+## Zhipu vendor 间歇性 `[1210][API 调用参数有误]` 拒绝（诊断阶段）
+
+**问题描述**
+
+Zhipu vendor 作为首选 tier 时，处理 `claude-haiku-* → glm-5-turbo` 的部分请求被上游直接拒绝：
+
+```
+WARNING Tier zhipu semantic rejection
+  (type=invalid_request_error,
+   msg=[1210][API 调用参数有误，请检查文档。][...])
+  [model=claude-haiku-4-5-20251001, messages=1], trying next tier without recording failure
+INFO  Tier anthropic message succeeded (took over from failed tier: zhipu)
+```
+
+失败请求统一表现为 `duration<1s + tokens=[0 0 0 0]`，被 zhipu 在入口校验阶段直接拒绝、未消耗任何 token。两次观察窗口失败率分别为 4%（2026-05-23 22:24，glm-4.7 旧映射）与 27%（2026-05-25 17:26+，glm-5-turbo 当前映射），均触发降级至 anthropic / copilot。
+
+**表因**
+
+`is_semantic_rejection` 检测到 zhipu 返回 `invalid_request_error + 1210` 含「API 调用参数有误」中文标记，判定为语义拒绝，跳过下一层 tier。1210 是智谱官方错误码，[官方文档](https://docs.bigmodel.cn/cn/api/api-code) 定义为「参数格式/类型不符规范」（区别于 1213「必需字段缺失」、1214「字段参数非法」）。
+
+**根因（仍在收集证据）**
+
+PR #244 的初版诊断字段仅覆盖 `thinking / thinking_blocks / cache_control / model / messages`，但 2026-05-25 17:26 后的诊断日志显示失败请求**均不含**上述任何字段。说明真正祸根在更细粒度的参数（system / tools / max_tokens / sampling / metadata / content_types / body_size 等）。
+
+**处理方式（分阶段）**
+
+- **Step 1（PR #244，已合并）**：在 `executor.py::_build_semantic_rejection_diagnostic` 中输出 thinking / cache_control 相关字段 — 但证据反转，覆盖不足以定位真因。
+- **Step 1 v2（本次）**：扩展诊断函数覆盖 `system_kind|blocks(+cc)` / `tools` / `tool_choice` / 采样参数 / `stream` / `metadata_keys` / `content_types` / `body_bytes` 等维度。所有项「仅存在时输出」以控制日志噪声。配套 14 个单元测试（`TestBuildSemanticRejectionDiagnostic`）覆盖各字段组合。
+- **Step 2（待定）**：依据扩展诊断日志的新证据，定位具体祸根参数后再施修复（候选路径：`ZhipuVendor._prepare_request` 参数剥离 / 调用现有 `normalize_for_zhipu` / pre-validation 警告）。
+
+**后续防范**
+
+- **「无证据，不下结论」**：当初版诊断字段无法覆盖根因时，禁止反复猜测，应优先扩展诊断维度抓取更多线索。本次先扩展再修复的迭代节奏可作为同类「黑盒 API 报错」问题的范式。
+- **诊断字段设计原则**：所有诊断项应「仅存在时输出」，避免常态化噪声；输出格式紧凑（`key=val`）便于日志检索；参数值用 `!r:.N` 截断防止巨型对象灌入日志。
+- **错误码差异化**：智谱 12xx 系列错误码语义并不等价（1210 ≠ 1213 ≠ 1214），未来面对类似 `[code][message]` 形式的供应商错误时，应优先查阅其官方错误码字典，避免基于错误消息字面意思的误判。
+
+**同类问题影响与处理注意事项**
+
+- 其他薄透传 vendor（minimax / kimi / doubao / alibaba / xiaomi）共用 `NativeAnthropicVendor._prepare_request`，若它们也开始报「参数错误」类语义拒绝，可复用本次扩展的诊断函数定位差异。
+- 若证据指向 `tools` 字段（如工具 schema 不兼容）、`metadata` 字段（如自定义键被 zhipu 拒收）等具体路径，修复时应优先复用 `convert/vendor_channels.py` 中已有的 `normalize_for_zhipu` / `strip_thinking_blocks` 工具，避免在 vendor 内部重复实现剥离逻辑。
+- 部署 Step 1 v2 后，建议观察至少 48 小时收集足够样本（>20 次失败），通过失败/成功请求形态对比统计找出**唯一差异维度**，再进入 Step 2。

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/docs/arch/config-reference.md

@@ -89,12 +89,13 @@ flowchart TD
 
 ## 5. VendorConfig 弹性字段
 
-| 字段                 | 类型           | 默认值               | 说明                        |
-| -------------------- | -------------- | -------------------- | --------------------------- |
-| `circuit_breaker`    | config \| None | `None`               | 熔断器配置（None = 终端层） |
-| `retry`              | config         | `RetryConfig()`      | 重试策略配置                |
-| `quota_guard`        | config         | `QuotaGuardConfig()` | 日度配额守卫配置            |
-| `weekly_quota_guard` | config         | `QuotaGuardConfig()` | 周度配额守卫配置            |
+| 字段                 | 类型           | 默认值               | 说明                                |
+| -------------------- | -------------- | -------------------- | ----------------------------------- |
+| `circuit_breaker`    | config \| None | `None`               | 熔断器配置（None = 终端层）         |
+| `retry`              | config         | `RetryConfig()`      | 重试策略配置                        |
+| `quota_guard`        | config         | `QuotaGuardConfig()` | 日度配额守卫配置                    |
+| `weekly_quota_guard` | config         | `QuotaGuardConfig()` | 周度配额守卫配置                    |
+| `concurrency`        | config \| None | `None`               | `[zhipu]` 每模型并发限制（详见 5.5） |
 
 <a id="elastic-params"></a>
 
@@ -143,6 +144,33 @@ flowchart TD
 | `error_types`            | list[str] | `["rate_limit_error", "overloaded_error", "api_error"]`                            |
 | `error_message_patterns` | list[str] | `["quota", "limit exceeded", "usage cap", "capacity", "internal network failure"]` |
 
+### 5.5 ZhipuConcurrencyConfig — Zhipu 每模型并发参数
+
+仅对 `vendor: zhipu` 生效，基于 `asyncio.Semaphore` 实现 FIFO 公平排队。
+
+| 字段      | 类型           | 默认值 | 说明                                                                             |
+| --------- | -------------- | ------ | -------------------------------------------------------------------------------- |
+| `default` | int            | `3`    | 全局默认并行度（适用于所有未在 `models` 中显式覆盖的模型）；取值范围 `[1, 20]`   |
+| `models`  | map[str → int] | `{}`   | 按映射后模型名（如 `glm-5v-turbo` / `glm-5.1` / `glm-4.5-air`）自定义并行度上限 |
+
+YAML 示例：
+
+```yaml
+- vendor: zhipu
+  concurrency:
+    default: 3
+    models:
+      glm-5v-turbo: 5
+      glm-5.1: 2
+```
+
+行为语义：
+
+- 信号量按**映射后模型名**键控，与上游真实承载模型对齐；流式与非流式请求共用同一槽位。
+- 槽位满时新请求按 FIFO 顺序排队，直到任一在途请求释放槽位才被唤醒。
+- 429 重试期间持续占用槽位（重试视为同一请求的延续）。
+- 顶层 `concurrency` 字段缺省为 `None` → 转发至 `ZhipuConfig` 时回退默认值 `default=3`；如需完全关闭限流，可在 `ZhipuConfig` 构造层显式置 `null`（一般无需操作）。
+
 ---
 
 ## 6. 供应商专属字段

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "coding-proxy"
-version = "0.4.1a8"
+version = "0.4.1a10"
 description = "A High-Availability, Transparent, and Smart Multi-Vendor Proxy for Claude Code. Support Claude Plans, GitHub Copilot, Google Antigravity, ZAI/GLM, MiniMax, Qwen, Xiaomi, Kimi, Doubao..."
 readme = "README.md"
 requires-python = ">=3.12"

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/config/config.default.yaml

@@ -119,6 +119,14 @@ vendors:
       window_hours: 24.0
       threshold_percent: 95.0
       probe_interval_seconds: 300
+    # 每模型并发限制：默认 3 个并行请求；超出则按 FIFO 排队等待
+    # 可通过 models 字段覆盖单个模型的限制（如 glm-5.1: 5）
+    concurrency:
+      default: 3
+      # models:
+      #   glm-5v-turbo: 3
+      #   glm-5.1: 3
+      #   glm-4.5-air: 3
 
   # Vendor 4: MiniMax（默认禁用，需手动启用并添加到 tiers）
   - vendor: minimax

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/config/routing.py

@@ -9,6 +9,7 @@ from typing import Annotated, Any, Literal
 from pydantic import BaseModel, BeforeValidator, Field, PrivateAttr, model_validator
 
 from .resiliency import CircuitBreakerConfig, QuotaGuardConfig, RetryConfig
+from .vendors import ZhipuConcurrencyConfig
 
 # ── 价格字段解析（$ / ¥ 前缀支持） ──────────────────────────
 
@@ -64,13 +65,13 @@ _NATIVE_ANTHROPIC_FIELDS: frozenset[str] = frozenset(
         "api_key",
     }
 )
-# 向后兼容别名
-_ZHIPU_FIELDS = _NATIVE_ANTHROPIC_FIELDS
+# Zhipu 独占字段：在通用 api_key 基础上增加每模型并发限制
+_ZHIPU_FIELDS: frozenset[str] = _NATIVE_ANTHROPIC_FIELDS | frozenset({"concurrency"})
 
 _VENDOR_EXCLUSIVE_FIELDS: dict[str, frozenset[str]] = {
     "copilot": _COPILOT_FIELDS,
     "antigravity": _ANTIGRAVITY_FIELDS,
-    "zhipu": _NATIVE_ANTHROPIC_FIELDS,
+    "zhipu": _ZHIPU_FIELDS,
     "minimax": _NATIVE_ANTHROPIC_FIELDS,
     "kimi": _NATIVE_ANTHROPIC_FIELDS,
     "doubao": _NATIVE_ANTHROPIC_FIELDS,
@@ -285,6 +286,12 @@ class VendorConfig(BaseModel):
     quota_guard: QuotaGuardConfig = Field(default_factory=QuotaGuardConfig)
     weekly_quota_guard: QuotaGuardConfig = Field(default_factory=QuotaGuardConfig)
 
+    # ── Zhipu 专属：每模型并发限制 ───────────────────────────
+    concurrency: ZhipuConcurrencyConfig | None = Field(
+        default=None,
+        description="[zhipu] 每模型并发限制；None 表示不限并发",
+    )
+
     @model_validator(mode="after")
     def _warn_irrelevant_fields(self) -> VendorConfig:
         """对非当前 vendor 类型的非空专属字段发出 warning."""

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/config/schema.py

@@ -54,6 +54,7 @@ from .vendors import (  # noqa: F401
     KimiConfig,
     MinimaxConfig,
     XiaomiConfig,
+    ZhipuConcurrencyConfig,
     ZhipuConfig,
 )
 
@@ -318,6 +319,7 @@ __all__ = [
     "CopilotConfig",
     "AntigravityConfig",
     "ZhipuConfig",
+    "ZhipuConcurrencyConfig",
     # resiliency
     "CircuitBreakerConfig",
     "RetryConfig",

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/config/vendors.py

@@ -2,7 +2,21 @@
 
 from __future__ import annotations
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+
+
+class ZhipuConcurrencyConfig(BaseModel):
+    """Zhipu 每模型并发限制配置."""
+
+    default: int = Field(default=3, ge=1, le=20, description="全局默认并行度")
+    models: dict[str, int] = Field(
+        default_factory=dict,
+        description="按映射后模型名自定义并行度（覆盖 default）",
+    )
+
+    def get_limit(self, model: str) -> int:
+        """获取指定模型的并行度限制."""
+        return self.models.get(model, self.default)
 
 
 class AnthropicConfig(BaseModel):
@@ -48,6 +62,7 @@ class ZhipuConfig(BaseModel):
     base_url: str = "https://open.bigmodel.cn/api/anthropic"
     api_key: str = ""
     timeout_ms: int = 3000000
+    concurrency: ZhipuConcurrencyConfig = Field(default_factory=ZhipuConcurrencyConfig)
 
 
 class MinimaxConfig(BaseModel):
@@ -100,6 +115,7 @@ __all__ = [
     "CopilotConfig",
     "AntigravityConfig",
     "ZhipuConfig",
+    "ZhipuConcurrencyConfig",
     "MinimaxConfig",
     "KimiConfig",
     "DoubaoConfig",

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/routing/executor.py

@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import json
 import logging
 import re
 import time
@@ -175,6 +176,124 @@ def _build_semantic_rejection_diagnostic(body: dict[str, Any]) -> str:
     return f" [{', '.join(parts)}]" if parts else ""
 
 
+def _build_semantic_rejection_diagnostic(body: dict[str, Any]) -> str:
+    """构建语义拒绝的请求体诊断上下文.
+
+    在 semantic rejection 日志中附加请求体的可疑参数快照，
+    用于定位供应商参数校验失败的具体祸根参数。
+
+    覆盖范围：
+      * 模型 / messages 数（baseline）
+      * thinking 系列顶层参数 + history thinking_blocks 数
+      * system 形态（string / blocks，含 cache_control 计数）
+      * tools 数量 + tool_choice 形态
+      * 采样参数（max_tokens / temperature / top_p / top_k / stop_sequences）
+      * stream / metadata 形态
+      * cache_control 存在性
+      * messages.content 类型分布
+      * 请求体大小估算（json.dumps 字节数）
+    """
+    parts: list[str] = []
+
+    # ── 模型 + 消息数（baseline，始终输出）──
+    parts.append(f"model={body.get('model', 'N/A')}")
+    parts.append(f"messages={len(body.get('messages', []))}")
+
+    # ── 顶层 thinking 系列参数 ──
+    for key in ("thinking", "extended_thinking", "reasoning_effort"):
+        if key in body:
+            val = body[key]
+            parts.append(f"{key}={val!r:.80}")
+
+    # ── system 形态 ──
+    system = body.get("system")
+    if isinstance(system, str):
+        parts.append(f"system_kind=string(len={len(system)})")
+    elif isinstance(system, list):
+        cc_count = sum(
+            1 for item in system if isinstance(item, dict) and "cache_control" in item
+        )
+        if cc_count:
+            parts.append(f"system_blocks={len(system)},cc={cc_count}")
+        else:
+            parts.append(f"system_blocks={len(system)}")
+
+    # ── tools 与 tool_choice ──
+    tools = body.get("tools")
+    if isinstance(tools, list):
+        parts.append(f"tools={len(tools)}")
+    tool_choice = body.get("tool_choice")
+    if tool_choice is not None:
+        parts.append(f"tool_choice={tool_choice!r:.60}")
+
+    # ── 采样参数（仅存在时输出）──
+    for key in ("max_tokens", "temperature", "top_p", "top_k"):
+        if key in body:
+            parts.append(f"{key}={body[key]!r:.40}")
+    stop_sequences = body.get("stop_sequences")
+    if isinstance(stop_sequences, list) and stop_sequences:
+        parts.append(f"stop_sequences={len(stop_sequences)}")
+
+    # ── stream / metadata ──
+    if "stream" in body:
+        parts.append(f"stream={body['stream']}")
+    metadata = body.get("metadata")
+    if isinstance(metadata, dict) and metadata:
+        parts.append(f"metadata_keys={len(metadata)}")
+
+    # ── 会话历史中的 thinking blocks 与 content_types 分布 ──
+    thinking_count = 0
+    content_type_counts: dict[str, int] = {}
+    for msg in body.get("messages", []):
+        content = msg.get("content")
+        if isinstance(content, str):
+            content_type_counts["string"] = content_type_counts.get("string", 0) + 1
+            continue
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            btype = block.get("type")
+            if isinstance(btype, str):
+                content_type_counts[btype] = content_type_counts.get(btype, 0) + 1
+            if btype in ("thinking", "redacted_thinking"):
+                thinking_count += 1
+    if thinking_count:
+        parts.append(f"thinking_blocks_in_history={thinking_count}")
+    if content_type_counts:
+        type_repr = ",".join(f"{k}:{v}" for k, v in sorted(content_type_counts.items()))
+        parts.append(f"content_types={{{type_repr}}}")
+
+    # ── cache_control 存在检测（messages / tools，不含 system 因已单独统计）──
+    has_cc = False
+    sections: list[Any] = []
+    for m in body.get("messages", []):
+        if isinstance(m.get("content"), list):
+            sections.append(m["content"])
+    if isinstance(body.get("tools"), list):
+        sections.append(body["tools"])
+    for section in sections:
+        for item in section:
+            if isinstance(item, dict) and "cache_control" in item:
+                has_cc = True
+                break
+        if has_cc:
+            break
+    if has_cc:
+        parts.append("cache_control_fields=present")
+
+    # ── 请求体大小估算 ──
+    try:
+        body_bytes = len(json.dumps(body, ensure_ascii=False).encode("utf-8"))
+        parts.append(f"body_bytes={body_bytes}")
+    except (TypeError, ValueError):
+        # 极少数情况下 body 含非可序列化对象，跳过
+        pass
+
+    return f" [{', '.join(parts)}]" if parts else ""
+
+
 def _log_http_error_detail(
     tier_name: str,
     exc: Exception,

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/server/factory.py

@@ -156,13 +156,17 @@ def _create_vendor_from_config(
             cfg = _resolve_antigravity_credentials(cfg, token_store)
             return AntigravityVendor(cfg, failover_cfg, mapper)
         case "zhipu":
-            cfg = ZhipuConfig(
-                enabled=vendor_cfg.enabled,
-                base_url=vendor_cfg.base_url
+            zhipu_kwargs: dict[str, Any] = {
+                "enabled": vendor_cfg.enabled,
+                "base_url": vendor_cfg.base_url
                 or "https://open.bigmodel.cn/api/anthropic",
-                api_key=vendor_cfg.api_key,
-                timeout_ms=vendor_cfg.timeout_ms,
-            )
+                "api_key": vendor_cfg.api_key,
+                "timeout_ms": vendor_cfg.timeout_ms,
+            }
+            # 仅当显式配置了 concurrency 时转发，否则使用 ZhipuConfig 默认值
+            if vendor_cfg.concurrency is not None:
+                zhipu_kwargs["concurrency"] = vendor_cfg.concurrency
+            cfg = ZhipuConfig(**zhipu_kwargs)
             return ZhipuVendor(cfg, mapper, failover_cfg)
         case "minimax":
             cfg = MinimaxConfig(

coding_proxy-0.4.1a10/src/coding/proxy/vendors/concurrency.py

@@ -0,0 +1,78 @@
+"""每模型并发限制器 — 基于 asyncio.Semaphore 的公平排队.
+
+为每个映射后的模型（如 ``glm-5v-turbo``）独立维护一个 ``asyncio.Semaphore``，
+确保同一时间点该模型的并行请求数不超过配置的上限。当所有槽位被占满时，
+新请求按 FIFO 顺序排队等待，直到有槽位释放。
+
+设计要点：
+  - **惰性创建**：仅在首次请求到达时才为该模型创建 Semaphore，避免冷启动开销
+  - **FIFO 公平**：``asyncio.Semaphore`` 内部使用 FIFO 队列，天然满足排队语义
+  - **按映射后模型名键控**：与上游真实承载能力对齐，而非按客户端请求名（如 ``claude-sonnet-*``）
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from ..config.vendors import ZhipuConcurrencyConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ModelConcurrencyLimiter:
+    """按模型名提供独立并发槽位的限制器.
+
+    用法::
+
+        limiter = ModelConcurrencyLimiter(config)
+        sem = await limiter.acquire("glm-5v-turbo")
+        try:
+            ...  # 执行请求
+        finally:
+            sem.release()
+    """
+
+    def __init__(self, config: ZhipuConcurrencyConfig) -> None:
+        self._config = config
+        self._semaphores: dict[str, asyncio.Semaphore] = {}
+
+    def _get_semaphore(self, model: str) -> asyncio.Semaphore:
+        """获取（或惰性创建）指定模型的信号量."""
+        sem = self._semaphores.get(model)
+        if sem is None:
+            limit = self._config.get_limit(model)
+            sem = asyncio.Semaphore(limit)
+            self._semaphores[model] = sem
+            logger.debug(
+                "ModelConcurrencyLimiter: created semaphore model=%s limit=%d",
+                model,
+                limit,
+            )
+        return sem
+
+    async def acquire(self, model: str) -> asyncio.Semaphore:
+        """获取指定模型的并发槽位，必要时阻塞排队.
+
+        返回已获取的 Semaphore 实例，调用方负责在请求完成后调用 ``release()``。
+        """
+        sem = self._get_semaphore(model)
+        await sem.acquire()
+        return sem
+
+    def get_diagnostics(self) -> dict[str, dict[str, int]]:
+        """返回每个模型的并发状态快照（用于可观测性）."""
+        snapshot: dict[str, dict[str, int]] = {}
+        for model, sem in self._semaphores.items():
+            limit = self._config.get_limit(model)
+            # asyncio.Semaphore 内部 _value 表示剩余可用槽位
+            available = sem._value  # noqa: SLF001 — 公开 API 未暴露
+            snapshot[model] = {
+                "limit": limit,
+                "in_use": max(limit - available, 0),
+                "available": max(available, 0),
+            }
+        return snapshot
+
+
+__all__ = ["ModelConcurrencyLimiter"]

{coding_proxy-0.4.1a8 → coding_proxy-0.4.1a10}/src/coding/proxy/vendors/zhipu.py

@@ -34,6 +34,7 @@ from ..routing.rate_limit import (
 )
 from ..routing.retry import RetryConfig, calculate_delay
 from .base import VendorResponse
+from .concurrency import ModelConcurrencyLimiter
 from .native_anthropic import NativeAnthropicVendor
 
 logger = logging.getLogger(__name__)
@@ -68,6 +69,12 @@ class ZhipuVendor(NativeAnthropicVendor):
     ) -> None:
         super().__init__(config, model_mapper, failover_config)
         self._rl_retry = _RATE_LIMIT_RETRY
+        # 每模型并发限制器（config.concurrency 为 None 时禁用）
+        self._concurrency_limiter: ModelConcurrencyLimiter | None = (
+            ModelConcurrencyLimiter(config.concurrency)
+            if config.concurrency is not None
+            else None
+        )
 
     # ── 非流式：429 重试 ────────────────────────────────────
 
@@ -76,7 +83,24 @@ class ZhipuVendor(NativeAnthropicVendor):
         request_body: dict[str, Any],
         headers: dict[str, str],
     ) -> VendorResponse:
-        """非流式请求，429 时自动重试."""
+        """非流式请求，429 时自动重试.
+
+        在 429 重试循环外层套上每模型并发槽位获取，确保同一时间点同一模型的
+        在途请求数不超过配置上限；超过时新请求 FIFO 排队等待。
+        """
+        sem = await self._maybe_acquire_concurrency_slot(request_body)
+        try:
+            return await self._send_message_with_retry(request_body, headers)
+        finally:
+            if sem is not None:
+                sem.release()
+
+    async def _send_message_with_retry(
+        self,
+        request_body: dict[str, Any],
+        headers: dict[str, str],
+    ) -> VendorResponse:
+        """原 send_message 主体逻辑（不含并发控制）."""
         max_attempts = self._rl_retry.max_attempts
 
         for attempt in range(max_attempts):
@@ -116,42 +140,71 @@ class ZhipuVendor(NativeAnthropicVendor):
         安全性：429 在 BaseVendor.send_message_stream 中于
         status code 检查阶段即 raise（在任何 chunk yield 之前），
         因此重试不会导致已发出数据不一致。
+
+        在 429 重试循环外层套上每模型并发槽位获取，确保流式请求与非流式请求
+        共用同一信号量，统一限制同一模型的总在途并发数。
         """
+        sem = await self._maybe_acquire_concurrency_slot(request_body)
         max_attempts = self._rl_retry.max_attempts
 
-        for attempt in range(max_attempts):
-            try:
-                # 429 在 status code 检查阶段即 raise（在任何 chunk 之前），
-                # 因此 __anext__ 安全：要么拿到首个 chunk，要么抛异常。
-                ait = super().send_message_stream(request_body, headers)
-                head = await ait.__anext__()
-            except StopAsyncIteration:
-                return
-            except httpx.HTTPStatusError as exc:
-                if exc.response is None or exc.response.status_code != 429:
-                    raise
-                if attempt == max_attempts - 1:
-                    logger.warning(
-                        "Zhipu 429 stream rate limit exhausted after %d attempts",
-                        max_attempts,
+        try:
+            for attempt in range(max_attempts):
+                try:
+                    # 429 在 status code 检查阶段即 raise（在任何 chunk 之前），
+                    # 因此 __anext__ 安全：要么拿到首个 chunk，要么抛异常。
+                    ait = super().send_message_stream(request_body, headers)
+                    head = await ait.__anext__()
+                except StopAsyncIteration:
+                    return
+                except httpx.HTTPStatusError as exc:
+                    if exc.response is None or exc.response.status_code != 429:
+                        raise
+                    if attempt == max_attempts - 1:
+                        logger.warning(
+                            "Zhipu 429 stream rate limit exhausted after %d attempts",
+                            max_attempts,
+                        )
+                        raise
+
+                    delay = self._compute_retry_delay_from_response(
+                        exc.response, attempt
                     )
-                    raise
-
-                delay = self._compute_retry_delay_from_response(exc.response, attempt)
-                logger.info(
-                    "Zhipu 429 stream rate limit, retry %d/%d in %.1fms",
-                    attempt + 1,
-                    max_attempts - 1,
-                    delay,
-                )
-                await asyncio.sleep(delay / 1000.0)
-                continue
-
-            # yield 在 try/except 之外，避免捕获外部 athrow 的异常
-            yield head
-            async for chunk in ait:
-                yield chunk
-            return
+                    logger.info(
+                        "Zhipu 429 stream rate limit, retry %d/%d in %.1fms",
+                        attempt + 1,
+                        max_attempts - 1,
+                        delay,
+                    )
+                    await asyncio.sleep(delay / 1000.0)
+                    continue
+
+                # yield 在 try/except 之外，避免捕获外部 athrow 的异常
+                yield head
+                async for chunk in ait:
+                    yield chunk
+                return
+        finally:
+            if sem is not None:
+                sem.release()
+
+    # ── 并发控制 ────────────────────────────────────────────
+
+    async def _maybe_acquire_concurrency_slot(
+        self,
+        request_body: dict[str, Any],
+    ) -> asyncio.Semaphore | None:
+        """按映射后模型名获取并发槽位；未配置 concurrency 时返回 None.
+
+        ``map_model()`` 是纯同步字典查找，在 Semaphore 等待前调用是安全的，
+        且能确保排队键与上游真实承载模型对齐。
+        """
+        if self._concurrency_limiter is None:
+            return None
+        raw_model = request_body.get("model", "") if request_body else ""
+        mapped_model = self.map_model(raw_model) if raw_model else ""
+        if not mapped_model:
+            return None
+        return await self._concurrency_limiter.acquire(mapped_model)
 
     # ── 延迟计算 ────────────────────────────────────────────