fix: 流内 4001 恢复跳过轮换语义（此前被误改为立即终止）

字节级 diff 两实现的请求（头/体）确认渠道特征已完全对齐后，
用户仍报 400。最终定位：上一轮给流式 event ERROR 加 INVALID 分流时
误写为 yield 错误帧 + return——TRAE 4001 后直接终止，不再尝试 CB；
非流式 UpstreamStreamError 分支同样会把 4001 错误地计入冷却。

- 流式：4001 → record_invalid + skip_provider + 轮换到下一上游；
  全部拒绝才以 invalid_request 帧结束（与 HTTP 400 路径语义一致）
- 非流式：UpstreamStreamError 的 INVALID 分支同样跳过 + 轮换

调度轨迹验证：TRAE 4001 → 跳过 → CB 成功接住，TRAE 凭证零冷却。
hy4-preview PI 风格 x6 全部成功。后端 638 测试 / 覆盖 100%。

Author: RobbsLuo

src/engine/executor.py

@@ -128,18 +128,18 @@ async def stream(self, request: ChatRequest, *, username: str = "unknown"
                     if event.kind is EventKind.ERROR:
                         kind = _event_kind(event)
                         if kind is ErrKind.INVALID:
-                            # 流内 4001 等参数/模型错误：换凭证没用，跳过该上游
+                            # 流内 4001 等参数/模型错误：换凭证没用，
+                            # 跳过该上游继续试其他上游；全部拒绝才以 400 结束
                             logger.warning(
                                 "上游 %s 流内拒绝模型 %s（凭证 %s 跳过）: code=%s %s",
                                 provider_id, target.model, credential_id,
                                 event.error_code, event.error_message)
                             self._record_invalid(username, provider_id, credential_id,
                                                  target.model, started, event)
-                            yield _error_frame(
-                                _reject_message(target.model, last_error,
-                                                self._suggestions(target.model)),
-                                "invalid_request")
-                            return
+                            last_error = UpstreamStreamError(event)
+                            last_kind = ErrKind.INVALID
+                            self._skip_provider(provider_id, tried)
+                            break
                         logger.warning(
                             "上游 %s 流内错误（凭证 %s，kind=%s）: code=%s %s",
                             provider_id, credential_id, kind,
@@ -260,8 +260,19 @@ async def complete(self, request: ChatRequest, *, username: str = "unknown"
                     result = aggregate(events, target.model)
                 except UpstreamStreamError as error:
                     kind = _event_kind(error.event)
-                    self._record_error(credential_id, kind)
-                    last_error = error
+                    if kind is ErrKind.INVALID:
+                        # 流内参数/模型错误：跳过该上游继续轮换，不冷却
+                        logger.warning(
+                            "上游 %s 流内拒绝模型 %s（凭证 %s 跳过）: code=%s %s",
+                            provider_id, target.model, credential_id,
+                            error.event.error_code, error.event.error_message)
+                        self._record_invalid(username, provider_id, credential_id,
+                                             target.model, started, error)
+                        last_error, last_kind = error, ErrKind.INVALID
+                        self._skip_provider(provider_id, tried)
+                    else:
+                        self._record_error(credential_id, kind)
+                        last_error = error
                 else:
                     self._deps.credentials.save_success(credential_id)
                     usage = result.get("usage") or {}

src/provider/codebuddy/client.py

@@ -87,6 +87,13 @@ async def stream_chat(self, credential: CodeBuddyCredential, payload: dict[str,
         body = dict(payload)
         body["model"] = model
         body["stream"] = True
+        # 官方 CLI 请求的标准特征字段；缺失会被渠道风控判定非官方调用（11128）
+        body.setdefault("enable_thinking", True)
+        stream_options = body.get("stream_options")
+        body["stream_options"] = {
+            **(stream_options if isinstance(stream_options, dict) else {}),
+            "include_usage": True,
+        }
         url = f"{self.endpoint}{EP_CHAT}"
         async with self._stream.stream(
             "POST", url, json=body, headers=build_headers(credential, self.endpoint),

tests/test_m1b_codebuddy.py

@@ -1165,3 +1165,68 @@ class P:
         "SELECT err_count, cooling_until FROM credentials").fetchone()
     assert tuple(row) == (0, None)                      # 不冷却
     assert any("流内拒绝模型" in r.getMessage() for r in caplog.records)
+
+
+async def test_stream_chat_body_carries_cli_signature_fields():
+    """官方 CLI 特征字段：enable_thinking / stream_options.include_usage。"""
+    import json as _json
+
+    def handler(_request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, text=fixture("chat-basic.sse"))
+
+    captured: dict = {}
+
+    def capture_handler(request: httpx.Request) -> httpx.Response:
+        captured["body"] = _json.loads(request.read())
+        return httpx.Response(200, text=fixture("chat-basic.sse"))
+
+    provider = CodeBuddyProvider(client=_client(capture_handler))
+    payload = {"messages": [{"role": "user", "content": "hi"}],
+               "stream_options": {"include_usage": False}}
+    events = [e async for e in provider.stream_chat({"bearer_token": "t"}, payload, "m")]
+
+    body = captured["body"]
+    assert body["enable_thinking"] is True          # 缺失触发 11128 渠道风控
+    assert body["stream_options"]["include_usage"] is True
+    assert body["stream"] is True
+    assert body["model"] == "m"
+    assert events[-1].kind is EventKind.FINISH
+
+
+async def test_trae_4001_falls_through_to_codebuddy(dual_repo, caplog):
+    """TRAE 流内 4001 → 跳过 TRAE → CB 成功接住；TRAE 凭证不被冷却。"""
+
+    from src.provider.base import Event
+
+    class Trae4001:
+        id = "trae"
+        calls = 0
+
+        async def stream_chat(self, _cred, _payload, _model):
+            self.calls += 1
+            yield Event(kind=EventKind.ERROR, error_code=4001, error_message="param")
+
+    class CbOk:
+        id = "codebuddy"
+        calls = 0
+
+        async def stream_chat(self, _cred, _payload, _model):
+            self.calls += 1
+            yield Event(kind=EventKind.CONTENT, content="ok")
+            yield Event(kind=EventKind.FINISH, finish_reason="stop")
+
+    repo, db = dual_repo
+    repo.add(provider="codebuddy", credential_data={"bearer_token": "cb"})
+    repo.add(provider="trae", credential_data={"accessToken": "tr"})
+    db.connect().execute("UPDATE credentials SET pinned = 1 WHERE provider = 'trae'")
+    trae, cb = Trae4001(), CbOk()
+    executor = Executor(ExecutorDeps(
+        providers={"trae": trae, "codebuddy": cb}, credentials=repo,
+        scheduler=Scheduler(), default_model="m"))
+
+    result = await executor.complete(_request("m"), username="u")
+    assert result["choices"][0]["message"]["content"] == "ok"
+    assert trae.calls == 1 and cb.calls == 1
+    rows = [tuple(r) for r in db.connect().execute(
+        "SELECT err_count, cooling_until FROM credentials ORDER BY provider")]
+    assert rows == [(0, None), (0, None)]       # TRAE 4001 不冷却