PyPI - coding-proxy - Versions diffs - 0.5.0__tar.gz → 0.5.1a1__tar.gz - Mend

coding-proxy 0.5.0tar.gz → 0.5.1a1tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (197) hide show

{coding_proxy-0.5.0 → coding_proxy-0.5.1a1}/CHANGELOG.md RENAMED Viewed

@@ -4,6 +4,11 @@
 ## [Unreleased]
+- feat(dashboard): Model Calling 实时监控扩展至全 vendor / 全 model（仅 CC 场景），其他 vendor 在 monitor 模式下仅计数不限流，Zhipu 保留 limited 模式 + FIFO 排队；
+- feat(concurrency): 新增 `peak_pending_recent` 最近 10s 排队峰值追踪，瞬时排队释放后前端仍可见"曾排队 N" 余晖徽章；
+- perf(dashboard): Model Calling 轮询间隔由 5000ms 缩短至 1500ms，提升瞬时排队可观测性；
+- refactor(vendors): `ModelConcurrencyLimiter` 重构为 `ModelConcurrencyController`，统一 monitor / limited 双模式抽象（保留旧名别名）；并发控制由 vendor 内部迁移至 executor 层 `track_in_flight` 包裹，行为对所有 vendor 一致；
 ## [v0.5.0](https://github.com/ThreeFish-AI/coding-proxy/releases/tag/v0.5.0) - 2026-05-27
 > [!IMPORTANT]

{coding_proxy-0.5.0 → coding_proxy-0.5.1a1}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-proxy
-Version: 0.5.0
+Version: 0.5.1a1
 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.5.0 → coding_proxy-0.5.1a1}/pyproject.toml RENAMED Viewed

@@ -1,6 +1,6 @@
 [project]
 name = "coding-proxy"
-version = "0.5.0"
+version = "0.5.1a1"
 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.5.0 → coding_proxy-0.5.1a1}/src/coding/proxy/routing/executor.py RENAMED Viewed

@@ -689,15 +689,17 @@ class _RouteExecutor:
                     tier.name, failed_tier_name, session_record, body
                 )
                 body_for_tier = self._prepare_body_for_tier(body, tier, source_vendor)
-                async for chunk in tier.vendor.send_message_stream(
-                    body_for_tier, headers
-                ):
-                    parse_usage_from_chunk(
-                        chunk,
-                        usage,
-                        vendor_label=_VENDOR_PROTOCOL_LABEL_MAP.get(tier.name),
-                    )
-                    yield chunk, tier.name
+                _mapped_model = tier.vendor.map_model(body.get("model", ""))
+                async with tier.vendor.track_in_flight(_mapped_model):
+                    async for chunk in tier.vendor.send_message_stream(
+                        body_for_tier, headers
+                    ):
+                        parse_usage_from_chunk(
+                            chunk,
+                            usage,
+                            vendor_label=_VENDOR_PROTOCOL_LABEL_MAP.get(tier.name),
+                        )
+                        yield chunk, tier.name
                 info = self._recorder.build_usage_info(usage)
                 if has_missing_input_usage_signals(info):
@@ -863,7 +865,9 @@ class _RouteExecutor:
                     tier.name, failed_tier_name, session_record, body
                 )
                 body_for_tier = self._prepare_body_for_tier(body, tier, source_vendor)
-                resp = await tier.vendor.send_message(body_for_tier, headers)
+                _mapped_model = tier.vendor.map_model(body.get("model", ""))
+                async with tier.vendor.track_in_flight(_mapped_model):
+                    resp = await tier.vendor.send_message(body_for_tier, headers)
                 if resp.status_code < 400:
                     duration = int((time.monotonic() - start) * 1000)

{coding_proxy-0.5.0 → coding_proxy-0.5.1a1}/src/coding/proxy/server/dashboard.py RENAMED Viewed

@@ -629,6 +629,10 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
       background: rgba(251,146,60,.15);
       color: #fb923c;
     }
+    .mc-badge-peak {
+      background: rgba(148,163,184,.12);
+      color: #94a3b8;
+    }
     .mc-badge-active {
       background: rgba(74,222,128,.12);
       color: #4ade80;
@@ -1282,10 +1286,12 @@ function updateModelCalling(status) {
       models.push({
         vendor: tier.name,
         model: model,
-        limit: d.limit || 0,
+        mode: d.mode || 'limited',
+        limit: d.limit,
         in_use: d.in_use || 0,
-        available: d.available || 0,
+        available: d.available,
         pending: d.pending || 0,
+        peak_pending_recent: d.peak_pending_recent || 0,
       });
     }
   }
