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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-proxy
-Version: 0.4.1a10
+Version: 0.4.1a11
 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.1a10 → coding_proxy-0.4.1a11}/docs/agents/issue.md

@@ -253,15 +253,19 @@ INFO  Tier anthropic message succeeded (took over from failed tier: zhipu)
 
 `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 等）。
+PR #247 (Step 1 v2) 部署后，2026-05-26 16:30–16:31 的诊断日志显示 8 次连续拒绝**全部携带 `thinking={"type": "adaptive"}`**（Anthropic Claude 4.x 新增的参数类型），而同一时段其他会话的请求持续成功。之前 curl 测试仅验证了 `{"type": "enabled"}`，未覆盖 `adaptive` 类型。GLM 可能不支持此特定类型值，导致 [1210] 参数校验失败。
 
 **处理方式（分阶段）**
 
 - **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 警告）。
+- **Step 1 v2（PR #247，已合并）**：扩展诊断函数覆盖 `system_kind|blocks(+cc)` / `tools` / `tool_choice` / 采样参数 / `stream` / `metadata_keys` / `content_types` / `body_bytes` 等维度。所有项「仅存在时输出」以控制日志噪声。配套 14 个单元测试（`TestBuildSemanticRejectionDiagnostic`）覆盖各字段组合。
+- **Step 2（进行中）**：基于 Step 1 v2 的日志证据，在 `ZhipuVendor._prepare_request` 中实现 **兼容转换**（而非移除）：
+  - `thinking.type="adaptive"` → `{"type": "enabled", "budget_tokens": 16000}`（保留 thinking 能力）
+  - 新增 `_build_zhipu_request_snapshot` 诊断快照，同时覆盖成功/失败请求，建立可对比证据链
+  - 扩展语义拒绝日志的错误体截断限制（200 → 500 字符），保留完整字段级诊断
+  - `metadata` 暂不处理（待进一步诊断确认兼容性）
 
 **后续防范**
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "coding-proxy"
-version = "0.4.1a10"
+version = "0.4.1a11"
 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.1a10 → coding_proxy-0.4.1a11}/src/coding/proxy/convert/vendor_channels.py

@@ -369,8 +369,10 @@ def _strip_cache_control(body: dict[str, Any]) -> int:
 
 # ── zhipu 共享清洗函数 ──────────────────────────────────────────
 
-# 跨供应商转换时主动剥离的顶层参数（首选 tier 场景由 _prepare_request 原样透传，
-# GLM 原生支持 thinking / 静默忽略 cache_control 和 reasoning_effort，不会触发 400）。
+# 跨供应商转换时主动剥离的顶层参数。
+# 首选 tier 场景的 thinking.type=adaptive 兼容转换由
+# ZhipuVendor._prepare_request 处理（转换为 enabled + budget，保留功能），
+# 此处仅负责 failover 路径的全量剥离（跨供应商 thinking signature 失效）。
 _ZHIPU_UNSUPPORTED_PARAMS: frozenset[str] = frozenset(
     {"thinking", "extended_thinking", "reasoning_effort"}
 )

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

@@ -129,50 +129,116 @@ 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}")
-    # 会话历史中的 thinking blocks
+
+    # ── 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 isinstance(block, dict) and block.get("type") in (
-                "thinking",
-                "redacted_thinking",
-            ):
+            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}")
-    # cache_control 存在检测
+    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
-    for section in (
-        body.get("system", []) if isinstance(body.get("system"), list) else [],
-        *(
-            m.get("content", [])
-            for m in body.get("messages", [])
-            if isinstance(m.get("content"), list)
-        ),
-        body.get("tools", []),
-    ):
-        if isinstance(section, list):
-            for item in section:
-                if isinstance(item, dict) and "cache_control" in item:
-                    has_cc = True
-                    break
+    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")
-    # 模型 + 消息数
-    parts.append(f"model={body.get('model', 'N/A')}")
-    parts.append(f"messages={len(body.get('messages', []))}")
+
+    # ── 请求体大小估算 ──
+    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 ""
 
 
@@ -860,12 +926,15 @@ class _RouteExecutor:
 
                 if not is_last and is_semantic:
                     diagnostic = _build_semantic_rejection_diagnostic(body)
+                    # zhipu 等供应商的错误体含字段级诊断（如 [1210] 错误码 + request_id），
+                    # 500 字符足以覆盖完整错误体，避免截断丢失关键细节
+                    err_msg = (resp.error_message or "N/A")[:500]
                     logger.warning(
                         "Tier %s semantic rejection (type=%s, msg=%s)%s, "
                         "trying next tier without recording failure",
                         tier.name,
                         resp.error_type or resp.status_code,
-                        (resp.error_message or "N/A")[:200],
+                        err_msg,
                         diagnostic,
                     )
                     failed_tier_name = tier.name
@@ -1100,14 +1169,16 @@ class _RouteExecutor:
             if semantic_rejection and not is_last:
                 if request_body is not None:
                     diagnostic = _build_semantic_rejection_diagnostic(request_body)
+                    stream_err_msg = (
+                        error.get("message") if isinstance(error, dict) else "N/A"
+                    )
+                    # 扩展至 500 字符以保留完整字段级诊断信息
                     logger.warning(
                         "Tier %s stream semantic rejection (type=%s, msg=%s)%s, "
                         "trying next tier without recording failure",
                         tier.name,
                         error.get("type") if isinstance(error, dict) else None,
-                        (error.get("message") if isinstance(error, dict) else "N/A")[
-                            :200
-                        ],
+                        stream_err_msg[:500],
                         diagnostic,
                     )
                 return True, tier.name, exc

{coding_proxy-0.4.1a10 → coding_proxy-0.4.1a11}/src/coding/proxy/server/dashboard.py

@@ -557,6 +557,89 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
     .tab-btn:focus-visible { outline: 2px solid var(--accent-blue); outline-offset: 2px; }
     .tab-pane { display: none; }
     .tab-pane.active { display: block; }
+
+    /* ── Model Calling 实时状态 ────────────────────────── */
+    .model-calling-card {
+      margin-bottom: 5px;
+    }
+    .mc-empty {
+      text-align: center;
+      color: var(--text-muted);
+      padding: 16px 0;
+      font-size: 13px;
+    }
+    .mc-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+      gap: 8px;
+    }
+    .mc-model-row {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      padding: 8px 12px;
+      background: var(--bg-secondary);
+      border-radius: var(--radius-sm);
+      border: 1px solid var(--border-subtle);
+    }
+    .mc-model-name {
+      font-family: 'JetBrains Mono', monospace;
+      font-size: 12px;
+      color: var(--text-primary);
+      min-width: 140px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .mc-bar-wrap {
+      flex: 1;
+      min-width: 60px;
+      height: 6px;
+      background: rgba(255,255,255,.06);
+      border-radius: 3px;
+      overflow: hidden;
+    }
+    .mc-bar-fill {
+      height: 100%;
+      border-radius: 3px;
+      transition: width .3s ease, background .3s ease;
+    }
+    .mc-bar-fill.mc-low { background: var(--accent-green); }
+    .mc-bar-fill.mc-mid { background: var(--accent-yellow); }
+    .mc-bar-fill.mc-high { background: var(--accent-red); }
+    .mc-stats {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 11px;
+      font-family: 'JetBrains Mono', monospace;
+      color: var(--text-muted);
+      white-space: nowrap;
+    }
+    .mc-badge {
+      display: inline-flex;
+      align-items: center;
+      padding: 1px 6px;
+      border-radius: 4px;
+      font-size: 10px;
+      font-weight: 600;
+      font-family: 'JetBrains Mono', monospace;
+    }
+    .mc-badge-pending {
+      background: rgba(251,146,60,.15);
+      color: #fb923c;
+    }
+    .mc-badge-active {
+      background: rgba(74,222,128,.12);
+      color: #4ade80;
+    }
+    .mc-vendor-tag {
+      font-size: 10px;
+      color: var(--text-muted);
+      background: rgba(255,255,255,.06);
+      padding: 1px 6px;
+      border-radius: 3px;
+    }
   </style>
 </head>
 <body>
@@ -626,6 +709,14 @@ _DASHBOARD_HTML = """<!DOCTYPE html>
     </div>
   </div>
 
+  <!-- Model Calling 实时状态 -->
+  <div class="card model-calling-card" id="model-calling-card">
+    <div class="card-title">📡 Model Calling 实时状态</div>
+    <div class="model-calling-wrap" id="model-calling-wrap">
+      <div class="mc-empty">加载中…</div>
+    </div>
+  </div>
+
   <!-- 供应商状态 + 请求量趋势折线图 -->
   <div class="charts-grid">
     <div class="card">
@@ -1134,6 +1225,74 @@ function updateVendorStatus(status) {
   }).join('');
 }
 
+// ── Model Calling 实时状态 ────────────────────────────────
+function updateModelCalling(status) {
+  var wrap = document.getElementById('model-calling-wrap');
+  if (!wrap) return;
+  var tiers = status.tiers || [];
+
+  // 收集所有带 concurrency 诊断的模型
+  var models = [];
+  for (var i = 0; i < tiers.length; i++) {
+    var tier = tiers[i];
+    var diag = tier.diagnostics || {};
+    var conc = diag.concurrency;
+    if (!conc) continue;
+    var names = Object.keys(conc);
+    for (var j = 0; j < names.length; j++) {
+      var model = names[j];
+      var d = conc[model];
+      models.push({
+        vendor: tier.name,
+        model: model,
+        limit: d.limit || 0,
+        in_use: d.in_use || 0,
+        available: d.available || 0,
+        pending: d.pending || 0,
+      });
+    }
+  }
+
+  if (!models.length) {
+    wrap.innerHTML = '<div class="mc-empty">无活跃模型调用</div>';
+    return;
+  }
+
+  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 + '/' + m.limit + '</span>'
+      + (m.pending > 0 ? '<span class="mc-badge mc-badge-pending">⏳ ' + m.pending + '</span>' : '')
+      + '</div>'
+      + '</div>';
+  }
+  html += '</div>';
+  wrap.innerHTML = html;
+}
+
+// Model Calling 独立短间隔轮询
+var _mcTimer = null;
+function startModelCallingPoll() {
+  stopModelCallingPoll();
+  function tick() {
+    fetchJSON('/api/status').then(function(status) {
+      updateModelCalling(status);
+    }).catch(function() {});
+  }
+  tick();
+  _mcTimer = setInterval(tick, 5000);
+}
+function stopModelCallingPoll() {
+  if (_mcTimer) { clearInterval(_mcTimer); _mcTimer = null; }
+}
+
 // ── 按 tiers 顺序排序 vendor 列表 ─────────────────────────
 function sortByTierOrder(vendors, tierOrder) {
   if (!tierOrder || !tierOrder.length) return vendors.sort();
@@ -1713,6 +1872,7 @@ async function refreshOverview() {
 
   updateKPI(summary);
   updateVendorStatus(status);
+  updateModelCalling(status);
   updateChartTitles(days);
 
   const rows = timeline.rows || [];
@@ -1788,6 +1948,8 @@ function switchTab(name) {
   currentTab = name;
   applyTabState(name);
   syncTabUrl(name);
+  // Model Calling 轮询随页签切换启停
+  if (name === 'overview') { startModelCallingPoll(); } else { stopModelCallingPoll(); }
   refresh();
 }
 
@@ -1807,6 +1969,7 @@ function switchTab(name) {
   }).catch(function(){});
   refresh();                     // 仅加载初始页签的数据
   setInterval(refresh, 600000);  // 每 10 分钟刷新当前页签
+  if (initial === 'overview') startModelCallingPoll();
 })();
 </script>
 </body>

{coding_proxy-0.4.1a10 → coding_proxy-0.4.1a11}/src/coding/proxy/vendors/concurrency.py

@@ -67,10 +67,15 @@ class ModelConcurrencyLimiter:
             limit = self._config.get_limit(model)
             # asyncio.Semaphore 内部 _value 表示剩余可用槽位
             available = sem._value  # noqa: SLF001 — 公开 API 未暴露
+            in_use = max(limit - available, 0)
+            # _waiters 为正在排队等待的协程集合，无等待者时为 None
+            waiters = getattr(sem, "_waiters", None)  # noqa: SLF001
+            pending = len(waiters) if waiters else 0
             snapshot[model] = {
                 "limit": limit,
-                "in_use": max(limit - available, 0),
+                "in_use": in_use,
                 "available": max(available, 0),
+                "pending": pending,
             }
         return snapshot
 

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

@@ -1,15 +1,17 @@
-"""智谱 GLM 供应商 — 原生 Anthropic 兼容端点薄透传代理.
+"""智谱 GLM 供应商 — 原生 Anthropic 兼容端点代理（兼容转换 + 429 重试）.
 
-官方端点 (https://open.bigmodel.cn/api/anthropic) 已完整支持
-Anthropic Messages API 协议，本模块仅做两项最小适配：
+官方端点 (https://open.bigmodel.cn/api/anthropic) 支持大部分
+Anthropic Messages API 协议，本模块做以下适配：
   1. 模型名映射（Claude -> GLM）
   2. 认证头替换（x-api-key）
+  3. 首选 tier 参数兼容转换（_prepare_request）
 
-注意：实测验证 GLM 的 Anthropic 兼容端点对以下参数的处理方式：
-- thinking 参数：原生支持（GLM 有自己的 thinking 机制）
+实测验证 GLM 对 Anthropic 扩展参数的处理方式：
+- thinking.type="enabled"：原生支持（GLM 有自己的 thinking 机制）
+- thinking.type="adaptive"：不支持，触发 [1210] 参数错误 → 转换为 enabled + budget
 - cache_control 字段：静默忽略（GLM 使用隐式自动缓存）
 - reasoning_effort 参数：静默忽略
-以上参数均不会导致 400 错误，因此不需要在 _prepare_request 中剥离。
+- metadata 字段：暂不处理（待进一步诊断确认兼容性）
 
 额外提供 429 Rate Limit 专用重试挽回机制：
   - max_attempt = 5（1 初始 + 4 重试）
@@ -20,6 +22,7 @@ Anthropic Messages API 协议，本模块仅做两项最小适配：
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
 from collections.abc import AsyncIterator
 from typing import Any
@@ -76,6 +79,49 @@ class ZhipuVendor(NativeAnthropicVendor):
             else None
         )
 
+    # ── 首选 tier 参数兼容转换 ────────────────────────────────
+
+    # adaptive thinking → enabled 的默认预算（Anthropic 推荐的 adaptive 等价值）
+    _ADAPTIVE_THINKING_BUDGET = 16000
+
+    async def _prepare_request(
+        self,
+        request_body: dict[str, Any],
+        headers: dict[str, Any],
+    ) -> tuple[dict[str, Any], dict[str, str]]:
+        """深拷贝 + 模型映射 + 认证头替换 + GLM 兼容转换.
+
+        当 zhipu 作为首选 tier 时（source_vendor=None），请求体来自原始客户端，
+        不经过跨供应商转换通道。此处对已知的 GLM 不兼容参数做兼容转换（而非移除），
+        保留完整的 CC (Claude Code) 功能特性。
+        """
+        body, new_headers = await super()._prepare_request(request_body, headers)
+
+        adaptations: list[str] = []
+
+        # thinking.type="adaptive" 是 Anthropic Claude 4.x 新增的类型，
+        # GLM 不支持此类型值，会触发 [1210] 参数错误。
+        # 转换为 enabled + budget 保留 thinking 能力。
+        thinking = body.get("thinking")
+        if isinstance(thinking, dict) and thinking.get("type") == "adaptive":
+            body["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": self._ADAPTIVE_THINKING_BUDGET,
+            }
+            adaptations.append(
+                f"converted_thinking_adaptive→enabled"
+                f"(budget={self._ADAPTIVE_THINKING_BUDGET})"
+            )
+
+        if adaptations:
+            logger.debug(
+                "ZhipuVendor first-tier compat: %s%s",
+                ", ".join(adaptations),
+                _build_zhipu_request_snapshot(body),
+            )
+
+        return body, new_headers
+
     # ── 非流式：429 重试 ────────────────────────────────────
 
     async def send_message(
@@ -206,6 +252,15 @@ class ZhipuVendor(NativeAnthropicVendor):
             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 _compute_retry_delay_from_headers(
@@ -239,3 +294,39 @@ class ZhipuVendor(NativeAnthropicVendor):
 
 # 向后兼容别名
 ZhipuBackend = ZhipuVendor
+
+
+def _build_zhipu_request_snapshot(body: dict[str, Any]) -> str:
+    """构建发往 zhipu 请求的轻量参数快照，用于诊断日志.
+
+    输出格式与 executor._build_semantic_rejection_diagnostic 一致，
+    使成功请求和失败请求的日志可直接 diff 对比，定位差异维度。
+
+    仅在转换发生时输出（DEBUG 级别），避免常态化日志噪声。
+    """
+    parts: list[str] = []
+    parts.append(f"messages={len(body.get('messages', []))}")
+
+    thinking = body.get("thinking")
+    if isinstance(thinking, dict):
+        parts.append(f"thinking_type={thinking.get('type', 'unknown')}")
+
+    metadata = body.get("metadata")
+    if isinstance(metadata, dict) and metadata:
+        parts.append(f"metadata_keys={len(metadata)}")
+
+    tools = body.get("tools")
+    if isinstance(tools, list):
+        parts.append(f"tools={len(tools)}")
+
+    system = body.get("system")
+    if isinstance(system, list):
+        parts.append(f"system_blocks={len(system)}")
+
+    try:
+        body_bytes = len(json.dumps(body, ensure_ascii=False).encode("utf-8"))
+        parts.append(f"body_bytes={body_bytes}")
+    except (TypeError, ValueError):
+        pass
+
+    return f" [{', '.join(parts)}]" if parts else ""

{coding_proxy-0.4.1a10 → coding_proxy-0.4.1a11}/tests/test_vendors.py

@@ -396,7 +396,7 @@ async def test_zhipu_prepare_request_preserves_metadata():
 
 @pytest.mark.asyncio
 async def test_zhipu_prepare_request_preserves_thinking():
-    """ZhipuVendor._prepare_request 应原样保留 thinking 字段（GLM 原生支持）."""
+    """ZhipuVendor._prepare_request 应原样保留 thinking.type=enabled（GLM 原生支持）."""
     mapper = ModelMapper([])
     zhipu_vendor = ZhipuVendor(ZhipuConfig(api_key="sk-test"), mapper)
     body = {
@@ -405,12 +405,35 @@ async def test_zhipu_prepare_request_preserves_thinking():
         "thinking": {"type": "enabled", "budget_tokens": 10000},
     }
     prepared_body, _ = await zhipu_vendor._prepare_request(body, {})
-    # thinking 原样透传（GLM 原生支持 thinking）
+    # thinking.type=enabled 原样透传（GLM 原生支持）
     assert prepared_body["thinking"] == {"type": "enabled", "budget_tokens": 10000}
     # 原始 body 不应被修改
     assert body["thinking"]["budget_tokens"] == 10000
 
 
+@pytest.mark.asyncio
+async def test_zhipu_prepare_request_converts_thinking_adaptive():
+    """ZhipuVendor._prepare_request 应将 thinking.type=adaptive 转换为 enabled+budget.
+
+    GLM 不支持 adaptive 类型，转换为已确认安全的 enabled + budget_tokens 格式，
+    保留 thinking 能力不被阉割。
+    """
+    mapper = ModelMapper([])
+    zhipu_vendor = ZhipuVendor(ZhipuConfig(api_key="sk-test"), mapper)
+    body = {
+        "model": "claude-opus-4-7",
+        "messages": [],
+        "thinking": {"type": "adaptive"},
+    }
+    prepared_body, _ = await zhipu_vendor._prepare_request(body, {})
+
+    # adaptive 应被转换为 enabled + budget
+    assert prepared_body["thinking"]["type"] == "enabled"
+    assert prepared_body["thinking"]["budget_tokens"] == 16000
+    # 原始 body 不应被修改
+    assert body["thinking"] == {"type": "adaptive"}
+
+
 @pytest.mark.asyncio
 async def test_zhipu_prepare_request_preserves_anthropic_beta_header():
     zhipu_vendor = ZhipuVendor(ZhipuConfig(api_key="sk-test"), ModelMapper([]))