@peterwangze/claude-trigger-router 1.11.0 → 1.12.0

package/README.md

@@ -218,14 +218,14 @@ ANTHROPIC_AUTH_TOKEN=<managed-key>
 - 配置指南：[docs/configuration-guide.md](docs/configuration-guide.md)
 - Models 迁移：[docs/models-migration-guide.md](docs/models-migration-guide.md)
 - CLI 测试矩阵：[docs/cli-test-matrix.md](docs/cli-test-matrix.md)
-- 发布说明：[docs/release-notes-v1.11.0.md](docs/release-notes-v1.11.0.md)
+- 发布说明：[docs/release-notes-v1.12.0.md](docs/release-notes-v1.12.0.md)
 - 发布验证：[docs/releasing.md](docs/releasing.md)
 
-## v1.11.0 发布定位
+## v1.12.0 发布定位
 
-`v1.11.0` 是基础路由流式稳定性与 socket 错误修复版。它修复 `v1.8.0` 之后流式 response governance 默认全量缓冲导致的基础路由输出中断，并让上游结构化 API error 稳定返回，不再被转换成 socket-level hook error。
+`v1.12.0` 是流式传输韧性与远程中转稳定性修复版。它在 `v1.11.0` 首轮止血基础上继续修复用户复现的 socket 断连和中转卡顿：上游流式中途断开时返回可读 SSE error event，远程中转会在客户端断开时主动取消上游请求，并修复 SSE parser 在多字节字符跨 chunk 时的解析风险。
 
-这个版本不新增 SmartRouter 协作模式、不改变远程客户端配置心智；`v1.10.0` 的 routing advisor、confidence threshold、latency budget 和 collaboration contract 继续保留。完整发布边界见 [docs/release-notes-v1.11.0.md](docs/release-notes-v1.11.0.md)。
+这个版本不新增 SmartRouter 协作模式、不改变远程客户端配置心智；`v1.10.0` 的 routing advisor、confidence threshold、latency budget 和 collaboration contract 继续保留。完整发布边界见 [docs/release-notes-v1.12.0.md](docs/release-notes-v1.12.0.md)。
 
 ## License
 

package/dist/cli.js

