@peterwangze/claude-trigger-router 1.10.0 → 1.12.0

package/dist/cli.js

@@ -4298,18 +4298,26 @@ var init_SSEParser_transform = __esm({
     "use strict";
     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);
+              this.parseBuffer(controller, true);
+            } else if (Object.keys(this.currentEvent).length > 0) {
+              this.parseBuffer(controller, true);
             }
           }
         });
@@ -4318,25 +4326,29 @@ var init_SSEParser_transform = __esm({
       }
       readable;
       writable;
-      parseBuffer(controller) {
-        const lines = this.buffer.split("\n");
-        this.buffer = lines.pop() || "";
-        let currentEvent = {};
-        for (const line of lines) {
+      parseBuffer(controller, flush = false) {
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = flush ? "" : lines.pop() || "";
+        for (const rawLine of lines) {
+          const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
           if (line.startsWith("event:")) {
-            currentEvent.event = line.slice(6).trim();
+            this.currentEvent.event = line.slice(6).trim();
           } else if (line.startsWith("data:")) {
             const dataStr = line.slice(5).trim();
             try {
-              currentEvent.data = JSON.parse(dataStr);
+              this.currentEvent.data = JSON.parse(dataStr);
             } catch {
-              currentEvent.data = dataStr;
+              this.currentEvent.data = dataStr;
             }
-          } else if (line === "" && Object.keys(currentEvent).length > 0) {
-            controller.enqueue(currentEvent);
-            currentEvent = {};
+          } else if (line === "" && Object.keys(this.currentEvent).length > 0) {
+            controller.enqueue(this.currentEvent);
+            this.currentEvent = {};
           }
         }
+        if (flush && Object.keys(this.currentEvent).length > 0) {
+          controller.enqueue(this.currentEvent);
+          this.currentEvent = {};
+        }
       }
     };
   }
@@ -4356,6 +4368,133 @@ 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 = [];
+  for (const rawLine of block.split(/\r?\n/)) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line.startsWith("event:")) {
+      event2.event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trim());
+    }
+  }
+  if (dataLines.length > 0) {
+    const dataStr = dataLines.join("\n");
+    try {
+      event2.data = JSON.parse(dataStr);
+    } catch {
+      event2.data = dataStr;
+    }
+  }
+  return Object.keys(event2).length > 0 ? event2 : null;
+}
+function collectEventObservation(event2, observation) {
+  const deltaText = event2?.data?.delta?.text;
+  if (typeof deltaText === "string") {
+    observation.sawText = true;
+    observation.text += deltaText;
+  }
+  if (event2?.event === "message_delta" && event2?.data?.usage) {
+    observation.usage = event2.data.usage;
+  }
+}
+function observeSSEChunk(buffer, chunkText, observation) {
+  let nextBuffer = buffer + chunkText;
+  while (true) {
+    const match = /\r?\n\r?\n/.exec(nextBuffer);
+    if (!match || match.index < 0) {
+      break;
+    }
+    const block = nextBuffer.slice(0, match.index);
+    nextBuffer = nextBuffer.slice(match.index + match[0].length);
+    const event2 = parseSSEBlock(block);
+    if (event2) {
+      collectEventObservation(event2, observation);
+    }
+  }
+  return nextBuffer;
+}
+function finalizeStreamingTrace(req, observation) {
+  if (req.sessionId && observation.usage) {
+    sessionUsageCache.put(req.sessionId, observation.usage);
+  }
+  if (!req.governanceTrace) {
+    return;
+  }
+  const outputGuardrail = inspectOutputGuardrail(observation.text);
+  req.governanceTrace.outputGuardrail = outputGuardrail;
+  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)
+  );
+  req.governanceTrace.spans = buildTraceSpansFromPipeline(
+    req.governanceTrace,
+    getRuntimePipeline(req)
+  );
+  req.governanceTrace = finalizeTrace(req.governanceTrace, {
+    finalModel: req.body?.model ?? req.governanceTrace.finalModel
+  });
+  recordGovernanceTrace(req.governanceTrace);
+}
+function passThroughStreamingResponse(stream, req) {
+  const decoder = new TextDecoder();
+  const observation = { text: "", sawText: false };
+  let buffer = "";
+  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();
+      }
+    },
+    cancel(reason) {
+      return reader?.cancel(reason);
+    }
+  });
+}
 async function collectSSE(stream) {
   const parser = new SSEParserTransform();
   const parsedStream = stream.pipeThrough(parser);
@@ -4395,6 +4534,12 @@ function governStreamingResponse(stream, req, config, servicePort, deps) {
       to: resolveModelReference(config, level.to) ?? level.to
     }))
   } : void 0;
