@peterwangze/claude-trigger-router 1.10.0 → 1.11.0

package/dist/cli.js

@@ -4298,6 +4298,7 @@ var init_SSEParser_transform = __esm({
     "use strict";
     SSEParserTransform = class {
       buffer = "";
+      currentEvent = {};
       constructor() {
         const transformStream = new TransformStream({
           start: (controller) => {
@@ -4309,7 +4310,9 @@ var init_SSEParser_transform = __esm({
           },
           flush: (controller) => {
             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 +4321,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 +4363,102 @@ function serializeEvent(event2) {
   output3 += "\n";
   return new TextEncoder().encode(output3);
 }
+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}`);
+  }
+  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 = "";
+  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);
+        }
+      }
+      finalizeStreamingTrace(req, observation);
+    }
+  }));
+}
 async function collectSSE(stream) {
   const parser = new SSEParserTransform();
   const parsedStream = stream.pipeThrough(parser);
@@ -4395,6 +4498,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 +11661,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);
@@ -11722,8 +11850,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 +12303,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 +12312,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 +12342,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 +12376,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"];
   }
 });