@@ -159,6 +159,8 @@ services:
       STREAM_IDLE_TIMEOUT_SECONDS: ${STREAM_IDLE_TIMEOUT_SECONDS:-0}
       # 短冷却「等待续上」（秒）：全池都在短冷却时最多等这么久再取一次；0 关闭
       SHORT_COOLDOWN_WAIT_SECONDS: ${SHORT_COOLDOWN_WAIT_SECONDS:-0}
+      # 非流式出口保活（秒）：N 秒内没聚合完就转 chunked 吐空白心跳；0 关闭
+      NONSTREAM_KEEPALIVE_SECONDS: ${NONSTREAM_KEEPALIVE_SECONDS:-0}
       # 单账号在途请求上限（跨渠道全局）；0 = 不限
       MAX_INFLIGHT_PER_CREDENTIAL: ${MAX_INFLIGHT_PER_CREDENTIAL:-0}
       # Prometheus 指标出口（GET /metrics，无鉴权，与 /healthz 同口径）；false 关闭
 
@@ -19,10 +19,11 @@
 from ..config import Settings
 from ..engine.compress import estimate_messages
 from ..engine.executor import Executor, StreamSink
+from ..engine.sse import SSE_COMMENT
 from ..key_quota import Lease, QuotaExceeded
 from ..runtime_settings import RuntimeSettings
 from .deps import ApiKeyPrincipal, get_services, read_json_body
-from .streaming import with_keepalive
+from .streaming import respond_with_keepalive, with_keepalive
 
 
 def ensure_model_allowed(chat_request: ChatRequest, principal: ApiKeyPrincipal,
@@ -98,12 +99,26 @@ async def dispatch_compat(
             lease.release()          # 400 不该占着并发名额
             raise
         translator = translator_for(target.model) if translator_for else None
+        # 心跳帧随出口协议走：Anthropic 要 `event: ping` 具名事件（只解析
+        # `event:` 行的客户端会忽略注释帧），chat / Responses 保持注释帧
+        # （Responses 无 ping 事件，未知事件类型会让严格解析器报错）。
+        keepalive_frame = (translator.keepalive() if translator is not None
+                           else SSE_COMMENT)
         frames = with_keepalive(executor.stream_guarded(chat_request,
                                                         username=principal.username,
                                                         translator=translator,
-                                                        provider_binding=binding))
+                                                        provider_binding=binding),
+                                keepalive_frame=keepalive_frame)
         return StreamingResponse(
             _release_when_done(frames, lease), media_type="text/event-stream")
+    # 非流式保活（`nonstream_keepalive_seconds`，默认 0 = 关闭）：宽限期内
+    # 完成仍是逐字节相同的 JSONResponse，超时才转 chunked 吐空白心跳。
+    keepalive = float(getattr(settings, "nonstream_keepalive_seconds", 0) or 0)
+    if keepalive > 0:
+        return await respond_with_keepalive(
+            lambda: executor.complete(chat_request, username=principal.username,
+                                      provider_binding=binding),
+            grace=keepalive, convert=convert, release=lease.release)
     try:
         completion = await executor.complete(chat_request, username=principal.username,
                                              provider_binding=binding)
 
@@ -3,24 +3,46 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncIterator
+import json
+import logging
+from collections.abc import AsyncIterator, Awaitable, Callable
+from typing import Any
+
+from starlette.responses import JSONResponse, Response, StreamingResponse
 
 from ..engine.sse import SSE_COMMENT
 
+logger = logging.getLogger(__name__)
+
 # 上游思考/排队时可能长时间不吐字节；nginx proxy_read_timeout 默认 60s，
 # 空闲超过它就会断开连接。SSE 注释帧被客户端忽略，只为保活。
 KEEPALIVE_SECONDS = 15.0
 
+# 非流式保活字节：JSON 允许任意前导空白（RFC 8259 §2 `JSON-text = ws value ws`），
+# 解析器（Python json / JS JSON.parse / Go encoding/json）都照常接受
+# `"\n\n{\"a\":1}"`。发换行比发空格更不容易被中间盒做行首嗅探改写。
+JSON_KEEPALIVE_BYTES = b"\n"
+
 
 async def with_keepalive(frames: AsyncIterator[bytes],
-                         interval: float = KEEPALIVE_SECONDS) -> AsyncIterator[bytes]:
-    """在上游无输出的空隙插入 SSE 注释帧。
+                         interval: float | None = None,
+                         keepalive_frame: bytes = SSE_COMMENT) -> AsyncIterator[bytes]:
+    """在上游无输出的空隙插入心跳帧。
+
+    `keepalive_frame` 由出口协议决定：chat / Responses 用 SSE 注释帧（被客户端
+    忽略），Anthropic 用具名 `event: ping`（部分客户端只解析 `event:` 行，注释帧
+    对它们等于没有字节，长静默下仍会判超时）。
+
+    `interval=None` 读模块常量 `KEEPALIVE_SECONDS`（运行期读而非默认参数，
+    否则 import 时就定死，测试无法缩短）。
 
     实现要点：取下一帧用**可复用的 Task** 而不是 `wait_for(anext(...))`。
     后者在超时时会 cancel 掉 `anext` 协程，取消会穿透进上游生成器并把
     它关闭——心跳反而变成了断流。这里用 `asyncio.wait` 与定时器竞争，
