coding-proxy 0.4.1a12__tar.gz → 0.5.1a1__tar.gz

{coding_proxy-0.4.1a12 → coding_proxy-0.5.1a1}/AGENTS.md

@@ -44,14 +44,15 @@
   1. **Python**: 严禁使用 pip/poetry，**必须**统一使用 `uv` 进行包管理与脚本执行（如 `uv run`）；
   2. **JavaScript/TypeScript**: 严禁使用 npm/yarn，**必须**统一使用 `pnpm` 进行包管理与脚本执行；
 - **Database Management**: 谨慎操作，数据迁移、测试等操作严禁将现有数据删除，谨慎操作数据迁移的回滚，防止数据被清理。
+- **In-depth and close to the facts**：系统且全面地进行问题的分析，深入贴近事实，如有疑问，需先发问，不要乱做决定。
 - **Browser Validation Protocol (浏览器验证准则)**：Agent 不得自行完成、绕过或模拟任何 OAuth / SSO 认证流程，所有登录态均来源于用户已认证的 Chrome 主 profile（真实用户登录态）。完整协议（连通性自检、凭证管理、E2E 集成、实机回归等）详见 [浏览器验证协议](./docs/agents/browser-validation.md)；
   1. **安全红线**：禁止在 Sandbox 浏览器中跳转 Google 同意屏；禁止以模拟用户或第三方账号替代真实登录态；禁止要求用户在 chat 中粘贴密码、Cookie 或验证码；
 - **Knowledge Map (知识索引)**：项目所有文档索引统一维护在 [知识索引](./docs/agents/knowledge-map.md)，并在文档目录变更时即时同步跟新；
 - **Documentation Standards (文档规范)**：
-  1. **Visual Documentation (图文并茂)**: 对于复杂逻辑，优先 **Mermaid Visualization Norms (Mermaid 可视化规范)**，构建“图文并茂”的直观文档；
+  1. **Visual Documentation (图文并茂)**: 对于复杂逻辑，优先 **Mermaid Visualization Norms (Mermaid 可视化规范)**，构建”图文并茂”的直观文档；
      - **色彩语义与兼容性**：为图表节点配置具备语义辨识度的色彩，并确保在深色模式（Dark Mode）下具有极高的对比度与清晰度；
      - **逻辑模块化解构**：针对业务跨度较大的架构流程，强制采用 `subgraph` 容器进行层级解构与边界划分，以增强图表的自解说（Self-explaining）能力；
   2. **语言叙事**：用语精准，叙事完备，行文专业，聚焦核心，篇幅精炼，形象具体，体现真实作用与用户吸引性，字数恰当；
-  3. **Direct Hyperlinking (直接跳转)**: 在文档中提及 Repo 内其他资源（文档/代码）时，**必须**构建可跳转的相对路径链接（如 `[Doc Name](./path.md)`），严禁使用“死文本”引用，以降低信息检索熵；
+  3. **Direct Hyperlinking (直接跳转)**: 在文档中提及 Repo 内其他资源（文档/代码）时，**必须**构建可跳转的相对路径链接（如 `[Doc Name](./path.md)`），严禁使用”死文本”引用，以降低信息检索熵；
   4. **实操截图**：文档需要引入必要的浏览器实操截图时，需自行通过默认浏览器打开相关页面，通过实操现场截图并保留到文档路径进行文档引用；
 - **Reference Specifications (IEEE)**：为保障工程决策的可追溯性与学术严谨性，核心引用需遵循 [reference-specifications.md](docs/agents/reference-specifications.md)IEEE 标准引用格式；

{coding_proxy-0.4.1a12 → coding_proxy-0.5.1a1}/CHANGELOG.md

@@ -4,7 +4,34 @@
 
 ## [Unreleased]
 
-- feat(zhipu): 新增每模型并发限制（默认 3，可通过 `vendors[zhipu].concurrency` 配置），基于 `asyncio.Semaphore` 实现 FIFO 公平排队，流式与非流式共用同一槽位，与 429 重试机制兼容。
+- 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]
+>
+> **🚀 Model Calling 实时状态！**
+>
+> 模型并发与排队深度一目了然，运行时动态调整每个模型并行度，预防 vendor 侧的 429 幺蛾子。
+
+![model-calling](assets/model-calling-v0.5.0.png)
+
+### ✨ 核心亮点
+
+- feat(concurrency): 新增 Model Calling 实时状态模块，可视化每模型并发与排队深度，支持运行时动态修改每模型并行度 (#250) (#251)
+- feat(zhipu): 新增每模型并发限制，默认 3 个并行请求 FIFO 排队 (#248)
+- feat(zhipu): 为 429 Rate Limit 添加指数退避重试挽回机制 (#242)
+
+### 🔧 更多特性
+
+- fix(antigravity): 修复 v1internal 模式检测逻辑并新增 E2E 测试; (#234)
+- fix(routes): 修复 count_tokens 路由对 target_vendor.name 的错误属性访问; (#235)
+- fix(vendor-channels): 修复 zhipu→anthropic 通道 tool_use/tool_result 配对漏洞; (#236)
+- fix(native-api): 修复 Gemini :verb 路径中 %3A URL 编码导致上游 400 的兼容问题; (#237)
+- fix(zhipu): 诊断首选 tier 语义拒绝降级问题，增强可观测性并提取跨供应商清洗共享函数 (#243)
 
 ## [v0.4.0](https://github.com/ThreeFish-AI/coding-proxy/releases/tag/v0.4.0) — 2026-05-01
 

{coding_proxy-0.4.1a12 → coding_proxy-0.5.1a1}/PKG-INFO

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

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

@@ -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.4.1a12 → coding_proxy-0.5.1a1}/src/coding/proxy/server/dashboard.py

@@ -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.4.1a12 → coding_proxy-0.5.1a1}/src/coding/proxy/server/routes.py

@@ -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.4.1a12 → coding_proxy-0.5.1a1}/src/coding/proxy/vendors/base.py

@@ -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

@@ -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"]