@@ -4299,16 +4299,21 @@ var init_SSEParser_transform = __esm({
     SSEParserTransform = class {
       buffer = "";
       currentEvent = {};
+      decoder = new TextDecoder();
       constructor() {
         const transformStream = new TransformStream({
           start: (controller) => {
           },
           transform: (chunk, controller) => {
-            const text = new TextDecoder().decode(chunk);
+            const text = this.decoder.decode(chunk, { stream: true });
             this.buffer += text;
             this.parseBuffer(controller);
           },
           flush: (controller) => {
+            const remaining = this.decoder.decode();
+            if (remaining) {
+              this.buffer += remaining;
+            }
             if (this.buffer.trim()) {
               this.parseBuffer(controller, true);
             } else if (Object.keys(this.currentEvent).length > 0) {
@@ -4363,6 +4368,15 @@ function serializeEvent(event2) {
   output3 += "\n";
   return new TextEncoder().encode(output3);
 }
+function serializeStreamErrorEvent(message) {
+  return serializeEvent({
+    event: "error",
+    data: {
+      type: "upstream_stream_error",
+      message
+    }
+  });
+}
 function parseSSEBlock(block) {
   const event2 = {};
   const dataLines = [];
@@ -4422,6 +4436,9 @@ function finalizeStreamingTrace(req, observation) {
   for (const finding of outputGuardrail.findings) {
     appendTraceReason(req.governanceTrace, `output_guardrail:${finding.code}`);
   }
+  if (observation.streamError) {
+    appendTraceReason(req.governanceTrace, "upstream_stream_error");
+  }
   req.governanceTrace.handoffSummary = summarizeRouteHandoffTrace(
     req.governanceTrace,
     getRuntimePipeline(req)
@@ -4439,25 +4456,44 @@ function passThroughStreamingResponse(stream, req) {
   const decoder = new TextDecoder();
   const observation = { text: "", sawText: false };
   let buffer = "";
-  return stream.pipeThrough(new TransformStream({
-    transform(chunk, controller) {
-      controller.enqueue(chunk);
-      buffer = observeSSEChunk(buffer, decoder.decode(chunk, { stream: true }), observation);
-    },
-    flush() {
-      const remaining = decoder.decode();
-      if (remaining) {
-        buffer = observeSSEChunk(buffer, remaining, observation);
-      }
-      if (buffer.trim()) {
-        const event2 = parseSSEBlock(buffer);
-        if (event2) {
-          collectEventObservation(event2, observation);
+  let reader;
+  return new ReadableStream({
+    async start(controller) {
+      reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          controller.enqueue(value);
+          buffer = observeSSEChunk(buffer, decoder.decode(value, { stream: true }), observation);
         }
+      } catch (error) {
+        const message = error instanceof Error && error.message ? error.message : "The upstream stream closed before completion.";
+        observation.streamError = message;
+        controller.enqueue(serializeStreamErrorEvent("The upstream stream closed before completion."));
+      } finally {
+        const remaining = decoder.decode();
+        if (remaining) {
+          buffer = observeSSEChunk(buffer, remaining, observation);
+        }
+        if (buffer.trim()) {
+          const event2 = parseSSEBlock(buffer);
+          if (event2) {
+            collectEventObservation(event2, observation);
+          }
+        }
+        finalizeStreamingTrace(req, observation);
+        reader.releaseLock();
+        reader = void 0;
+        controller.close();
       }
-      finalizeStreamingTrace(req, observation);
+    },
+    cancel(reason) {
+      return reader?.cancel(reason);
     }
-  }));
+  });
 }
 async function collectSSE(stream) {
   const parser = new SSEParserTransform();
@@ -11754,6 +11790,37 @@ function buildRemoteForwardHeaders(req, authToken) {
   headers["x-ctr-remote-forward"] = "1";
   return headers;
 }
+function isSSEContentType(contentType) {
+  return Boolean(contentType?.toLowerCase().includes("text/event-stream"));
+}
+function clearTimerOnStreamClose(stream, clear) {
+  let reader;
+  return new ReadableStream({
+    async start(controller) {
+      reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          controller.enqueue(value);
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        clear();
+        reader?.releaseLock();
+        reader = void 0;
+      }
+    },
+    cancel(reason) {
+      clear();
+      return reader?.cancel(reason);
+    }
+  });
+}
 async function forwardModelCallToRemote(req, reply, config) {
   if (!isModelCallPath(req.url) || !isRemoteForwardEnabled(config) || req.headers?.["x-ctr-remote-forward"] === "1") {
     return false;
@@ -11763,12 +11830,28 @@ async function forwardModelCallToRemote(req, reply, config) {
   const forwardPath = getRemoteForwardPath(req.url);
   const path = forwardPath.split("?")[0];
   const targetUrl = `${remoteBaseUrl}${forwardPath}`;
+  const abortController = new AbortController();
+  let timeout;
+  const clearRemoteTimeout = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+  };
+  timeout = setTimeout(() => {
+    abortController.abort(new Error("remote_forward_timeout"));
+  }, config.API_TIMEOUT_MS ?? 6e5);
+  const abortOnClientClose = () => {
+    clearRemoteTimeout();
+    abortController.abort(new Error("client_connection_closed"));
+  };
+  reply.raw?.once?.("close", abortOnClientClose);
   try {
     const response = await fetch(targetUrl, {
       method: String(req.method ?? "POST").toUpperCase(),
       headers: buildRemoteForwardHeaders(req, remoteService.auth_token),
       body: req.body === void 0 ? void 0 : JSON.stringify(req.body),
-      signal: AbortSignal.timeout(config.API_TIMEOUT_MS ?? 6e5)
+      signal: abortController.signal
     });
     reply.code(response.status);
     const contentType = response.headers.get("content-type");
@@ -11782,9 +11865,11 @@ async function forwardModelCallToRemote(req, reply, config) {
     req.remoteForwarded = true;
     req.responseGovernanceApplied = true;
     if (response.body) {
-      reply.send(response.body);
+      const body = clearTimerOnStreamClose(response.body, clearRemoteTimeout);
+      reply.send(isSSEContentType(contentType) ? governStreamingResponse(body, req, config, config.PORT ?? 5678) : body);
       return true;
     }
+    clearRemoteTimeout();
     reply.send(response.ok ? {} : { error: `Remote service returned HTTP ${response.status}` });
     return true;
   } catch (error) {
@@ -11801,6 +11886,10 @@ async function forwardModelCallToRemote(req, reply, config) {
       }
     });
     return true;
+  } finally {
+    if (!req.remoteForwarded) {
+      clearRemoteTimeout();
+    }
   }
 }
 async function run(options = {}) {