-    超时只发注释、待取帧的 Task 继续存活。
+    超时只发心跳、待取帧的 Task 继续存活。
     """
+    if interval is None:
+        interval = KEEPALIVE_SECONDS
     iterator = frames.__aiter__()
     pending: asyncio.Task[bytes] | None = None
     try:
@@ -41,11 +63,102 @@ async def with_keepalive(frames: AsyncIterator[bytes],
                 continue
             # 定时器先到：上游暂无输出 → 发心跳，保留 pending 继续等
             ticker.cancel()
-            yield SSE_COMMENT
+            yield keepalive_frame
     finally:
         # 客户端断开 / 生成器关闭：清掉在途任务，避免 "Task was destroyed"。
         # cancel() 只是「请求取消」，必须 await 到任务真正结束再退出——否则
         # 生成器所在事件循环很快回收，任务以 pending 状态被销毁并打印告警。
         if pending is not None and not pending.done():
             pending.cancel()
             await asyncio.gather(pending, return_exceptions=True)
+
+
+# 保活已提交 200 之后上游才失败时的正文：状态码已经发出去了，改不回来，只能
+# 给一个可解析的 JSON 错误体（比截断强：截断的 JSON 在客户端是解码异常，
+# 完全看不出是上游问题）。文案固定，不回显上游正文。
+LATE_FAILURE_PAYLOAD: dict[str, Any] = {
+    "error": {
+        "message": "upstream request failed after the response had started",
+        "type": "api_error",
+        "code": "upstream_error",
+        "status": 502,
+    }
+}
+
+
+def _dumps(payload: Any) -> bytes:
+    """与 `JSONResponse.render` 逐字节一致（分隔符/allow_nan 都对齐）。"""
+    return json.dumps(payload, ensure_ascii=False, allow_nan=False,
+                      indent=None, separators=(",", ":")).encode("utf-8")
+
+
+async def respond_with_keepalive(
+        work: Callable[[], Awaitable[dict[str, Any]]],
+        *, grace: float,
+        convert: Callable[[dict[str, Any]], Any] | None = None,
+        release: Callable[[], None] | None = None) -> Response:
+    """非流式出口的保活（`nonstream_keepalive_seconds`，默认 0 关闭）。
+
+    **宽限期设计**：先等 `grace` 秒。
+
+    - 期间完成 → 返回普通 `JSONResponse`：状态码、`Content-Length`、字节内容
+      与不开保活时**完全一致**，异常也照常抛给上层异常处理器（400/503 不变）。
+    - 超时 → 才提交 200 + chunked，先吐空白字节再补正文。
+
+    为什么不一开始就用 `StreamingResponse`：那样 200 在聚合前就发出去了，
+    之后任何失败（无可用凭证 503 / 请求无效 400）都改不回来。宽限期把
+    「改不回来」的窗口压到只有真正超过 `grace` 的请求。
+
+    空白字节合法：RFC 8259 §2 规定 `JSON-text = ws value ws`，值前允许任意
+    空白，故 `"\\n\\n{...}"` 仍是合法 JSON（Python `json.loads` / JS
+    `JSON.parse` 均已实测接受）。
+    """
+    task = asyncio.ensure_future(work())
+    try:
+        done, _ = await asyncio.wait({task}, timeout=grace)
+    except BaseException:
+        # 客户端断开 / 上层取消：必须把工作协程一起收掉，否则它继续跑完整个
+        # 上游调用（真实计费）却没人接收结果。
+        task.cancel()
+        await asyncio.gather(task, return_exceptions=True)
+        if release is not None:
+            release()
+        raise
+    if task in done:
+        try:
+            completion = task.result()
+        finally:
+            if release is not None:
+                release()
+        return JSONResponse(convert(completion) if convert else completion)
+    return StreamingResponse(
+        _json_frames(task, grace, convert, release),
+        media_type="application/json",
+        headers={"X-Accel-Buffering": "no", "Cache-Control": "no-store"})
+
+
+async def _json_frames(task: asyncio.Task[dict[str, Any]], interval: float,
+                       convert: Callable[[dict[str, Any]], Any] | None,
+                       release: Callable[[], None] | None) -> AsyncIterator[bytes]:
+    """慢请求的正文生成器：空闲 `interval` 秒就吐一个空白字节。"""
+    try:
+        while not task.done():
+            await asyncio.wait({task}, timeout=interval)
+            if not task.done():
+                yield JSON_KEEPALIVE_BYTES
+        try:
+            completion = task.result()
+        except asyncio.CancelledError:
+            raise
+        except Exception:  # noqa: BLE001 - 已提交 200，只能写进正文
+            logger.warning("非流式保活：200 已提交后上游才失败，正文降级为错误体",
+                           exc_info=True)
+            yield _dumps(LATE_FAILURE_PAYLOAD)
+            return
+        yield _dumps(convert(completion) if convert else completion)
+    finally:
+        if not task.done():
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+        if release is not None:
+            release()
@@ -157,10 +157,13 @@ def finish(self) -> Iterator[bytes]:
         yield from self._close("stop")
 
     def keepalive(self) -> bytes:
-        """SSE 注释帧心跳（与 chat / Responses 出口同一约定）。"""
-        from ...engine.sse import SSE_COMMENT
+        """Anthropic 心跳：具名 `ping` 事件（不是 SSE 注释帧）。
 
