coding-proxy 0.3.1a1__tar.gz → 0.3.1a3__tar.gz

{coding_proxy-0.3.1a1 → coding_proxy-0.3.1a3}/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 ## [Unreleased]
 
+- fix(vendor-channels): 新增 zhipu 同 vendor 自清理通道，修复 GLM-5 自循环 400 + tool_results 偶发降级；
+- fix(vendor-channels): 修复 `_rewrite_srvtoolu_ids` 块顺序敏感性导致 inline tool_result 漏改名，进而 enforce 阶段 dict key 与 tool_use_ids 错位、anthropic 报 `tool_use ids without tool_result blocks immediately after` 的 cascade failover 问题（改为两遍扫描：先收集 id_map，再统一改写所有 tool_result.tool_use_id 引用）；
+- fix(vendor-channels): `enforce_anthropic_tool_pairing` 增加全局 sanity check pass，主循环边角错位让 dangling tool_use 漏过校验时兜底合成 is_error 占位并打 `pairing_sanity_repaired` 标签，避免 anthropic 二次报错；
+
+### Bug Fixes
+
+- fix(vendor-channels): 新增 `anthropic → zhipu` 跨供应商转换通道，修复 Anthropic beta 功能（web search, computer use）产生的 `server_tool_use` 块导致 zhipu 400 错误的问题；
+- fix(error-classifier): 增强语义拒绝检测，识别 zhipu 等供应商返回的中文错误消息（如「API 调用参数有误」code=1210），确保正确触发故障转移；
+- fix(vendor-channels): `_remove_vendor_blocks` 增加空内容占位保护，防止内容块全部剥离后消息结构不合法。
+
 ## [v0.3.0](https://github.com/ThreeFish-AI/coding-proxy/releases/tag/v0.3.0) — 2026-04-20
 
 > [!IMPORTANT]