@@ -1298,18 +1304,33 @@ function updateModelCalling(status) {
   var html = '<div class="mc-grid">';
   for (var k = 0; k < models.length; k++) {
     var m = models[k];
-    var pct = m.limit > 0 ? Math.round((m.in_use / m.limit) * 100) : 0;
-    var barClass = pct <= 50 ? 'mc-low' : (pct <= 80 ? 'mc-mid' : 'mc-high');
-    html += '<div class="mc-model-row">'
-      + '<span class="mc-model-name">' + escapeHtml(m.vendor + '/' + m.model) + '</span>'
-      + '<div class="mc-bar-wrap"><div class="mc-bar-fill ' + barClass + '" style="width:' + pct + '%"></div></div>'
-      + '<div class="mc-stats">'
-      + '<span class="mc-badge mc-badge-active">' + m.in_use
-      + '/<span class="mc-limit-editable" data-tier="' + escapeHtml(m.vendor) + '" data-model="' + escapeHtml(m.model) + '" data-limit="' + m.limit + '" title="点击修改并行度">' + m.limit + '</span></span>'
-      + (m.pending > 0 ? '<span class="mc-badge mc-badge-pending">⏳ ' + m.pending + '</span>' : '')
-      + '</div>'
-      + '</div>';
+    if (m.mode === 'monitor') {
+      // monitor 模式：纯计数徽章，无 limit/进度条
+      html += '<div class="mc-model-row">'
+        + '<span class="mc-model-name">' + escapeHtml(m.vendor + '/' + m.model) + '</span>'
+        + '<div class="mc-bar-wrap"></div>'
+        + '<div class="mc-stats">'
+        + '<span class="mc-badge mc-badge-active">' + m.in_use + '</span>'
+        + '</div>'
+        + '</div>';
+    } else {
+      // limited 模式：保留现有渲染（进度条 + limit 编辑）
+      var limit = m.limit || 0;
+      var pct = limit > 0 ? Math.round((m.in_use / limit) * 100) : 0;
+      var barClass = pct <= 50 ? 'mc-low' : (pct <= 80 ? 'mc-mid' : 'mc-high');
+      html += '<div class="mc-model-row">'
+        + '<span class="mc-model-name">' + escapeHtml(m.vendor + '/' + m.model) + '</span>'
+        + '<div class="mc-bar-wrap"><div class="mc-bar-fill ' + barClass + '" style="width:' + pct + '%"></div></div>'
+        + '<div class="mc-stats">'
+        + '<span class="mc-badge mc-badge-active">' + m.in_use
+        + '/<span class="mc-limit-editable" data-tier="' + escapeHtml(m.vendor) + '" data-model="' + escapeHtml(m.model) + '" data-limit="' + limit + '" title="点击修改并行度">' + limit + '</span></span>'
+        + (m.pending > 0 ? '<span class="mc-badge mc-badge-pending">⏳ ' + m.pending + '</span>' : '')
+        + (m.pending === 0 && m.peak_pending_recent > 0 ? '<span class="mc-badge mc-badge-peak">🕘 曾排队 ' + m.peak_pending_recent + '</span>' : '')
+        + '</div>'
+        + '</div>';
+    }
   }
   html += '</div>';
   wrap.innerHTML = html;
@@ -1325,7 +1346,7 @@ function startModelCallingPoll() {
     }).catch(function() {});
   }
   tick();
