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

coding-proxy 0.5.0tar.gz → 0.5.1a2tar.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.1a2}/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.1a2}/PKG-INFO RENAMED Viewed

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

@@ -1,6 +1,6 @@
 [project]
 name = "coding-proxy"
-version = "0.5.0"
+version = "0.5.1a2"
 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.1a2}/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.1a2}/src/coding/proxy/server/dashboard.py RENAMED Viewed

@@ -89,6 +89,7 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
       --shadow-md: 0 8px 24px rgba(0,0,0,.3);
       --glow-blue: 0 0 0 1px rgba(88,166,255,.1), 0 8px 32px rgba(88,166,255,.04);
       --gradient-primary: linear-gradient(135deg, #667eea, #764ba2);
+      --gap-section: 12px;
     }
     @keyframes fadeInUp {
       from { opacity: 0; transform: translateY(10px); }
@@ -160,7 +161,7 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
       display: grid;
       grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
       gap: 5px;
-      margin-bottom: 24px;
+      margin-bottom: var(--gap-section);
     }
     .kpi-card {
       background: rgba(18,22,30,.7);
@@ -214,13 +215,13 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
       display: grid;
       grid-template-columns: 1fr 2fr;
       gap: 16px;
-      margin-bottom: 16px;
+      margin-bottom: var(--gap-section);
     }
     .charts-grid-2 {
       display: grid;
       grid-template-columns: 1fr 2fr;
       gap: 16px;
-      margin-bottom: 16px;
+      margin-bottom: var(--gap-section);
     }
     .charts-grid > .card,
     .charts-grid-2 > .card {
@@ -356,7 +357,7 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
     /* ── 时间区间选择栏 ── */
     .time-range-bar {
       display: flex; align-items: center; gap: 8px;
-      margin-bottom: 24px; flex-wrap: wrap;
+      margin-bottom: var(--gap-section); flex-wrap: wrap;
       padding: 8px 16px;
       background: rgba(18,22,30,.5);
       border: 1px solid rgba(255,255,255,.04);
@@ -560,7 +561,10 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
     /* ── Model Calling 实时状态 ────────────────────────── */
     .model-calling-card {
-      margin-bottom: 5px;
+      margin-bottom: var(--gap-section);
+    }
+    .model-token-card {
+      margin-bottom: var(--gap-section);
     }
     .mc-empty {
       text-align: center;
@@ -629,6 +633,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;
@@ -787,7 +795,7 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
   </div>
   <!-- Token 用量（按 Vendor / 模型）堆叠图 -->
-  <div class="card" style="margin-bottom:12px">
+  <div class="card model-token-card">
     <div class="card-title" id="title-model-token-timeline">近 7 天 Token 用量（按 Vendor / 模型）</div>
     <div class="chart-with-legend">
       <div class="chart-wrap-xl">
@@ -1282,10 +1290,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 +1308,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 +1350,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.1a2}/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.1a2}/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.1a2/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__tar.gz → 0.5.1a2__tar.gz

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