fix(zhipu): 修复首选 tier 语义拒绝降级问题，剥离 GLM 不支持的 Anthropic 扩展参数;

根因：zhipu 作为首选 tier 时 source_vendor=None，不触发跨供应商转换通道，
原始请求体含 cache_control/thinking/reasoning_effort 等 GLM 不支持的参数，
导致 400 invalid_request_error 降级到 copilot 浪费 token。

改动：
- 新增 normalize_for_zhipu() 共享清洗函数作为 zhipu 兼容性单一事实源
- ZhipuVendor._prepare_request() 覆写应用 GLM 兼容性清洗
- 重构 prepare_copilot_to_zhipu() 委托给 normalize_for_zhipu() 消除重复
- 增强 execute_message 语义拒绝日志输出 error_message

🤖 Generated with [Claude Code](https://github.com/claude), [CodeX](https://openai.com), [Gemini](https://github.com/apps/gemini-code-assist)
Co-Authored-By: Aurelius Huang<threefish.ai@gmail.com>

Author: ThreeFish-AI

src/coding/proxy/convert/vendor_channels.py

@@ -367,6 +367,56 @@ def _strip_cache_control(body: dict[str, Any]) -> int:
     return removed
 
 
+# ── zhipu 共享清洗函数 ──────────────────────────────────────────
+
+# GLM 的 Anthropic 兼容端点不支持以下顶层参数，透传会导致 400 invalid_request_error。
+_ZHIPU_UNSUPPORTED_PARAMS: frozenset[str] = frozenset(
+    {"thinking", "extended_thinking", "reasoning_effort"}
+)
+
+
+def normalize_for_zhipu(body: dict[str, Any]) -> tuple[dict[str, Any], list[str]]:
+    """为 zhipu GLM 的 Anthropic 兼容端点清洗请求体（就地，不 deep copy）.
+
+    作为 zhipu 兼容性清洗的单一事实源，同时服务于：
+    - 首选 tier 场景（source_vendor=None，无跨供应商转换触发）
+    - 跨供应商转换通道 ``prepare_copilot_to_zhipu``
+
+    清洗内容：
+    1. 剥离 cache_control 字段（GLM 不支持 Anthropic prompt caching）
+    2. 移除不支持的顶层参数（thinking / extended_thinking / reasoning_effort）
+    3. 强制 tool_use/tool_result 配对约束
+
+    不包含 thinking blocks 剥离：首选 tier 时 history 中的 thinking blocks 来自
+    zhipu 自身（签名有效）；跨供应商场景由调用方（``prepare_copilot_to_zhipu``）
+    在调用本函数之前单独处理。
+
+    所有操作均为幂等，安全地在已清洗的请求体上重复调用。
+
+    Returns:
+        (body, adaptations) — body 为就地修改后的同一引用，adaptations 为变换描述列表。
+    """
+    adaptations: list[str] = []
+
+    # Step 1: 剥离 cache_control
+    removed_cc = _strip_cache_control(body)
+    if removed_cc:
+        adaptations.append(f"removed_{removed_cc}_cache_control_fields")
+
+    # Step 2: 移除不支持的顶层参数
+    for param in _ZHIPU_UNSUPPORTED_PARAMS:
+        if param in body:
+            del body[param]
+            adaptations.append(f"removed_{param}_param")
+
+    # Step 3: 强制 tool_use/tool_result 配对
+    pairing_fixes = enforce_anthropic_tool_pairing(body.get("messages", []))
+    if pairing_fixes:
+        adaptations.extend(pairing_fixes)
+
+    return body, adaptations
+
+
 def _remove_vendor_blocks(body: dict[str, Any], block_types: set[str]) -> int:
     """从 messages[].content[] 中就地移除指定 type 的内容块.
 
@@ -544,26 +594,14 @@ def prepare_copilot_to_zhipu(
     prepared = copy.deepcopy(body)
     adaptations: list[str] = []
 
-    # Step 1: 剥离 thinking/redacted_thinking 块
+    # Step 1: 剥离 thinking/redacted_thinking 块（跨供应商签名失效）
     stripped = strip_thinking_blocks(prepared)
     if stripped:
         adaptations.append(f"stripped_{stripped}_thinking_blocks")
 
-    # Step 2: 移除 cache_control 字段
-    removed_cc = _strip_cache_control(prepared)
-    if removed_cc:
-        adaptations.append(f"removed_{removed_cc}_cache_control_fields")
-
-    # Step 3: 移除顶层 thinking/extended_thinking 参数（GLM-5 不支持）
-    for param in ("thinking", "extended_thinking"):
-        if param in prepared:
-            del prepared[param]
-            adaptations.append(f"removed_{param}_param")
-
-    # Step 4: 强制 tool_use/tool_result 配对
-    pairing_fixes = enforce_anthropic_tool_pairing(prepared.get("messages", []))
-    if pairing_fixes:
-        adaptations.extend(pairing_fixes)
+    # Step 2: 共享清洗（cache_control、不支持的顶层参数、tool pairing）
+    _, norm_adaptations = normalize_for_zhipu(prepared)
+    adaptations.extend(norm_adaptations)
 
     return prepared, adaptations
 

src/coding/proxy/routing/executor.py

@@ -602,9 +602,11 @@ async def execute_message(
 
                 if not is_last and is_semantic:
                     logger.warning(
-                        "Tier %s semantic rejection (%s), trying next tier without recording failure",
+                        "Tier %s semantic rejection (type=%s, msg=%s), "
+                        "trying next tier without recording failure",
                         tier.name,
                         resp.error_type or resp.status_code,
+                        (resp.error_message or "N/A")[:200],
                     )
                     failed_tier_name = tier.name
                     continue

src/coding/proxy/vendors/zhipu.py

@@ -1,23 +1,31 @@
-"""智谱 GLM 供应商 — 原生 Anthropic 兼容端点薄透传代理.
+"""智谱 GLM 供应商 — 原生 Anthropic 兼容端点透传代理.
 
 官方端点 (https://open.bigmodel.cn/api/anthropic) 已完整支持
-Anthropic Messages API 协议，本模块仅做两项最小适配：
+Anthropic Messages API 协议，本模块仅做三项最小适配：
   1. 模型名映射（Claude -> GLM）
   2. 认证头替换（x-api-key）
+  3. 请求参数清洗（剥离 GLM 不支持的 Anthropic 扩展字段）
 """
 
 from __future__ import annotations
 
+import logging
+from typing import Any
+
 from ..config.schema import FailoverConfig, ZhipuConfig
 from ..routing.model_mapper import ModelMapper
 from .native_anthropic import NativeAnthropicVendor
 
+logger = logging.getLogger(__name__)
+
 
 class ZhipuVendor(NativeAnthropicVendor):
-    """智谱 GLM 原生 Anthropic 兼容端点供应商（薄透传）.
+    """智谱 GLM 原生 Anthropic 兼容端点供应商.
 
     通过官方 /api/anthropic 端点转发请求，
-    仅替换模型名和认证头，其余原样透传。
+    替换模型名和认证头，并剥离 GLM 不支持的 Anthropic 扩展参数：
+    - cache_control 字段（GLM 不支持 Anthropic prompt caching）
+    - thinking / extended_thinking / reasoning_effort 顶层参数
     """
 
     _vendor_name = "zhipu"
@@ -31,6 +39,29 @@ def __init__(
     ) -> None:
         super().__init__(config, model_mapper, failover_config)
 
+    async def _prepare_request(
+        self,
+        request_body: dict[str, Any],
+        headers: dict[str, str],
+    ) -> tuple[dict[str, Any], dict[str, str]]:
+        """深拷贝 + 模型映射 + 认证头替换 + GLM 兼容性清洗.
+
+        在父类 deep copy + model mapping + header 替换的基础上，
+        增加剥离 GLM 不支持的 Anthropic 扩展参数。
+        """
+        body, new_headers = await super()._prepare_request(request_body, headers)
+
+        from ..convert.vendor_channels import normalize_for_zhipu
+
+        _, adaptations = normalize_for_zhipu(body)
+        if adaptations:
+            logger.debug(
+                "zhipu: applied first-tier normalization: %s",
+                ", ".join(adaptations),
+            )
+
+        return body, new_headers
+
 
 # 向后兼容别名
 ZhipuBackend = ZhipuVendor

tests/test_vendor_channels.py

@@ -22,6 +22,7 @@
     enforce_anthropic_tool_pairing,
     get_transition_channel,
     infer_source_vendor_from_body,
+    normalize_for_zhipu,
     prepare_copilot_to_zhipu,
     prepare_zhipu_to_anthropic,
     prepare_zhipu_to_copilot,
@@ -2147,3 +2148,80 @@ def test_rewrites_srvtoolu_and_strips_vendor_delta(self):
         assert prepared["messages"][1]["content"][0]["tool_use_id"] == new_id
         assert any("zhipu_vendor_blocks" in a for a in adaptations)
         assert any("srvtoolu_ids" in a for a in adaptations)
+
+
+# ── normalize_for_zhipu 共享清洗函数 ────────────────────────
+
+
+class TestNormalizeForZhipu:
+    """normalize_for_zhipu 共享清洗函数测试."""
+
+    def test_strips_cache_control_and_params(self):
+        body = {
+            "model": "claude-sonnet-4-20250514",
+            "messages": [],
+            "thinking": {"type": "enabled", "budget_tokens": 5000},
+            "extended_thinking": {"type": "enabled"},
+            "reasoning_effort": "high",
+            "system": [
+                {
+                    "type": "text",
+                    "text": "sys",
+                    "cache_control": {"type": "ephemeral"},
+                },
+            ],
+            "tools": [
+                {
+                    "name": "Bash",
+                    "input_schema": {"type": "object"},
+                    "cache_control": {"type": "ephemeral"},
+                },
+            ],
+        }
+        result, adaptations = normalize_for_zhipu(body)
+
+        assert "thinking" not in result
+        assert "extended_thinking" not in result
+        assert "reasoning_effort" not in result
+        assert "cache_control" not in result["system"][0]
+        assert "cache_control" not in result["tools"][0]
+        assert any("cache_control" in a for a in adaptations)
+        assert any("thinking" in a for a in adaptations)
+        assert any("reasoning_effort" in a for a in adaptations)
+
+    def test_operates_in_place(self):
+        body = {"model": "x", "messages": []}
+        result, _ = normalize_for_zhipu(body)
+        assert result is body
+
+    def test_idempotent(self):
+        body = {
+            "model": "x",
+            "messages": [],
+            "thinking": {"type": "enabled"},
+        }
+        normalize_for_zhipu(body)
+        _, adaptations = normalize_for_zhipu(body)
+        assert adaptations == []
+
+    def test_no_deep_copy(self):
+        messages = [{"role": "user", "content": "hi"}]
+        body = {"model": "x", "messages": messages}
+        result, _ = normalize_for_zhipu(body)
+        assert result["messages"] is messages
+
+    def test_preserves_supported_params(self):
+        body = {
+            "model": "x",
+            "messages": [{"role": "user", "content": "hello"}],
+            "max_tokens": 1024,
+            "temperature": 0.7,
+            "stream": True,
+            "metadata": {"user_id": "test"},
+        }
+        result, adaptations = normalize_for_zhipu(body)
+        assert result["max_tokens"] == 1024
+        assert result["temperature"] == 0.7
+        assert result["stream"] is True
+        assert result["metadata"] == {"user_id": "test"}
+        assert adaptations == []

tests/test_vendors.py

@@ -395,8 +395,8 @@ async def test_zhipu_prepare_request_preserves_metadata():
 
 
 @pytest.mark.asyncio
-async def test_zhipu_prepare_request_preserves_thinking():
-    """ZhipuVendor._prepare_request 应原样保留 thinking 字段（原生端点支持）."""
+async def test_zhipu_prepare_request_strips_thinking():
+    """ZhipuVendor._prepare_request 应剥离 GLM 不支持的 thinking 顶层参数."""
     mapper = ModelMapper([])
     zhipu_vendor = ZhipuVendor(ZhipuConfig(api_key="sk-test"), mapper)
     body = {
@@ -405,9 +405,9 @@ async def test_zhipu_prepare_request_preserves_thinking():
         "thinking": {"type": "enabled", "budget_tokens": 10000},
     }
     prepared_body, _ = await zhipu_vendor._prepare_request(body, {})
-    # thinking 原样透传，不再剥离任何字段
-    assert prepared_body["thinking"] == {"type": "enabled", "budget_tokens": 10000}
-    # 原始 body 不应被修改
+    # thinking 被 GLM 兼容性清洗剥离
+    assert "thinking" not in prepared_body
+    # 原始 body 不应被修改（deep copy）
     assert body["thinking"]["budget_tokens"] == 10000