-  _mcTimer = setInterval(tick, 5000);
+  _mcTimer = setInterval(tick, 1500);
 }
 function stopModelCallingPoll() {
   if (_mcTimer) { clearInterval(_mcTimer); _mcTimer = null; }

{coding_proxy-0.5.0 → coding_proxy-0.5.1a1}/src/coding/proxy/server/routes.py RENAMED Viewed

@@ -254,16 +254,15 @@ def register_concurrency_route(app: Any, router: Any) -> None:
         for tier in router.tiers:
             if tier.name == tier_name:
                 vendor = tier.vendor
-                update_fn = getattr(vendor, "update_concurrency", None)
-                if update_fn is None:
+                try:
+                    vendor.update_concurrency(model, limit)
+                except ValueError as exc:
                     return json_error_response(
-                        400,
+                        422,
                         error_type="invalid_request_error",
-                        message=f"vendor '{tier_name}' does not support concurrency",
+                        message=str(exc),
                     )
-                try:
-                    update_fn(model, limit)
-                except (ValueError, AttributeError) as exc:
+                except AttributeError as exc:
                     return json_error_response(
                         400, error_type="invalid_request_error", message=str(exc)
                     )

{coding_proxy-0.5.0 → coding_proxy-0.5.1a1}/src/coding/proxy/vendors/base.py RENAMED Viewed

@@ -44,6 +44,7 @@ from ..compat.canonical import (
 )
 from ..compat.session_store import CompatSessionRecord
 from ..config.schema import FailoverConfig
+from .concurrency import ModelConcurrencyController
 logger = logging.getLogger(__name__)
@@ -63,6 +64,8 @@ class BaseVendor(ABC):
         self._client: httpx.AsyncClient | None = None
         self._compat_trace: CompatibilityTrace | None = None
         self._compat_session_record: CompatSessionRecord | None = None
+        # 默认 monitor 模式（仅计数不限流）；子类可覆盖为 limited 模式
+        self._concurrency_controller = ModelConcurrencyController(None)
     def _get_client(self) -> httpx.AsyncClient:
         if self._client is None or self._client.is_closed:
@@ -246,8 +249,30 @@ class BaseVendor(ABC):
         diagnostics: dict[str, Any] = {}
         if self._compat_trace is not None:
             diagnostics["compat"] = self._compat_trace.to_dict()
+        concurrency = self._concurrency_controller.get_diagnostics()
+        if concurrency:
+            diagnostics["concurrency"] = concurrency
         return diagnostics
+    def track_in_flight(self, mapped_model: str):
+        """返回用于追踪在途请求的异步上下文管理器.
+        空 model name 时返回 no-op context（防御性处理）。
+        """
+        if not mapped_model:
+            from contextlib import nullcontext
+            return nullcontext()
+        return self._concurrency_controller.track(mapped_model)
+    def update_concurrency(self, model: str, limit: int) -> None:
+        """运行时更新指定模型的并发限制.
+        默认实现委托给 ``_concurrency_controller.set_limit``。
+        monitor 模式下抛 ``ValueError``。
+        """
+        self._concurrency_controller.set_limit(model, limit)
     def should_trigger_failover(
         self, status_code: int, body: dict[str, Any] | None
     ) -> bool:

coding_proxy-0.5.1a1/src/coding/proxy/vendors/concurrency.py ADDED Viewed

@@ -0,0 +1,251 @@
+"""统一并发控制器 — 支持监控 (monitor) 与限流 (limited) 双模式.
+为每个映射后的模型（如 ``glm-5v-turbo``）独立维护一个 ``_ConcurrencySlot``，
+根据模式提供不同语义：
+  **monitor 模式** (config=None)
+    - 仅计数 ``in_use``，不做排队与限流
+    - ``pending`` 恒为 0，``available`` / ``limit`` 为 None
+    - 所有 vendor 默认使用此模式
+  **limited 模式** (config 非 None)
+    - ``in_use`` 不超过 ``limit`` 时立即获取，超限时 FIFO 排队
+    - ``pending`` 反映当前排队数，``peak_pending_recent`` 记录最近 10s 峰值
+    - 由 ZhipuVendor 等需限流的 vendor 启用
+设计要点：
+  - **惰性创建**：仅在首次请求到达时才为该模型创建 Slot，避免冷启动开销
+  - **FIFO 公平**：``asyncio.Event`` + while 循环天然满足 FIFO 排队语义（limited 模式）
+  - **动态调整**：支持运行时修改 per-model limit，无需重启进程
+  - **按映射后模型名键控**：与上游真实承载能力对齐，而非按客户端请求名
+  - **峰值余晖**：记录 ``peak_pending_recent`` 使瞬时排队可观测
+"""
+from __future__ import annotations
+import asyncio
+import logging
+import time
+from collections import deque
+from contextlib import asynccontextmanager
+from typing import Any, Literal
+from ..config.vendors import ZhipuConcurrencyConfig
+logger = logging.getLogger(__name__)
+# peak_pending_recent 滑窗宽度（秒）
+_PEAK_WINDOW_SECONDS = 10.0
+class _ConcurrencySlot:
+    """支持双模式的并发槽位.
+    ``limit=None`` (monitor) 时 acquire 走 fast path，仅计数。
+    ``limit>0`` (limited) 时在满槽位后 FIFO 排队等待。
+    """
+    def __init__(self, limit: int | None) -> None:
+        self._limit = limit
+        self._in_use: int = 0
+        self._pending: int = 0
+        self._wake = asyncio.Event()
+        self._wake.set()
+        # peak_pending_recent 追踪：存储 (timestamp, pending_value) 元组
+        self._peak_samples: deque[tuple[float, int]] = deque()
+    async def acquire(self) -> None:
+        """获取一个并发槽位.
+        monitor 模式 (limit=None)：仅 in_use++，永不排队。
+        limited 模式 (limit>0)：满槽时阻塞等待。
+        """
+        # monitor 模式：仅计数
+        if self._limit is None:
+            self._in_use += 1
+            return
+        # limited — fast path
+        if self._in_use < self._limit:
+            self._in_use += 1
+            return
+        # limited — slow path: FIFO 排队
+        self._pending += 1
+        self._observe_peak()
+        try:
+            while True:
+                self._wake.clear()
+                await self._wake.wait()
+                if self._in_use < self._limit:
+                    self._in_use += 1
+                    return
+        finally:
+            self._pending -= 1
+    def release(self) -> None:
+        """释放一个并发槽位."""
+        self._in_use = max(0, self._in_use - 1)
+        if self._limit is not None:
+            self._wake.set()
+    def set_limit(self, new_limit: int) -> None:
+        """动态调整并发上限.
+        仅 limited 模式有效；monitor 模式调用抛 ValueError。
+        """
+        if self._limit is None:
+            msg = "Cannot set limit on monitor-only slot"
+            raise ValueError(msg)
+        self._limit = new_limit
+        self._wake.set()
+    def _observe_peak(self) -> None:
+        """记录当前 pending 值作为峰值采样点."""
+        now = time.monotonic()
+        self._peak_samples.append((now, self._pending))
+    def _get_peak_pending_recent(self) -> int:
+        """获取最近窗口内的 peak pending 值."""
+        cutoff = time.monotonic() - _PEAK_WINDOW_SECONDS
+        # 剔除过期采样
+        while self._peak_samples and self._peak_samples[0][0] < cutoff:
+            self._peak_samples.popleft()
+        if not self._peak_samples:
+            return 0
+        return max(v for _, v in self._peak_samples)
+    @property
+    def limit(self) -> int | None:
+        return self._limit
+    @property
+    def in_use(self) -> int:
+        return self._in_use
+    @property
+    def available(self) -> int | None:
+        if self._limit is None:
+            return None
+        return max(0, self._limit - self._in_use)
+    @property
+    def pending(self) -> int:
+        return self._pending
+    @property
+    def peak_pending_recent(self) -> int:
+        return self._get_peak_pending_recent()
+class ModelConcurrencyController:
+    """按模型名提供独立并发槽位的控制器.
+    用法::
+        # monitor 模式（默认）
+        ctrl = ModelConcurrencyController(None)
+        async with ctrl.track("model-a"):
+            ...  # 执行请求
+        # limited 模式（Zhipu 等）
+        ctrl = ModelConcurrencyController(config)
+        async with ctrl.track("glm-5v-turbo"):
+            ...  # 满槽时排队等待
+    """
+    def __init__(self, config: ZhipuConcurrencyConfig | None) -> None:
+        self._config = config
+        self._slots: dict[str, _ConcurrencySlot] = {}
+    @property
+    def mode(self) -> Literal["monitor", "limited"]:
+        """当前控制器模式."""
+        return "limited" if self._config is not None else "monitor"
+    def _get_or_create_slot(self, model: str) -> _ConcurrencySlot:
+        """获取（或惰性创建）指定模型的并发槽位."""
+        slot = self._slots.get(model)
+        if slot is None:
+            if self._config is not None:
+                limit = self._config.get_limit(model)
+            else:
+                limit = None
+            slot = _ConcurrencySlot(limit)
+            self._slots[model] = slot
+            if self._config is not None:
+                logger.debug(
+                    "ModelConcurrencyController: created slot mode=limited "
+                    "model=%s limit=%d",
+                    model,
+                    limit,
+                )
+            else:
+                logger.debug(
+                    "ModelConcurrencyController: created slot mode=monitor model=%s",
+                    model,
+                )
+        return slot
+    @asynccontextmanager
+    async def track(self, model: str):
+        """异步上下文管理器：获取 → 执行 → 释放.
+        用法::
+            async with controller.track("glm-5v-turbo"):
+                await vendor.send_message(...)
+        """
+        slot = self._get_or_create_slot(model)
+        await slot.acquire()
+        try:
+            yield
+        finally:
+            slot.release()
+    def set_limit(self, model: str, new_limit: int) -> None:
+        """运行时修改指定模型的并发上限.
+        仅 limited 模式支持；monitor 模式抛 ValueError。
+        """
+        if self._config is None:
+            msg = f"vendor is monitor-only; cannot update limit for model '{model}'"
+            raise ValueError(msg)
+        slot = self._slots.get(model)
+        if slot is None:
+            slot = _ConcurrencySlot(new_limit)
+            self._slots[model] = slot
+        else:
+            slot.set_limit(new_limit)
+        self._config.models[model] = new_limit
+        logger.info(
+            "ModelConcurrencyController: updated limit model=%s new_limit=%d",
+            model,
+            new_limit,
+        )
+    def get_diagnostics(self) -> dict[str, dict[str, Any]]:
+        """返回每个模型的并发状态快照（用于可观测性）."""
+        snapshot: dict[str, dict[str, Any]] = {}
+        mode = self.mode
+        for model, slot in self._slots.items():
+            entry: dict[str, Any] = {
+                "mode": mode,
+                "in_use": slot.in_use,
+                "pending": slot.pending,
+                "peak_pending_recent": slot.peak_pending_recent,
+            }
+            if mode == "limited":
+                entry["limit"] = slot.limit
+                entry["available"] = slot.available
+            else:
+                entry["limit"] = None
+                entry["available"] = None
+            snapshot[model] = entry
+        return snapshot
+# 向后兼容别名
+ModelConcurrencyLimiter = ModelConcurrencyController
+__all__ = ["ModelConcurrencyController", "ModelConcurrencyLimiter"]

{coding_proxy-0.5.0 → coding_proxy-0.5.1a1}/src/coding/proxy/vendors/zhipu.py RENAMED Viewed

@@ -17,6 +17,11 @@ Anthropic Messages API 协议，本模块做以下适配：
   - max_attempt = 5（1 初始 + 4 重试）
   - 指数退避 + Full Jitter（1s → 2s → 4s → 8s）
   - 优先尊重 server retry-after header
+并发限流由 BaseVendor._concurrency_controller 统一管控
+（limited 模式），在 executor 层通过 ``track_in_flight`` 触发，
+slot 跨 429 重试自然持有（executor 的 async with 包裹整个
+send_message/send_message_stream 调用链）。
 """
 from __future__ import annotations
@@ -37,7 +42,7 @@ from ..routing.rate_limit import (
 )
 from ..routing.retry import RetryConfig, calculate_delay
 from .base import VendorResponse
-from .concurrency import ModelConcurrencyLimiter
+from .concurrency import ModelConcurrencyController
 from .native_anthropic import NativeAnthropicVendor
 logger = logging.getLogger(__name__)
@@ -59,6 +64,7 @@ class ZhipuVendor(NativeAnthropicVendor):
     仅替换模型名和认证头，其余原样透传。
     429 Rate Limit 时自动重试（指数退避），降低 failover 频率。
+    并发限流由 BaseVendor._concurrency_controller 统一管控。
     """
     _vendor_name = "zhipu"
@@ -72,12 +78,8 @@ 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
-        )
+        # 覆盖 BaseVendor 默认的 monitor 模式为 limited 模式
+        self._concurrency_controller = ModelConcurrencyController(config.concurrency)
     # ── 首选 tier 参数兼容转换 ────────────────────────────────