+  const shouldBufferForStreamGuard = Boolean(
+    config.Governance?.enabled && resolvedCascadeConfig?.enabled && resolvedCascadeConfig.stream_guard && req.governanceTrace
+  );
+  if (!shouldBufferForStreamGuard) {
+    return passThroughStreamingResponse(stream, req);
+  }
   return new ReadableStream({
     async start(controller) {
       try {
@@ -11552,6 +11697,25 @@ var init_protocols = __esm({
 });
 
 // src/index.ts
+function getShutdownSignalHandlers() {
+  const store = globalThis;
+  if (!store[SHUTDOWN_SIGNAL_HANDLERS_KEY]) {
+    store[SHUTDOWN_SIGNAL_HANDLERS_KEY] = [];
+  }
+  return store[SHUTDOWN_SIGNAL_HANDLERS_KEY];
+}
+function registerShutdownSignalHandlers(shutdown) {
+  const handlers = getShutdownSignalHandlers();
+  for (const { signal, handler } of handlers) {
+    process.off(signal, handler);
+  }
+  handlers.length = 0;
+  for (const signal of SHUTDOWN_SIGNALS) {
+    const handler = () => shutdown(signal);
+    process.on(signal, handler);
+    handlers.push({ signal, handler });
+  }
+}
 function cloneRequestBody(value) {
   if (typeof structuredClone === "function") {
     return structuredClone(value);
@@ -11626,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;
@@ -11635,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");
@@ -11654,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) {
@@ -11673,6 +11886,10 @@ async function forwardModelCallToRemote(req, reply, config) {
       }
     });
     return true;
+  } finally {
+    if (!req.remoteForwarded) {
+      clearRemoteTimeout();
+    }
   }
 }
 async function run(options = {}) {
@@ -11722,8 +11939,7 @@ async function run(options = {}) {
       process.exit(0);
     });
   };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  registerShutdownSignalHandlers(shutdown);
   const servicePort = process.env.SERVICE_PORT ? parseInt(process.env.SERVICE_PORT) : port;
   config.PORT = servicePort;
   const pad = (num) => (num > 9 ? "" : "0") + num;
@@ -12176,7 +12392,7 @@ async function run(options = {}) {
         }).then((governedPayload) => {
           req.responseGovernanceApplied = true;
           if (governedPayload && typeof governedPayload === "object" && governedPayload.error) {
-            return done(governedPayload.error, null);
+            return done(null, governedPayload);
           }
           if (req.sessionId && governedPayload?.usage) {
             sessionUsageCache.put(req.sessionId, governedPayload.usage);
@@ -12185,7 +12401,7 @@ async function run(options = {}) {
         }).catch((error) => done(error, null));
         return;
       }
-      return done(payload.error, null);
+      return done(null, payload);
     }
     done(null, payload);
   });
@@ -12215,7 +12431,7 @@ async function run(options = {}) {
   });
   await server.start();
 }
-var import_fs8, import_promises5, import_os2, import_path8, import_json5, import_node_events, import_rotating_file_stream, event;
+var import_fs8, import_promises5, import_os2, import_path8, import_json5, import_node_events, import_rotating_file_stream, event, SHUTDOWN_SIGNAL_HANDLERS_KEY, SHUTDOWN_SIGNALS;
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
@@ -12249,6 +12465,8 @@ var init_index = __esm({
     init_protocols();
     init_pipeline();
     event = new import_node_events.EventEmitter();
+    SHUTDOWN_SIGNAL_HANDLERS_KEY = Symbol.for("claude-trigger-router.shutdownSignalHandlers");
+    SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM"];
   }
 });