-        return SSE_COMMENT
+        官方流式规范里的 `ping` 是**具名事件**（`event: ping` +
+        `data: {"type": "ping"}`），客户端只解析 `event:` 行时注释帧等于没有
+        字节，长静默（推理模型 TTFT 可达 40s）下仍会判超时断开。
+        """
+        return b'event: ping\ndata: {"type": "ping"}\n\n'
 
     def error_frame(self, message: str, code: str) -> bytes:
         """出口错误帧：Anthropic 用 `event: error`（无 [DONE] 哨兵）。"""
 
@@ -2,7 +2,8 @@
 
 约定（继承 codebuddy2api 的语义）：
 - 首块补 role:assistant
-- 上游缺失 index 的 tool_calls 补稳定 index，不重生成 id
+- 上游缺失 index 的 tool_calls 补稳定 index，不重生成已有 id；`id` 缺失时
+  按 index 补一个稳定值（OpenAI 客户端按 id 聚合分片，缺 id 会丢工具调用）
 - reasonng 走 delta.reasoning_content
 - 流以 data: [DONE] 结束
 """
@@ -58,19 +59,26 @@ def _completion_id() -> str:
 
 @dataclass
 class ToolIndexState:
-    """优先沿用上游 index，缺失时按出现顺序补稳定位置。"""
+    """优先沿用上游 index，缺失时按出现顺序补稳定位置；`id` 缺失时补稳定 id。
+
+    上游（尤其聚合型中转）偶尔只发 `function.arguments` 分片而不发 `id`。
+    OpenAI 客户端按 `id` 聚合流式工具调用分片，缺 id 的分片会被丢弃，表现为
+    「模型调了工具但客户端收不到」。故按 index 生成并记忆 id，后续同 index 的
+    分片沿用同一个值（每次现生成会让同一调用被拆成多个）。
+    """
 
     id_to_index: dict[str, int] = field(default_factory=dict)
+    index_to_id: dict[int, str] = field(default_factory=dict)
     used: set[int] = field(default_factory=set)
+    _seq: int = 0
 
     def resolve(self, tool_call: dict[str, Any]) -> tuple[dict[str, Any], int]:
         item = dict(tool_call)
         index = item.get("index")
         tool_id = item.get("id")
         if isinstance(index, int) and not isinstance(index, bool):
             self.used.add(index)
-            if isinstance(tool_id, str) and tool_id:
-                self.id_to_index[tool_id] = index
+            self._bind(index, tool_id, item)
             return item, index
         if isinstance(tool_id, str) and tool_id and tool_id in self.id_to_index:
             resolved = self.id_to_index[tool_id]
@@ -80,11 +88,27 @@ def resolve(self, tool_call: dict[str, Any]) -> tuple[dict[str, Any], int]:
         while candidate in self.used:
             candidate += 1
         self.used.add(candidate)
-        if isinstance(tool_id, str) and tool_id:
-            self.id_to_index[tool_id] = candidate
+        self._bind(candidate, tool_id, item)
         item["index"] = candidate
         return item, candidate
 
+    def _bind(self, index: int, tool_id: Any, item: dict[str, Any]) -> None:
+        """登记 id↔index 双向映射；`id` 缺失时按 index 补一个稳定值。
+
+        每片都补同一个 id（而不是只补首片）：按 id 聚合的客户端若在续片上
+        拿到空 id，会把一次调用拆成两条；重复同一个 id 则各种聚合方式都安全。
+        """
+        if isinstance(tool_id, str) and tool_id:
+            self.id_to_index[tool_id] = index
+            self.index_to_id.setdefault(index, tool_id)
+            return
+        existing = self.index_to_id.get(index)
+        if existing is None:
+            self._seq += 1
+            existing = f"call_{index}_{self._seq}"
+            self.index_to_id[index] = existing
+        item["id"] = existing
+
 
 class StreamTranslator:
     """把 Event 序列翻译为 OpenAI SSE 帧序列。"""
 
@@ -190,7 +190,12 @@ def finish(self) -> Iterator[bytes]:
         yield from self._close("stop")
 
     def keepalive(self) -> bytes:
-        """SSE 注释帧心跳（与 chat 出口同一约定）。"""
+        """SSE 注释帧心跳（与 chat 出口同一约定）。
+
+        **不能改成 `event: ping`**：Responses API 没有 ping 事件类型，严格
+        解析器收到未知事件会直接报错（`MAXeaglet/commandcode-proxy` 的实测
+        结论，与 Anthropic 出口的处理相反）。
+        """
         from ...engine.sse import SSE_COMMENT
 
         return SSE_COMMENT