deeptrade-quant 0.8.0__tar.gz → 0.9.0__tar.gz

{deeptrade_quant-0.8.0 → deeptrade_quant-0.9.0}/CHANGELOG.md

@@ -2,6 +2,54 @@
 
 All notable changes to DeepTrade. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and SemVer.
 
+## [v0.9.0] — 2026-05-16 — LLM transport 改流式，规避网关 idle-timeout
+
+打板等长生成场景下，`kimi-k2.6` 等 thinking 模型的非流式调用 100% 触发 `LLMTransportError: Request timed out.`，单次失败耗时 ~27 分钟（外层 tenacity 3 次 × openai SDK 3 次 × 180 s）。Moonshot 官方文档明确：思考模型在 server 端先思考再生成，**任何中间网关（包括 Moonshot 自家网关）只要看到长时间无 header 返回就会把 TCP 当僵尸连接切掉**，这是非流式的设计性缺陷，与 base_url / DNS / TLS 均无关。
+
+实证：同一 prompt + `stream=True` 下 TTFC 1.3 s、总耗时 42 s、`content_len=240`、JSON 合法、usage 完整。
+
+### Changed
+
+- `deeptrade/core/llm_client.py::OpenAICompatTransport.chat()` 改为流式：`stream=True` + `stream_options={"include_usage": True}`，逐 chunk 累积 `delta.content` 拼成完整文本，从末 chunk 取 usage。`create()` 与迭代两阶段的 `APITimeoutError` / `APIError` 都包成 `LLMTransportError`，原 tenacity 重试路径不变。
+- 保留 v0.6 / v0.8.1 的两段逻辑：`_adjust_temperature()` 钩子（Moonshot 强制 1.0）与 `supports_reasoning_effort` 门控（仅 `OpenAIOfficialTransport` 翻 True）继续生效。
+- 子类（`GenericOpenAITransport` / `DashScopeTransport` / `MoonshotTransport` / `OpenAIOfficialTransport`）零修改，继承新基类实现。`RecordedTransport`、`LLMClient`、`LLMResponse`、`llm_calls` 表结构、`reports/<run>/llm_calls.jsonl` 格式全部不变。
+
+### Why streaming-only, no fallback
+
+内测期约定：**不留 `stream=False` 开关、不加配置项、不做降级**。理由：
+
+- timeout 语义自然从「整次调用墙钟」变为「单 chunk 间最大不活跃间隔」，更宽容、更符合 LLM 长生成的实际形态；`provider.timeout=180` 字面值无需调整。
+- 流式中途断 → 截断 JSON → 走 `LLMClient._with_retry` 已有的 `LLMValidationError` 1 次 repair-retry，不必单独走非流式 fallback。
+- include_usage 是 OpenAI 协议 2024-07 起的官方约定，in-scope 的全部 provider（OpenAI / Moonshot / DeepSeek / DashScope / Doubao / GLM / Yi / OpenRouter / SiliconFlow）均已支持；万一某末 chunk 缺 usage，审计记 0 不抛。
+
+### Migration notes
+
+- 插件零改动。`LLMClient.complete_json()` 接口、异常类型、返回类型、重试语义、审计格式全部不变。
+- `app_config.llm_providers[*].timeout` 字段保留，语义如上；用户原本配的数值无需调整。
+- 行为差异详见 `docs/fix/2026-05-16-llm-streaming-transport.md` §4.3。
+
+## [v0.8.1] — 2026-05-16 — Moonshot reasoning 模型 temperature 兼容性
+
+`limit-up-board` 等插件接入 Kimi K2.6（``base_url = https://api.moonshot.cn/v1``）后，**所有** LLM 调用 100% 命中 ``HTTP 400 invalid temperature: only 1 is allowed for this model``。根因：Kimi K2 系列的 thinking / reasoning 变体（与 OpenAI o1/o3、Anthropic Sonnet thinking 同侧设计）在服务端硬约束 ``temperature``——仅接受模型专属的固定值，而插件 ``StageProfile`` 出于复现性给的是 ``0.0 ~ 0.2``。
+
+修复职责完全在框架：插件不应感知具体 provider/model 的服务端约束，框架的契约是「插件给一个温度意图，框架在真正发出请求前 sanitize 到目标 provider/model 能接受的取值」。
+
+### Changed
+
+- ``deeptrade/core/llm_client.py::OpenAICompatTransport``：新增 ``_adjust_temperature(model, temperature) -> float`` 钩子，默认 identity；``chat()`` 在写 kwargs 前调用钩子，并在改写时打一行 ``logger.info`` 便于排查。非 Moonshot 路径完全无感。
+- 新增 ``MoonshotTransport(OpenAICompatTransport)``：``_FORCED_TEMPERATURE`` prefix 表强制 ``kimi-k2-thinking`` / ``kimi-k2.5`` / ``kimi-k2.6`` 到 ``1.0``、``kimi-for-coding`` 到 ``0.6``；fallthrough 走 ``min(temperature, 1.0)`` 兼顾非 reasoning 模型（``moonshot-v1-*`` / ``kimi-k2-instruct-*``）的 ``[0, 1]`` 上限——Pydantic 字段允许到 2.0，超界一样 400。
+- ``_TRANSPORT_BY_BASE_URL`` 新增 ``("api.moonshot.cn", MoonshotTransport)``。substring 匹配自动覆盖 ``api.moonshot.cn`` / ``api.moonshot.cn/v1`` 所有形式；国际站 ``api.moonshot.ai`` 暂未支持，若后续需要追加一行即可。
+
+### Why prefix match, not exact / regex
+
+Moonshot 命名空间 ``<major>.<minor>[-<dated-revision>]`` 的天然分界就在 prefix。exact 会让 ``kimi-k2.6-1106`` / ``kimi-k2-thinking-128k`` 这类 dated revision 漏网，触发 0day 失败；regex 转义复杂度抬高 review 成本，收益不抵。
+
+### Migration notes
+
+- 插件零改动。``limit_up_board`` / 其他第三方插件的 ``profiles.py`` 不需要感知该约束。
+- 用户原本在 Kimi reasoning 模型上设的 ``temperature=0.0`` 在改写后会被强制为 ``1.0``——这本来就是服务端唯一允许的取值，不改写就是 100% 失败。
+- ``app.profile`` / ``llm.providers`` 配置无变动。
+
 ## [v0.8.0] — 2026-05-16 — 插件 install / upgrade 走 CDN，零 GitHub API 调用
 
 `deeptrade plugin install` 与 `deeptrade plugin upgrade` 此前在解析"最新版本"与下载 tarball 时各打一次 ``api.github.com``，未认证用户共享 60/h 的 IP 级配额。一旦插件用户数上来，或者用户与浏览器 / `gh` CLI / `git clone` 公共仓库共用同一公网 IP，``HTTP 403: rate limit exceeded`` 就会把 install / upgrade 直接打死。共享 token 会违反 GitHub ToS，且配额仍会在那个 token 上聚合——不是解。