@@ -129,24 +131,7 @@ class ZhipuVendor(NativeAnthropicVendor):
         request_body: dict[str, Any],
         headers: dict[str, str],
     ) -> VendorResponse:
-        """非流式请求，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 主体逻辑（不含并发控制）."""
+        """非流式请求，429 时自动重试."""
         max_attempts = self._rl_retry.max_attempts
         for attempt in range(max_attempts):
@@ -186,87 +171,42 @@ 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
-        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
-                    )
-                    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
+        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
-        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)
-    # ── 诊断信息 ─────────────────────────────────────────────
-    def get_diagnostics(self) -> dict[str, Any]:
-        """返回供应商运行时诊断信息，包含每模型并发状态."""
-        diagnostics = super().get_diagnostics()
-        if self._concurrency_limiter is not None:
-            diagnostics["concurrency"] = self._concurrency_limiter.get_diagnostics()
-        return diagnostics
-    def update_concurrency(self, model: str, limit: int) -> None:
-        """运行时更新指定模型的并发限制."""
-        if self._concurrency_limiter is None:
-            msg = "Concurrency limiter is not enabled for this vendor"
-            raise ValueError(msg)
-        self._concurrency_limiter.set_limit(model, limit)
+            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)
+                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
     # ── 延迟计算 ────────────────────────────────────────────

coding-proxy 0.5.0__tar.gz → 0.5.1a1__tar.gz

coding-proxy 0.5.0tar.gz → 0.5.1a1tar.gz