{coding_proxy-0.3.1a1 → coding_proxy-0.3.1a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-proxy
-Version: 0.3.1a1
+Version: 0.3.1a3
 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
@@ -113,6 +113,14 @@ export ANTHROPIC_BASE_URL=http://127.0.0.1:3392
 claude
 ```
 
+### 5. Peek at the Dashboard
+
+Curious about your real-time token spend, latency, and circuit breaker pulse? Pop open your browser and head to:
+
+```bash
+open http://127.0.0.1:3392/dashboard
+```
+
 ---
 
 ## 🛠️ The CLI Console Guide

{coding_proxy-0.3.1a1 → coding_proxy-0.3.1a3}/README.md

@@ -86,6 +86,14 @@ export ANTHROPIC_BASE_URL=http://127.0.0.1:3392
 claude
 ```
 
+### 5. Peek at the Dashboard
+
+Curious about your real-time token spend, latency, and circuit breaker pulse? Pop open your browser and head to:
+
+```bash
+open http://127.0.0.1:3392/dashboard
+```
+
 ---
 
 ## 🛠️ The CLI Console Guide

coding_proxy-0.3.1a3/docs/issue.md

@@ -0,0 +1,143 @@
+# Issue 处理档案
+
+> 维护已处理过的 Issue 摘要（问题描述、表因根因、处理方式、后续防范、同类问题影响与处理注意事项），便于同类问题的跨上下文处理。识别相同 Issue 时应在原条目追加复盘，避免同 Issue 多处维护。
+
+---
+
+## streaming usage parse failed: 'NoneType' object has no attribute 'get'
+
+**问题描述**
+
+OpenAI 兼容 SSE 流式响应过程中，单次请求日志反复刷出数十条 WARNING：
+
+```
+WARNING streaming usage parse failed: 'NoneType' object has no attribute 'get'
+```
+
+警告本身被上层 `try/except` 吞掉不影响主链路，但日志噪声严重，且每帧都丢失了 usage 累加。
+
+**表因**
+
+`StreamingUsageAccumulator.feed` 调用 `parse_usage_from_chunk` 解析 SSE chunk 时抛出 `AttributeError`。
+
+**根因**
+
+`src/coding/proxy/routing/usage_parser.py::parse_usage_from_chunk` 中 Anthropic message_start 与 Anthropic message_delta / OpenAI 两条分支都使用了脆弱的判空模式：
+
+```python
+if "usage" in data:        # 仅判断 key 存在
+    u = data["usage"]      # 但值可能是 null
+    u.get("output_tokens", 0)  # AttributeError
+```
+
+部分上游（含某些 OpenAI 兼容供应商）在中间 chunk 显式发送 `"usage": null` 占位帧，`in` 检查通过但取出的是 `None`。
+
+**处理方式**
+
+将两处 guard 统一改为 `u = container.get("usage"); if isinstance(u, dict):`，既排除缺省也排除 null，并顺手移除内部冗余的 `if isinstance(u, dict):` 包装层（已被外层 guard 覆盖）。同时新增三个回归用例覆盖 `data.usage = null` / `message.usage = null` / null 帧后跟有效帧三种场景。
+
+**后续防范**
+
+- 解析外部 SSE / JSON 结构时, 不要单独使用 `if key in data` 作为安全 guard, 应统一采用 `value = data.get(key); if isinstance(value, dict):` 的双重保护, 同时排除缺省与显式 null。
+- 对 try/except 包裹的 WARNING 路径要保持警觉: 异常被吞不代表无害，重复刷屏的同类警告往往暗示防御性 guard 过窄，需要回溯至根因修复，而非依赖 except 兜底。
+
+**同类问题影响与处理注意事项**
+
+- 本仓库内 `parse_usage_from_chunk` 的 Gemini `usageMetadata` 分支 (line ~219) 已经使用 `isinstance(um, dict)` 防御, 不受影响, 可作为参考实现。
+- 检查其他解析器 (如 routing / vendor adapter 层) 是否还有 `if "key" in data: v = data["key"]; v.get(...)` 这种模式, 必要时同步加固。
+
+---
+
+## zhipu 自循环 400 + tool_results 偶发降级
+
+**问题描述**
+
+生产日志反复出现下述链路: 请求一开始命中 zhipu 主 tier, 但在含 `tool_results` 的多轮工具调用场景下偶发返回 400, 触发到 copilot 二级 tier。具体日志特征:
+
+```
+WARNING Tier zhipu likely format incompatibility (400 + tool_results), trying next tier without recording failure
+WARNING Tier zhipu semantic rejection (400), trying next tier without recording failure
+DEBUG Applied transition channel zhipu → copilot: rewritten_38_srvtoolu_ids, stripped_16_thinking_blocks, removed_3_cache_control_fields, misplaced_tool_result_relocated
+```
+
+zhipu → copilot 通道的 adaptations 列表暴露了上一轮 zhipu 响应中存在的非标准产物 (`srvtoolu_*` ID、自签 thinking、错位的 `tool_result`)。
+
+**表因**
+
+zhipu 自身偶发返回 400, 但错误体非 JSON 结构, 由 `_is_likely_request_format_error()` 判定为「格式不兼容」并跳过当前 tier。
+
+**根因**
+
+1. zhipu 是 `NativeAnthropicVendor` 薄透传供应商, **不做任何请求体预处理**。
+2. `executor._determine_source_vendor` 三条优先级路径均以 `source != target_name` 过滤掉了同 vendor 自转换。
+3. `VENDOR_TRANSITIONS` 注册表中无 `("zhipu", "zhipu")` 条目。
+
+后果: GLM-5 偶发产出非标准产物 (assistant 内联 `tool_result`、`server_tool_use_delta` 流式残块) 后, Claude Code 把这些产物原样回送下一轮请求时, **没有任何清洗发生**, 直接被转发到 zhipu 自身, 命中 zhipu 端的输入校验返回 400。
+
+**处理方式**
+
+- 在 `vendor_channels.py` 新增 `prepare_zhipu_self_cleanup` 函数, 仅修复 zhipu 自身拒绝的两类产物:
+  1. 剥离 `server_tool_use_delta` 流式残块
+  2. `enforce_anthropic_tool_pairing` 把 assistant 内联 `tool_result` 重定位到紧随 user 消息
+- 显式 **保留** zhipu 原生支持的特性: `srvtoolu_*` ID、`server_tool_use` 类型、自签 thinking signature、`cache_control` (cache_read 已在生产实证)、顶层 `thinking` 参数。
+- 在 `VENDOR_TRANSITIONS` 注册 `("zhipu", "zhipu") = prepare_zhipu_self_cleanup`。
+- 在 `executor._determine_source_vendor` 三条优先级路径中, 把「`source != target`」过滤替换为「通道已注册」门控 (`get_transition_channel(...) is not None`), 让自转换通道在显式注册时启用, 未注册时退化为原行为。
+
+**后续防范**
+
+- 新增 `NativeAnthropicVendor` 子类 (minimax / kimi / doubao / xiaomi / alibaba 等) 时, 若上游 vendor 偶发产出违反 Anthropic 规范的产物, 可按需注册同名自清理通道, executor 无需任何额外改动。
+- 同 vendor 自转换通道应**精确剪裁**: 仅修复 vendor 自身拒绝的产物, 不要套用跨 vendor 通道的全量清理 (会误伤 vendor 原生支持的特性, 如 cache_control 损失带来 cache_read miss)。
+
+**同类问题影响与处理注意事项**
+
+- `enforce_anthropic_tool_pairing` 仅识别 `tool_use` 类型 (不含 `server_tool_use`), 因为 `server_tool_use` 由 vendor 自身执行, 不需要客户端 `tool_result`。构造测试或类似清洗逻辑时需注意此差别。
+- `_is_likely_request_format_error()` 把「400 + tool_results + 非结构化错误体」一律标记为格式不兼容并跳过 tier 不计熔断器, 这层兜底虽能维持可用性但会**掩盖** vendor 自身的间歇性问题, 让根因更难发现。处理类似 400 偶发时, 应优先看 `Applied transition channel` 日志中的 adaptations 列表, 它能精确暴露上游响应中的非标准产物。
+
+---
+
+## anthropic 报 messages.X tool_use 缺 tool_result (zhipu→anthropic 故障转移失败)
+
+**问题描述**
+
+zhipu 完成响应后, executor 故障转移至 anthropic 时反复失败 (HTTP 400):
+
+```
+DEBUG Applied transition channel zhipu → anthropic: rewritten_86_srvtoolu_ids, misplaced_tool_result_relocated, stripped_18_thinking_blocks
+WARNING anthropic stream error: status=400 ... messages.3: `tool_use` ids were found without `tool_result` blocks immediately after: toolu_normalized_3.
+INFO  Failover: anthropic → zhipu (reason: HTTP 400)
+```
+
+adaptations 列表显示 `misplaced_tool_result_relocated` 但**没有** `orphaned_tool_use_repaired`, 即 enforce 单遍扫描视角下认为所有 tool_use 都已配对; 但 anthropic 仍报 messages.X 缺 tool_result, 导致请求级 cascade failover 反复回到 zhipu。
+
+**表因**
+
+`prepare_zhipu_to_anthropic` 链路输出的请求体中, 某个 assistant 的 `tool_use` 在紧邻的 user 消息中没有匹配的 `tool_result` 块。
+
+**根因**
+
+`_rewrite_srvtoolu_ids` 采用单遍正向扫描: 在同一次循环中一边收集 srvtoolu_* → toolu_normalized_* 的 id_map, 一边改写遇到的 `tool_result.tool_use_id`。GLM-5 流式偶发将 inline tool_result 输出在本消息 `server_tool_use` 之前 (block 顺序异常), 导致:
+
+1. 处理 inline tool_result 时, id_map 尚未填入对应 srvtoolu_* → 漏改名, inline 仍保留 `srvtoolu_X`
+2. 处理本消息 server_tool_use 时, 填入 id_map 并把 tool_use 改名为 `toolu_normalized_X`
+3. 进入 `enforce_anthropic_tool_pairing` 时:
+   - A 步 extracted dict key = `srvtoolu_X` (inline 保留的旧 ID)
+   - B 步 tool_use_ids = `[toolu_normalized_X]` (已改名)
+   - F 步 `uid in extracted` 检查失败 (key 错位), 但若 next user 已含其他 stale tool_result 让 existing_result_ids "巧合" 命中, F 步会跳过 synth → 不触发 orphan 标签
+   - 最终 anthropic 看到 messages.X 真的缺 toolu_normalized_X 的 tool_result → 400
+
+**处理方式**
+
+- `_rewrite_srvtoolu_ids` 改为**两遍扫描**: Pass 1 仅遍历 assistant 消息, 收集 id_map 并改写 tool_use 自身的 id 与 type; Pass 2 全量遍历所有消息 (含 user / 异常 assistant 内联), 统一改写所有 `tool_result.tool_use_id` 引用。彻底消除 block 顺序敏感性。
+- `enforce_anthropic_tool_pairing` 主循环结束后追加**全局 sanity check pass**: 重新遍历每条 assistant, 验证其 tool_use_ids 全部在 next user 的 tool_result 中存在; 发现遗漏直接合成 is_error 占位并打 `pairing_sanity_repaired` 标签。作为防御深度抵御未来其他主循环边角错位。
+- A 步对 `tool_use_id` 缺失的破损 inline tool_result 也计入 relocated_count (避免 silent drop 影响 adaptations 标签可观测性)。
+
+**后续防范**
+
+- 任何"按出现顺序填充字典 + 同遍引用查询"的两阶段操作都应警惕**顺序耦合**问题。两遍扫描 (collect → apply) 是消除此类 bug 的标准 pattern。
+- 关键校验函数应有**主循环 + 全局 sanity check** 的双层结构, 单层校验在边角场景下容易被绕过。
+- 处理 anthropic `tool_use ids without tool_result blocks immediately after` 类 cascade failover 时, **adaptations 标签能否复现日志**是定位 root cause 的强信号: 若 enforce 视角与 anthropic 视角不一致 (有 misplaced 但无 orphan, anthropic 仍报错), 必有上游 _rewrite / id 改写阶段的隐藏漏洞。
+
+**同类问题影响与处理注意事项**
+
+- 任何对 messages 进行 ID 重写的转换链 (如 `_rewrite_srvtoolu_ids`、`anthropic_to_openai`、`anthropic_to_gemini`) 都应使用两遍扫描或一次性收集后再批量改写, 以保证 block 顺序无关性。
+- enforce 类校验函数若依赖 dict key 与 list 元素的**等同性**, 必须先确保两者在同一参考系下 (改名前 vs 改名后); 否则错位会以 "看起来 OK 实际有漏" 的方式静默泄漏到下游。

{coding_proxy-0.3.1a1 → coding_proxy-0.3.1a3}/docs/zh-CN/README.md

@@ -86,6 +86,14 @@ export ANTHROPIC_BASE_URL=http://127.0.0.1:3392
 claude
 ```
 
+### 5. 打开监控看板
+
+想实时观测 Token 消耗、延迟以及各层熔断状态？在浏览器中打开：
+
+```bash
+open http://127.0.0.1:3392/dashboard
+```
+
 ---
 
 ## 🛠️ CLI 控制台指南

{coding_proxy-0.3.1a1 → coding_proxy-0.3.1a3}/pyproject.toml

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

@@ -10,6 +10,8 @@ executor 层通过 ``get_transition_channel()`` 查表分发，无需感知具
     zhipu → anthropic : prepare_zhipu_to_anthropic  (剥离 thinking + tool pairing)
     zhipu → copilot   : prepare_zhipu_to_copilot    (剥离 thinking + cache_control + tool pairing)
     copilot → zhipu   : prepare_copilot_to_zhipu    (剥离 thinking + cache_control + 移除 thinking 参数 + tool pairing)
+    zhipu → zhipu     : prepare_zhipu_self_cleanup  (剥离 server_tool_use_delta + tool pairing)
+    anthropic → zhipu : prepare_anthropic_to_zhipu  (剥离 server_tool_use + thinking + cache_control + 移除 thinking 参数 + tool pairing)
 """
 
 from __future__ import annotations
@@ -108,6 +110,10 @@ def enforce_anthropic_tool_pairing(
 
     此函数是一个**自包含的单遍处理**，不依赖 Phase 1 收集的 misplaced 信息。
 
+    最终在主循环之后执行一次幂等的全局 sanity check pass, 防御主循环的边角
+    错位 (如 inline tool_result 引用未在本消息出现的 tool_use_id, 导致 extracted
+    字典 key 与 tool_use_ids 集合错位) 让 dangling tool_use 漏过校验。
+
     Args:
         messages_list: 消息列表（就地修改）。
 
@@ -139,10 +145,13 @@ def enforce_anthropic_tool_pairing(
                 if tid:
                     extracted_tool_results[tid] = block
                     relocated_count += 1
+                else:
+                    # 缺 tool_use_id 的破损 tool_result 也视作错位剥离
+                    relocated_count += 1
             else:
                 retained_content.append(block)
 
-        if extracted_tool_results:
+        if extracted_tool_results or len(retained_content) != len(content):
             msg["content"] = retained_content
 
         # B. 收集所有 tool_use ID
@@ -207,10 +216,17 @@ def enforce_anthropic_tool_pairing(
 
         i += 1
 
+    # G. 最终全局 sanity check pass (抽出为独立函数便于单测验证正向兜底路径).
+    sanity_synthesized = _enforce_pairing_sanity_pass(messages_list)
+
     if relocated_count:
         adaptations.append("misplaced_tool_result_relocated")
-    if synthesized_ids:
+    if synthesized_ids or sanity_synthesized:
         adaptations.append("orphaned_tool_use_repaired")
+
+    # 主循环 F 段与 sanity G 段分别打日志, 避免 main=0/sanity=N 时把 sanity
+    # 兜底误归因为主循环工作 (运维在线日志聚合时易混淆 cross-pass id-map drift).
+    if synthesized_ids:
         logger.warning(
             "Vendor degradation adaptation: synthesized %d tool_result block(s) "
             "for orphaned tool_use to satisfy Anthropic pairing constraint. "
@@ -218,10 +234,94 @@ def enforce_anthropic_tool_pairing(
             len(synthesized_ids),
             ", ".join(synthesized_ids),
         )
+    if sanity_synthesized:
+        adaptations.append("pairing_sanity_repaired")
+        logger.warning(
+            "Pairing sanity check repaired %d dangling tool_use(s) missed by "
+            "main pass (likely cross-pass id-map drift). Affected tool_use_ids: %s",
+            len(sanity_synthesized),
+            ", ".join(sanity_synthesized),
+        )
 
     return adaptations
 
 
+def _enforce_pairing_sanity_pass(messages_list: list[Any]) -> list[str]:
+    """全局 sanity check pass: 防御主循环边角错位让 dangling tool_use 漏过.
+
+    例如: extracted dict key 与 _rewrite 后的 tool_use_ids 错位、user_msg
+    中已有 stale tool_result 让 F 步误判 existing 命中等场景。
+
+    扫描所有 assistant 消息, 验证每个 ``tool_use`` block ID 在紧随的 user 消息
+    中均存在对应 ``tool_result``; 漏掉的合成 ``is_error`` 占位。
+
+    抽取为独立函数的目的: 主循环 F 步在当前实现下能覆盖所有 dangling tool_use,
+    导致 sanity 实际兜底分支在公开 API 测试中无法被触发; 独立函数便于直接
+    构造「绕过主循环」的输入, 对兜底合成路径建立正向回归保护。
+
+    Args:
+        messages_list: 消息列表 (就地修改, 必要时插入空 user 消息).
+
+    Returns:
+        sanity 兜底合成的 tool_use_id 列表 (空表示主循环已完成所有配对).
+    """
+    sanity_synthesized: list[str] = []
+    j = 0
+    while j < len(messages_list):
+        msg_j = messages_list[j]
+        if not isinstance(msg_j, dict) or msg_j.get("role") != "assistant":
+            j += 1
+            continue
+        content_j = msg_j.get("content")
+        if not isinstance(content_j, list):
+            j += 1
+            continue
+        tu_ids = [
+            b["id"]
+            for b in content_j
+            if isinstance(b, dict) and b.get("type") == "tool_use" and b.get("id")
+        ]
+        if not tu_ids:
+            j += 1
+            continue
+        next_j = j + 1
+        if (
+            next_j < len(messages_list)
+            and isinstance(messages_list[next_j], dict)
+            and messages_list[next_j].get("role") == "user"
+        ):
+            next_user = messages_list[next_j]
+        else:
+            next_user = {"role": "user", "content": []}
+            messages_list.insert(next_j, next_user)
+        nu_content = next_user.get("content")
+        if isinstance(nu_content, str):
+            next_user["content"] = [{"type": "text", "text": nu_content}]
+        elif not isinstance(nu_content, list):
+            next_user["content"] = []
+        nu_result_ids = {
+            b["tool_use_id"]
+            for b in next_user["content"]
+            if isinstance(b, dict)
+            and b.get("type") == "tool_result"
+            and b.get("tool_use_id")
+        }
+        for uid in tu_ids:
+            if uid in nu_result_ids:
+                continue
+            next_user["content"].append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": uid,
+                    "content": "",
+                    "is_error": True,
+                }
+            )
+            sanity_synthesized.append(uid)
+        j += 1
+    return sanity_synthesized
+
+
 def _strip_cache_control(body: dict[str, Any]) -> int:
     """从 system/messages/tools 中移除 cache_control 字段（就地）.
 
@@ -284,7 +384,13 @@ def _remove_vendor_blocks(body: dict[str, Any], block_types: set[str]) -> int:
                 removed += 1
                 continue
             new_content.append(block)
-        if removed:
+        if content != new_content:
+            if not new_content:
+                new_content = [{"type": "text", "text": "[vendor_block_removed]"}]
+                logger.info(
+                    "Inserted placeholder text block after stripping "
+                    "vendor blocks to avoid empty message content",
+                )
             message["content"] = new_content
     return removed
 
@@ -294,8 +400,12 @@ def _rewrite_srvtoolu_ids(body: dict[str, Any]) -> tuple[int, dict[str, str]]:
 
     Anthropic API 要求 tool_use 类型与 ``toolu_*`` 格式的 ID。Zhipu 的
     ``server_tool_use`` + ``srvtoolu_*`` 在上游 Anthropic 兼容端点可用，但无法
-    透传至其他供应商；同时还需重写紧随其后 user 消息中 ``tool_result.tool_use_id``
-    引用，保持配对关系。
+    透传至其他供应商；同时还需重写所有 ``tool_result.tool_use_id`` 引用，
+    保持配对关系。
+
+    采用**两遍扫描**避免块顺序敏感性: GLM-5 偶发将 inline tool_result 输出在
+    本消息 tool_use 之前, 单遍扫描会因 id_map 尚未填入而漏改 inline tool_result
+    的 tool_use_id, 导致后续 enforce 步骤无法将其与 tool_use 配对。
 
     Returns:
         (rewritten_count, id_map) — 重写次数与 {原 ID: 新 ID} 映射。
@@ -308,45 +418,59 @@ def _rewrite_srvtoolu_ids(body: dict[str, Any]) -> tuple[int, dict[str, str]]:
         counter += 1
         return f"toolu_normalized_{counter}"
 
+    # Pass 1: 收集所有 assistant tool_use / server_tool_use 的 ID 映射
+    # 不修改 tool_result, 仅建立 id_map; 同时改写 tool_use 自身的 id 与 type
     for message in body.get("messages", []):
         if not isinstance(message, dict):
             continue
         content = message.get("content")
         if not isinstance(content, list):
             continue
-        role = message.get("role")
+        if message.get("role") != "assistant":
+            continue
         for block in content:
             if not isinstance(block, dict):
                 continue
             block_type = block.get("type")
             block_id = block.get("id")
+            if block_type not in {"tool_use", "server_tool_use"}:
+                continue
 
-            # Case A: assistant 消息里的 server_tool_use / srvtoolu_* → 改写
-            if role == "assistant" and block_type in {"tool_use", "server_tool_use"}:
-                if isinstance(block_id, str) and _ANTHROPIC_SERVER_TOOL_USE_ID_RE.match(
-                    block_id
-                ):
-                    new_id = next_id()
-                    id_map[block_id] = new_id
-                    block["id"] = new_id
-                    block["type"] = "tool_use"
-                elif (
-                    isinstance(block_id, str)
-                    and block_id
-                    and not _ANTHROPIC_TOOL_USE_ID_RE.match(block_id)
-                    and block.get("name")
-                ):
-                    # 非标准 ID（非 toolu_ / srvtoolu_），且具备 name 可改写
-                    new_id = next_id()
-                    id_map[block_id] = new_id
-                    block["id"] = new_id
-                    block["type"] = "tool_use"
-                elif block_type == "server_tool_use" and isinstance(block_id, str):
-                    # 兜底: 类型是 server_tool_use 但 ID 已是标准 toolu_ 形式，仅纠正类型
-                    block["type"] = "tool_use"
-
-            # Case B: user 消息里的 tool_result.tool_use_id 同步重写
-            if block_type == "tool_result":
+            if isinstance(block_id, str) and _ANTHROPIC_SERVER_TOOL_USE_ID_RE.match(
+                block_id
+            ):
+                new_id = next_id()
+                id_map[block_id] = new_id
+                block["id"] = new_id
+                block["type"] = "tool_use"
+            elif (
+                isinstance(block_id, str)
+                and block_id
+                and not _ANTHROPIC_TOOL_USE_ID_RE.match(block_id)
+                and block.get("name")
+            ):
+                # 非标准 ID（非 toolu_ / srvtoolu_），且具备 name 可改写
+                new_id = next_id()
+                id_map[block_id] = new_id
+                block["id"] = new_id
+                block["type"] = "tool_use"
+            elif block_type == "server_tool_use" and isinstance(block_id, str):
+                # 兜底: 类型是 server_tool_use 但 ID 已是标准 toolu_ 形式，仅纠正类型
+                block["type"] = "tool_use"
+
+    # Pass 2: 全量同步所有 tool_result.tool_use_id 引用 (含 user/assistant 内联)
+    if id_map:
+        for message in body.get("messages", []):
+            if not isinstance(message, dict):
+                continue
+            content = message.get("content")
+            if not isinstance(content, list):
+                continue
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                if block.get("type") != "tool_result":
+                    continue
                 tool_use_id = block.get("tool_use_id")
                 if isinstance(tool_use_id, str) and tool_use_id in id_map:
                     block["tool_use_id"] = id_map[tool_use_id]
@@ -358,8 +482,9 @@ def infer_source_vendor_from_body(body: dict[str, Any]) -> str | None:
     """从请求 body 内容推断源供应商（仅在无会话上下文时作为兜底）.
 
     启发式（按置信度排序）:
-    - 出现 ``srvtoolu_*`` 格式的 ``tool_use.id`` → zhipu
-    - 出现 ``server_tool_use`` / ``server_tool_use_delta`` 类型的 content block → zhipu
+    - 出现 ``srvtoolu_*`` 格式的 ID → zhipu
+    - 出现 ``server_tool_use_delta`` 类型的 content block → zhipu
+    - 出现 ``server_tool_use`` 块 + ``toolu_*`` ID → anthropic（beta 功能产物）
 
     原则: 只读扫描不修改 body；无匹配返回 None（视作纯净无需跨供应商清洗）。
 
@@ -367,7 +492,7 @@ def infer_source_vendor_from_body(body: dict[str, Any]) -> str | None:
         body: Anthropic Messages 请求体。
 
     Returns:
-        推断的源供应商名称（当前仅支持 ``"zhipu"``），无法推断返回 None。
+        推断的源供应商名称（``"zhipu"`` 或 ``"anthropic"``），无法推断返回 None。
     """
     for message in body.get("messages", []):
         if not isinstance(message, dict):
@@ -379,18 +504,35 @@ def infer_source_vendor_from_body(body: dict[str, Any]) -> str | None:
             if not isinstance(block, dict):
                 continue
             block_type = block.get("type")
-            if block_type in _ZHIPU_SERVER_TOOL_USE_TYPES:
-                return "zhipu"
             block_id = block.get("id")
+            tool_use_id = block.get("tool_use_id")
+
+            # Zhipu: server_tool_use_delta 是 zhipu 私有流式块（无歧义）
+            if block_type == "server_tool_use_delta":
+                return "zhipu"
+
+            # srvtoolu_* ID（无论 block type）→ zhipu
             if isinstance(block_id, str) and _ANTHROPIC_SERVER_TOOL_USE_ID_RE.match(
                 block_id
             ):
                 return "zhipu"
-            tool_use_id = block.get("tool_use_id")
             if isinstance(tool_use_id, str) and _ANTHROPIC_SERVER_TOOL_USE_ID_RE.match(
                 tool_use_id
             ):
                 return "zhipu"
+
+            # server_tool_use 块 + toolu_* ID → Anthropic beta 功能
+            if (
+                block_type == "server_tool_use"
+                and isinstance(block_id, str)
+                and _ANTHROPIC_TOOL_USE_ID_RE.match(block_id)
+            ):
+                return "anthropic"
+
+            # server_tool_use 块 + 非 toolu_/srvtoolu_ ID → 按类型兜底归 zhipu
+            if block_type == "server_tool_use":
+                return "zhipu"
+
     return None
 
 
@@ -438,6 +580,61 @@ def prepare_copilot_to_zhipu(
     return prepared, adaptations
 
 
+# ── anthropic → zhipu 转换通道 ────────────────────────────────────
+
+# Anthropic beta 特有的 server_tool_use 块类型（web search, computer use 等）.
+# 这些块在 Anthropic API 中有效，但 zhipu GLM-5 的兼容端点不支持。
+# 注意: 这与 zhipu 自己的 server_tool_use（使用 srvtoolu_* ID）是不同的概念，
+# 但它们共用同一个 type 名称 "server_tool_use"。
+_ANTHROPIC_BETA_BLOCK_TYPES = {"server_tool_use"}
+
+
+def prepare_anthropic_to_zhipu(
+    body: dict[str, Any],
+) -> tuple[dict[str, Any], list[str]]:
+    """anthropic → zhipu 转换: 清理 anthropic 产物以适配 GLM-5.
+
+    Anthropic API 可能产生的非兼容产物:
+    - ``server_tool_use`` blocks（web search / computer use 等 beta 功能）
+    - ``thinking`` / ``redacted_thinking`` blocks（含 Anthropic 签发的 signature）
+    - ``cache_control`` 字段
+    - 顶层 ``thinking`` / ``extended_thinking`` 参数
+
+    Returns:
+        (prepared_body, adaptations) — adaptations 为应用的变换描述列表。
+    """
+    prepared = copy.deepcopy(body)
+    adaptations: list[str] = []
+
+    # Step 1: 剥离 anthropic 的 server_tool_use blocks（web search, computer use 等）
+    removed_stu = _remove_vendor_blocks(prepared, _ANTHROPIC_BETA_BLOCK_TYPES)
+    if removed_stu:
+        adaptations.append(f"removed_{removed_stu}_server_tool_use_blocks")
+
+    # Step 2: 剥离 thinking/redacted_thinking blocks
+    stripped = strip_thinking_blocks(prepared)
+    if stripped:
+        adaptations.append(f"stripped_{stripped}_thinking_blocks")
+
+    # Step 3: 移除 cache_control 字段
+    removed_cc = _strip_cache_control(prepared)
+    if removed_cc:
+        adaptations.append(f"removed_{removed_cc}_cache_control_fields")
+
+    # Step 4: 移除顶层 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 5: 强制 tool_use/tool_result 配对
+    pairing_fixes = enforce_anthropic_tool_pairing(prepared.get("messages", []))
+    if pairing_fixes:
+        adaptations.extend(pairing_fixes)
+
+    return prepared, adaptations
+
+
 # ── zhipu → copilot 转换通道 ─────────────────────────────────────
 
 
@@ -539,8 +736,54 @@ def prepare_zhipu_to_anthropic(
     return prepared, adaptations
 
 
+# ── zhipu → zhipu 自清理通道 ──────────────────────────────────────
+
+
+def prepare_zhipu_self_cleanup(
+    body: dict[str, Any],
+) -> tuple[dict[str, Any], list[str]]:
+    """zhipu → zhipu 自清理: 仅修复 zhipu 自身无法消化的产物.
+
+    GLM-5 偶发地在 assistant 消息中输出 ``tool_result`` 块（违反 Anthropic 规范），
+    或在流式响应中暴露 ``server_tool_use_delta`` 私有块。当 Claude Code 将这些
+    产物原样回送下一轮请求时，zhipu 的 Anthropic 兼容端点会以 400 拒绝
+    （表现为 "400 + tool_results" 偶发，进而触发到 copilot 的降级）。
+
+    本通道仅修复 zhipu 自身拒绝的两类产物，**保留** 所有 zhipu 原生支持的特性:
+
+    - ✓ ``srvtoolu_*`` ID 与 ``server_tool_use`` 类型（zhipu 原生）
+    - ✓ thinking blocks 的 zhipu 自签 signature
+    - ✓ ``cache_control`` 字段（GLM Anthropic 端点支持，cache_read 已实证）
+    - ✓ 顶层 ``thinking`` / ``extended_thinking`` 参数
+
+    清理操作（顺序、就地、幂等）:
+    1. 剥离 ``server_tool_use_delta`` 流式残块
+    2. 强制 tool_use/tool_result 配对（关键: 把 assistant 内联的 tool_result
+       搬迁到紧随的 user 消息）
+
+    Returns:
+        (prepared_body, adaptations) — adaptations 为应用的变换描述列表。
+    """
+    prepared = copy.deepcopy(body)
+    adaptations: list[str] = []
+
+    # Step 1: 剥离 zhipu 私有流式块类型（input 中不应出现）
+    removed_vendor_blocks = _remove_vendor_blocks(prepared, _ZHIPU_VENDOR_BLOCK_TYPES)
+    if removed_vendor_blocks:
+        adaptations.append(f"removed_{removed_vendor_blocks}_zhipu_vendor_blocks")
+
+    # Step 2: 强制 tool_use/tool_result 配对
+    pairing_fixes = enforce_anthropic_tool_pairing(prepared.get("messages", []))
+    if pairing_fixes:
+        adaptations.extend(pairing_fixes)
+
+    return prepared, adaptations
+
+
 # ── 注册所有转换通道 ──────────────────────────────────────────────
 
 VENDOR_TRANSITIONS[("zhipu", "anthropic")] = prepare_zhipu_to_anthropic
 VENDOR_TRANSITIONS[("zhipu", "copilot")] = prepare_zhipu_to_copilot
 VENDOR_TRANSITIONS[("copilot", "zhipu")] = prepare_copilot_to_zhipu
+VENDOR_TRANSITIONS[("zhipu", "zhipu")] = prepare_zhipu_self_cleanup
+VENDOR_TRANSITIONS[("anthropic", "zhipu")] = prepare_anthropic_to_zhipu