{deeptrade_quant-0.8.0 → deeptrade_quant-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeptrade-quant
-Version: 0.8.0
+Version: 0.9.0
 Summary: LLM-driven A-share (Shanghai/Shenzhen main board) stock screening CLI
 Project-URL: Homepage, https://github.com/ty19880929/deeptrade
 Project-URL: Repository, https://github.com/ty19880929/deeptrade

{deeptrade_quant-0.8.0 → deeptrade_quant-0.9.0}/deeptrade/__init__.py

@@ -2,5 +2,5 @@
 
 from __future__ import annotations
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"
 __all__ = ["__version__"]

{deeptrade_quant-0.8.0 → deeptrade_quant-0.9.0}/deeptrade/core/llm_client.py

@@ -162,6 +162,16 @@ class OpenAICompatTransport(LLMTransport):
         del thinking  # base class has no provider knobs
         return {}
 
+    def _adjust_temperature(self, *, model: str, temperature: float) -> float:
+        """Provider/model-specific temperature sanitization hook.
+
+        Default: identity. Subclasses override to clamp / force temperature
+        for models with server-side hard constraints (e.g. Moonshot reasoning
+        variants that only accept ``temperature == 1``).
+        """
+        del model  # base class has no per-model constraints
+        return temperature
+
     def chat(
         self,
         *,
@@ -173,8 +183,35 @@ class OpenAICompatTransport(LLMTransport):
         thinking: bool,
         reasoning_effort: str,
     ) -> LLMResponse:
+        """Send one chat as a server-sent-event stream and accumulate the
+        deltas into a single :class:`LLMResponse`.
+
+        Streaming is the only supported wire mode (v0.9+). Moonshot's
+        official guidance explicitly warns that long non-streaming
+        generations are killed by intermediate gateways that interpret a
+        long "no headers yet" pause as a dead connection. Streaming makes
+        the server emit ``200 OK`` + SSE headers within ~1 s, so no
+        gateway treats the request as a zombie regardless of how long
+        generation takes. The framework still returns a single
+        ``LLMResponse``; audit log, retry, and plugin code are unaffected.
+
+        ``stream_options={"include_usage": True}`` — every OpenAI-compatible
+        provider currently in scope (OpenAI, Moonshot, DeepSeek, DashScope,
+        Doubao, GLM, Yi, OpenRouter, SiliconFlow) returns ``usage`` on the
+        final chunk when this is set. The final chunk in usage mode has
+        ``choices=[]`` and ``usage`` populated.
+        """
         from openai import APIError, APITimeoutError  # noqa: PLC0415
 
+        adjusted_temperature = self._adjust_temperature(model=model, temperature=temperature)
+        if adjusted_temperature != temperature:
+            logger.info(
+                "transport adjusted temperature for model=%s: %.3f -> %.3f",
+                model,
+                temperature,
+                adjusted_temperature,
+            )
+
         kwargs: dict[str, Any] = {
             "model": model,
             "messages": [
@@ -182,9 +219,10 @@ class OpenAICompatTransport(LLMTransport):
                 {"role": "user", "content": user},
             ],
             "response_format": {"type": "json_object"},
-            "temperature": temperature,
+            "temperature": adjusted_temperature,
             "max_tokens": max_tokens,
-            "stream": False,
+            "stream": True,
+            "stream_options": {"include_usage": True},
         }
         # v0.6 H5 — only send ``reasoning_effort`` when the transport
         # declares support AND the caller actually supplied a non-empty
@@ -199,15 +237,29 @@ class OpenAICompatTransport(LLMTransport):
         # ⚠ HARD CONSTRAINT (M3): we MUST NOT pass tools/tool_choice/functions.
         # If a future maintainer adds them, the no-tools test in V0.5 fails.
 
+        parts: list[str] = []
+        usage: Any = None
         try:
-            resp = self._client.chat.completions.create(**kwargs)
+            stream = self._client.chat.completions.create(**kwargs)
+            for chunk in stream:
+                # In include_usage mode the final chunk carries usage and
+                # an empty choices list. Earlier chunks carry one choice
+                # whose delta.content may be None (role-only opener) or a
+                # text fragment.
+                if chunk.choices:
+                    delta = chunk.choices[0].delta
+                    if delta is not None and delta.content:
+                        parts.append(delta.content)
+                if getattr(chunk, "usage", None) is not None:
+                    usage = chunk.usage
         except (APITimeoutError, APIError) as e:
+            # Errors raised during create() (header phase) or while
+            # iterating the stream (body phase) both surface as
+            # LLMTransportError so tenacity in _transport_call retries.
             raise LLMTransportError(str(e)) from e
 
-        text = resp.choices[0].message.content or ""
-        usage = resp.usage
         return LLMResponse(
-            text=text,
+            text="".join(parts),
             input_tokens=int(getattr(usage, "prompt_tokens", 0) or 0),
             output_tokens=int(getattr(usage, "completion_tokens", 0) or 0),
         )
@@ -236,6 +288,47 @@ class DashScopeTransport(OpenAICompatTransport):
         return {"enable_thinking": thinking}
 
 
+class MoonshotTransport(OpenAICompatTransport):
+    """Moonshot Kimi (``api.moonshot.cn``).
+
+    Reasoning-variant models (``kimi-k2-thinking`` / ``kimi-k2.5`` /
+    ``kimi-k2.6``) have a server-side hard constraint: ``temperature`` MUST
+    equal a model-specific fixed value (1.0 for thinking variants, 0.6 for
+    ``kimi-for-coding``). Any other value returns HTTP 400 ``invalid
+    temperature``.
+
+    Non-reasoning Moonshot models accept the full ``[0, 1]`` range; values
+    above 1 also 400. We handle both: forced equality on known reasoning
+    variants, then fall through to range clamp for everyone else.
+
+    ``_FORCED_TEMPERATURE`` uses **prefix** match so that dated revisions
+    (``kimi-k2.6-1106``, ``kimi-k2-thinking-128k``, …) inherit the same
+    constraint without a code change. Only include models with confirmed
+    server-side enforcement, not just "recommended" values.
+
+    Note: the international site (``api.moonshot.ai``) shares the same
+    constraints — add a routing-table entry there if/when the framework
+    supports it.
+    """
+
+    # model-name prefix → forced temperature value
+    _FORCED_TEMPERATURE: tuple[tuple[str, float], ...] = (
+        ("kimi-k2-thinking", 1.0),
+        ("kimi-k2.5", 1.0),
+        ("kimi-k2.6", 1.0),
+        ("kimi-for-coding", 0.6),
+    )
+
+    def _adjust_temperature(self, *, model: str, temperature: float) -> float:
+        for prefix, forced in self._FORCED_TEMPERATURE:
+            if model.startswith(prefix):
+                return forced
+        # Moonshot accepts only [0, 1] across the whole API; upper-clamp guards
+        # non-reasoning models (moonshot-v1-*, kimi-k2-instruct-*) against a
+        # StageProfile that goes above 1.0 (the Pydantic field allows up to 2).
+        return min(temperature, 1.0)
+
+
 class OpenAIOfficialTransport(OpenAICompatTransport):
     """OpenAI's own ``api.openai.com`` endpoint.
 
@@ -259,6 +352,7 @@ class OpenAIOfficialTransport(OpenAICompatTransport):
 # nowhere else; user-facing config has no "dialect" knob on purpose.
 _TRANSPORT_BY_BASE_URL: tuple[tuple[str, type[OpenAICompatTransport]], ...] = (
     ("dashscope.aliyuncs.com", DashScopeTransport),
+    ("api.moonshot.cn", MoonshotTransport),
     ("api.openai.com", OpenAIOfficialTransport),
 )
 

{deeptrade_quant-0.8.0 → deeptrade_quant-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deeptrade-quant"
-version = "0.8.0"
+version = "0.9.0"
 description = "LLM-driven A-share (Shanghai/Shenzhen main board) stock screening CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{deeptrade_quant-0.8.0 → deeptrade_quant-0.9.0}/tests/core/test_llm_client.py

@@ -22,6 +22,7 @@ from deeptrade.core.llm_client import (
     LLMTransport,
     LLMTransportError,
     LLMValidationError,
+    MoonshotTransport,
     OpenAICompatTransport,
     OpenAIOfficialTransport,
     RecordedTransport,
@@ -79,6 +80,28 @@ def client(db: Database, transport: RecordedTransport) -> LLMClient:
     )
 
 
+def _text_chunk(content: str | None) -> Any:
+    """Fabricate a streaming ChatCompletionChunk with a single delta content
+    fragment. Mirrors what openai SDK yields per delta during ``stream=True``.
+    """
+    from types import SimpleNamespace
+
+    delta = SimpleNamespace(content=content, role=None)
+    choice = SimpleNamespace(delta=delta, index=0, finish_reason=None)
+    return SimpleNamespace(choices=[choice], usage=None)
+
+
+def _final_usage_chunk(*, prompt_tokens: int, completion_tokens: int) -> Any:
+    """Final chunk in ``stream_options={'include_usage': True}`` mode: empty
+    choices list, populated usage."""
+    from types import SimpleNamespace
+
+    return SimpleNamespace(
+        choices=[],
+        usage=SimpleNamespace(prompt_tokens=prompt_tokens, completion_tokens=completion_tokens),
+    )
+
+
 def _ok_response(stage_label: str = "test", n: int = 2) -> LLMResponse:
     payload = {
         "stage": stage_label,
@@ -369,16 +392,15 @@ def test_dashscope_transport_sends_enable_thinking_through_chat(
     """End-to-end wire-shape regression — the kwargs handed to OpenAI's
     chat.completions.create() must carry `extra_body={"enable_thinking": ...}`
     for DashScope, even when thinking=False."""
-    from types import SimpleNamespace
-
     captured: dict[str, Any] = {}
 
     def fake_create(**kwargs: Any) -> Any:
         captured.update(kwargs)
-        choice = SimpleNamespace(message=SimpleNamespace(content='{"k": 1}'))
-        return SimpleNamespace(
-            choices=[choice],
-            usage=SimpleNamespace(prompt_tokens=10, completion_tokens=5),
+        return iter(
+            [
+                _text_chunk('{"k": 1}'),
+                _final_usage_chunk(prompt_tokens=10, completion_tokens=5),
+            ]
         )
 
     t = DashScopeTransport(
@@ -398,6 +420,8 @@ def test_dashscope_transport_sends_enable_thinking_through_chat(
         reasoning_effort="medium",
     )
     assert captured["extra_body"] == {"enable_thinking": False}
+    assert captured["stream"] is True
+    assert captured["stream_options"] == {"include_usage": True}
 
 
 def test_select_transport_class_routes_dashscope_by_base_url() -> None:
@@ -407,6 +431,97 @@ def test_select_transport_class_routes_dashscope_by_base_url() -> None:
     )
 
 
+# ---------------------------------------------------------------------------
+# Moonshot — server-side temperature constraint sanitization
+# ---------------------------------------------------------------------------
+
+
+def test_base_transport_adjust_temperature_is_identity() -> None:
+    """Default hook MUST NOT alter temperature — every non-Moonshot transport
+    relies on this. If this regresses, DashScope / DeepSeek / OpenAI / … will
+    silently start sending different temperatures than the caller requested.
+    """
+    t = GenericOpenAITransport(api_key="dummy", base_url="https://api.deepseek.com", timeout=10)
+    assert t._adjust_temperature(model="deepseek-chat", temperature=0.0) == 0.0
+    assert t._adjust_temperature(model="deepseek-chat", temperature=0.7) == 0.7
+    assert t._adjust_temperature(model="anything", temperature=1.5) == 1.5
+
+
+def test_moonshot_transport_forces_temperature_for_reasoning_variants() -> None:
+    """Kimi K2 reasoning variants only accept ``temperature == <forced>`` on
+    the wire; any other value returns HTTP 400. The transport must clamp to
+    the forced value regardless of what the StageProfile asks for.
+    """
+    t = MoonshotTransport(api_key="dummy", base_url="https://api.moonshot.cn/v1", timeout=10)
+    # forced to 1.0
+    assert t._adjust_temperature(model="kimi-k2.6", temperature=0.2) == 1.0
+    assert t._adjust_temperature(model="kimi-k2.6-1106", temperature=0.1) == 1.0
+    assert t._adjust_temperature(model="kimi-k2-thinking", temperature=0.0) == 1.0
+    assert t._adjust_temperature(model="kimi-k2-thinking-128k", temperature=0.5) == 1.0
+    assert t._adjust_temperature(model="kimi-k2.5", temperature=0.2) == 1.0
+    # forced to 0.6
+    assert t._adjust_temperature(model="kimi-for-coding", temperature=0.0) == 0.6
+    # no-op when caller already supplied the forced value
+    assert t._adjust_temperature(model="kimi-k2.6", temperature=1.0) == 1.0
+
+
+def test_moonshot_transport_clamps_non_reasoning_to_one() -> None:
+    """Non-reasoning Moonshot models accept [0, 1]; values above 1 also 400.
+    Pass through inside the range; clamp above."""
+    t = MoonshotTransport(api_key="dummy", base_url="https://api.moonshot.cn/v1", timeout=10)
+    assert t._adjust_temperature(model="moonshot-v1-32k", temperature=0.1) == 0.1
+    assert t._adjust_temperature(model="kimi-k2-instruct-0905", temperature=0.2) == 0.2
+    assert t._adjust_temperature(model="moonshot-v1-32k", temperature=1.0) == 1.0
+    assert t._adjust_temperature(model="moonshot-v1-32k", temperature=1.5) == 1.0
+
+
+def test_moonshot_transport_sends_forced_temperature_on_wire(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """End-to-end wire-shape regression: chat() composes kwargs with the
+    *adjusted* temperature, not the caller's original value."""
+    captured: dict[str, Any] = {}
+
+    def fake_create(**kwargs: Any) -> Any:
+        captured.update(kwargs)
+        return iter(
+            [
+                _text_chunk('{"k": 1}'),
+                _final_usage_chunk(prompt_tokens=1, completion_tokens=1),
+            ]
+        )
+
+    t = MoonshotTransport(api_key="dummy", base_url="https://api.moonshot.cn/v1", timeout=10)
+    monkeypatch.setattr(t._client.chat.completions, "create", fake_create)
+    t.chat(
+        model="kimi-k2.6",
+        system="s",
+        user="u",
+        temperature=0.2,
+        max_tokens=64,
+        thinking=False,
+        reasoning_effort="",
+    )
+    assert captured["temperature"] == 1.0
+    assert captured["stream"] is True
+    assert captured["stream_options"] == {"include_usage": True}
+
+
+def test_select_transport_class_routes_moonshot() -> None:
+    """``api.moonshot.cn`` (with or without ``/v1``) routes to MoonshotTransport
+    via substring match, same pattern as the other entries in the routing table.
+    """
+    assert _select_transport_class("https://api.moonshot.cn/v1") is MoonshotTransport
+    assert _select_transport_class("https://api.moonshot.cn") is MoonshotTransport
+
+
+def test_moonshot_transport_inherits_reasoning_effort_default() -> None:
+    """Moonshot does not document support for the ``reasoning_effort`` field;
+    it inherits the base-class default (False) — confirm we didn't accidentally
+    flip it on along with adding the transport."""
+    assert MoonshotTransport.supports_reasoning_effort is False
+
+
 # ---------------------------------------------------------------------------
 # v0.6 H5 — reasoning_effort gating
 # ---------------------------------------------------------------------------
@@ -432,16 +547,15 @@ def test_generic_transport_drops_reasoning_effort(monkeypatch: pytest.MonkeyPatc
     """Even when the caller's StageProfile sets ``reasoning_effort='high'``,
     a Generic (non-OpenAI) transport must NOT send the field — most Chinese
     OpenAI-compat providers either ignore or 400 on it."""
-    from types import SimpleNamespace
-
     captured: dict[str, Any] = {}
 
     def fake_create(**kwargs: Any) -> Any:
         captured.update(kwargs)
-        choice = SimpleNamespace(message=SimpleNamespace(content='{"k": 1}'))
-        return SimpleNamespace(
-            choices=[choice],
-            usage=SimpleNamespace(prompt_tokens=1, completion_tokens=1),
+        return iter(
+            [
+                _text_chunk('{"k": 1}'),
+                _final_usage_chunk(prompt_tokens=1, completion_tokens=1),
+            ]
         )
 
     t = GenericOpenAITransport(api_key="dummy", base_url="https://api.deepseek.com", timeout=10)
@@ -458,6 +572,8 @@ def test_generic_transport_drops_reasoning_effort(monkeypatch: pytest.MonkeyPatc
     assert "reasoning_effort" not in captured, (
         "GenericOpenAITransport must not forward reasoning_effort even when the caller sets it"
     )
+    assert captured["stream"] is True
+    assert captured["stream_options"] == {"include_usage": True}
 
 
 def test_openai_official_transport_sends_reasoning_effort(
@@ -465,16 +581,15 @@ def test_openai_official_transport_sends_reasoning_effort(
 ) -> None:
     """The official OpenAI transport forwards ``reasoning_effort`` when the
     caller's StageProfile supplies a non-empty value."""
-    from types import SimpleNamespace
-
     captured: dict[str, Any] = {}
 
     def fake_create(**kwargs: Any) -> Any:
         captured.update(kwargs)
-        choice = SimpleNamespace(message=SimpleNamespace(content='{"k": 1}'))
-        return SimpleNamespace(
-            choices=[choice],
-            usage=SimpleNamespace(prompt_tokens=1, completion_tokens=1),
+        return iter(
+            [
+                _text_chunk('{"k": 1}'),
+                _final_usage_chunk(prompt_tokens=1, completion_tokens=1),
+            ]
         )
 
     t = OpenAIOfficialTransport(api_key="dummy", base_url="https://api.openai.com/v1", timeout=10)
@@ -489,6 +604,8 @@ def test_openai_official_transport_sends_reasoning_effort(
         reasoning_effort="medium",
     )
     assert captured.get("reasoning_effort") == "medium"
+    assert captured["stream"] is True
+    assert captured["stream_options"] == {"include_usage": True}
 
 
 def test_openai_official_transport_drops_empty_reasoning_effort(
@@ -496,16 +613,15 @@ def test_openai_official_transport_drops_empty_reasoning_effort(
 ) -> None:
     """An empty ``reasoning_effort`` (caller declined to set one) is dropped
     even on the official transport — sending an empty string would 400."""
-    from types import SimpleNamespace
-
     captured: dict[str, Any] = {}
 
     def fake_create(**kwargs: Any) -> Any:
         captured.update(kwargs)
-        choice = SimpleNamespace(message=SimpleNamespace(content='{"k": 1}'))
-        return SimpleNamespace(
-            choices=[choice],
-            usage=SimpleNamespace(prompt_tokens=1, completion_tokens=1),
+        return iter(
+            [
+                _text_chunk('{"k": 1}'),
+                _final_usage_chunk(prompt_tokens=1, completion_tokens=1),
+            ]
         )
 
     t = OpenAIOfficialTransport(api_key="dummy", base_url="https://api.openai.com/v1", timeout=10)
@@ -520,6 +636,8 @@ def test_openai_official_transport_drops_empty_reasoning_effort(
         reasoning_effort="",
     )
     assert "reasoning_effort" not in captured
+    assert captured["stream"] is True
+    assert captured["stream_options"] == {"include_usage": True}
 
 
 def test_select_transport_class_defaults_to_generic() -> None:
@@ -532,4 +650,4 @@ def test_select_transport_class_defaults_to_generic() -> None:
     actually reaches the wire; that case is covered separately below.
     """
     assert _select_transport_class("https://api.deepseek.com") is GenericOpenAITransport
-    assert _select_transport_class("https://api.moonshot.cn/v1") is GenericOpenAITransport
+    assert _select_transport_class("https://openrouter.ai/api/v1") is GenericOpenAITransport

deeptrade_quant-0.9.0/tests/core/test_llm_client_streaming.py

@@ -0,0 +1,187 @@
+"""v0.9 — OpenAICompatTransport streaming wire-shape regression.
+
+The transport switched from ``stream=False`` (single blocking response) to
+``stream=True`` + ``stream_options={"include_usage": True}`` to dodge the
+intermediate-gateway idle-timeout that killed long Moonshot-thinking calls.
+These tests pin down:
+
+    * chunk concatenation + final-chunk usage pickup
+    * empty content (thinking model burned the budget) returns ``text=""``
+      so the upper layer can raise ``LLMEmptyResponseError`` itself
+    * transport errors during create() *and* mid-iteration both surface
+      as ``LLMTransportError`` (tenacity retries them)
+    * missing usage on the final chunk records 0/0 rather than crashing
+
+Plugin / audit / retry layers are unaffected and tested elsewhere.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from openai import APITimeoutError
+
+from deeptrade.core.llm_client import (
+    GenericOpenAITransport,
+    LLMTransportError,
+)
+
+
+def _text_chunk(content: str | None) -> Any:
+    delta = SimpleNamespace(content=content, role=None)
+    choice = SimpleNamespace(delta=delta, index=0, finish_reason=None)
+    return SimpleNamespace(choices=[choice], usage=None)
+
+
+def _final_usage_chunk(*, prompt_tokens: int, completion_tokens: int) -> Any:
+    return SimpleNamespace(
+        choices=[],
+        usage=SimpleNamespace(prompt_tokens=prompt_tokens, completion_tokens=completion_tokens),
+    )
+
+
+def _make_transport(stream_chunks: list[Any]) -> GenericOpenAITransport:
+    """Build a GenericOpenAITransport whose openai client returns the given
+    chunk sequence on chat.completions.create(). Bypasses __init__ so we
+    don't construct a real OpenAI client (no API key required)."""
+    t = GenericOpenAITransport.__new__(GenericOpenAITransport)
+    t._client = MagicMock()
+    t._client.chat.completions.create.return_value = iter(stream_chunks)
+    return t
+
+
+class TestStreamingHappyPath:
+    def test_concatenates_chunks_and_picks_up_final_usage(self) -> None:
+        t = _make_transport(
+            [
+                _text_chunk(None),  # role-only opener
+                _text_chunk('{"items":'),
+                _text_chunk('[{"code":"000001","score":7}]'),
+                _text_chunk("}"),
+                _final_usage_chunk(prompt_tokens=50, completion_tokens=20),
+            ]
+        )
+        resp = t.chat(
+            model="m",
+            system="s",
+            user="u",
+            temperature=1.0,
+            max_tokens=512,
+            thinking=False,
+            reasoning_effort="medium",
+        )
+        assert resp.text == '{"items":[{"code":"000001","score":7}]}'
+        assert resp.input_tokens == 50
+        assert resp.output_tokens == 20
+
+    def test_passes_stream_true_and_include_usage(self) -> None:
+        t = _make_transport([_final_usage_chunk(prompt_tokens=1, completion_tokens=1)])
+        t.chat(
+            model="m",
+            system="s",
+            user="u",
+            temperature=1.0,
+            max_tokens=64,
+            thinking=False,
+            reasoning_effort="medium",
+        )
+        kwargs = t._client.chat.completions.create.call_args.kwargs
+        assert kwargs["stream"] is True
+        assert kwargs["stream_options"] == {"include_usage": True}
+        # M3 hard constraint — no tools, ever.
+        assert "tools" not in kwargs
+        assert "tool_choice" not in kwargs
+        assert "functions" not in kwargs
+
+
+class TestStreamingEmptyContent:
+    def test_no_content_chunks_yields_empty_text(self) -> None:
+        """Thinking model burns its budget on internal reasoning before
+        emitting any visible content. The transport itself does NOT raise —
+        it honestly returns ``text=""``; ``LLMClient._with_retry`` is what
+        promotes that into ``LLMEmptyResponseError``."""
+        t = _make_transport(
+            [
+                _text_chunk(None),  # role-only
+                _final_usage_chunk(prompt_tokens=50, completion_tokens=2048),
+            ]
+        )
+        resp = t.chat(
+            model="m",
+            system="s",
+            user="u",
+            temperature=1.0,
+            max_tokens=2048,
+            thinking=False,
+            reasoning_effort="medium",
+        )
+        assert resp.text == ""
+        assert resp.output_tokens == 2048
+
+
+class TestStreamingErrors:
+    def test_timeout_during_create_wraps_to_LLMTransportError(self) -> None:
+        t = GenericOpenAITransport.__new__(GenericOpenAITransport)
+        t._client = MagicMock()
+        t._client.chat.completions.create.side_effect = APITimeoutError(request=MagicMock())
+        with pytest.raises(LLMTransportError):
+            t.chat(
+                model="m",
+                system="s",
+                user="u",
+                temperature=1.0,
+                max_tokens=64,
+                thinking=False,
+                reasoning_effort="medium",
+            )
+
+    def test_timeout_during_iteration_wraps_to_LLMTransportError(self) -> None:
+        """Errors mid-stream (connection reset after headers, gateway drop
+        between chunks) must also surface as LLMTransportError so tenacity
+        retries — otherwise the partial bytes leak as an opaque exception."""
+
+        def raising_iter() -> Any:
+            yield _text_chunk('{"items":[')
+            raise APITimeoutError(request=MagicMock())
+
+        t = GenericOpenAITransport.__new__(GenericOpenAITransport)
+        t._client = MagicMock()
+        t._client.chat.completions.create.return_value = raising_iter()
+        with pytest.raises(LLMTransportError):
+            t.chat(
+                model="m",
+                system="s",
+                user="u",
+                temperature=1.0,
+                max_tokens=64,
+                thinking=False,
+                reasoning_effort="medium",
+            )
+
+
+class TestStreamingUsageMissing:
+    def test_missing_usage_records_zero_not_raise(self) -> None:
+        """In-scope providers all populate usage on the final chunk when
+        ``include_usage`` is set, but the transport must not crash if a
+        provider omits it — it just records 0/0 and lets the call return."""
+        t = _make_transport(
+            [
+                _text_chunk("ok"),
+                SimpleNamespace(choices=[], usage=None),  # final chunk, no usage
+            ]
+        )
+        resp = t.chat(
+            model="m",
+            system="s",
+            user="u",
+            temperature=1.0,
+            max_tokens=64,
+            thinking=False,
+            reasoning_effort="medium",
+        )
+        assert resp.text == "ok"
+        assert resp.input_tokens == 0
+        assert resp.output_tokens == 0