@shpitdev/convex-cliproxy-observability 0.1.1 → 0.2.1

package/src/protocols/framing.ts

@@ -49,6 +49,74 @@ export class SSEReader {
     if (this.pending.length > this.maxBytes) throw new Error("SSE frame limit");
     return frames;
   }
+  /** Derive frames from pinned stock pre-framer callbacks; stored bytes stay untouched. */
+  feedStock(bytes: Uint8Array, protocol?: string, observedAt?: string): SSEFrame[] {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    if (protocol === "chat_completions" && (this.pending[0] ?? bytes[0]) === 123) {
+      if (this.pending.length + bytes.length > this.maxBytes) throw new Error("SSE frame limit");
+      const combined = new Uint8Array(this.pending.length + bytes.length);
+      combined.set(this.pending);
+      combined.set(bytes, this.pending.length);
+      this.pending = combined;
+      try {
+        const data = decoder.decode(combined);
+        JSON.parse(data);
+        this.pending = new Uint8Array();
+        return [{ data, observedAt }];
+      } catch {
+        return [];
+      }
+    }
+    if (protocol === "responses" && this.pending.length && bytes.length) {
+      // Only an event-only field can gain a missing separator. A data: prefix
+      // inside fragmented JSON is content, not a new line.
+      const event = new TextDecoder().decode(this.pending);
+      if (
+        /^event: *[a-zA-Z0-9][a-zA-Z0-9._:-]{0,126} *$/.test(event) &&
+        bytes[0] === 100 &&
+        bytes[1] === 97 &&
+        bytes[2] === 116 &&
+        bytes[3] === 97 &&
+        bytes[4] === 58
+      ) {
+        const line = new Uint8Array(bytes.length + 1);
+        line[0] = 10;
+        line.set(bytes, 1);
+        bytes = line;
+      }
+    }
+    const frames = this.feed(bytes, observedAt);
+    if (protocol !== "responses") return frames;
+    let candidate: string;
+    try {
+      candidate = decoder.decode(this.pending);
+    } catch {
+      return frames;
+    }
+    if (!candidate.trim()) {
+      this.pending = new Uint8Array();
+      return frames;
+    }
+    const data: string[] = [];
+    let event: string | undefined;
+    for (const line of candidate.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n")) {
+      if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
+      else if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line !== "" && !line.startsWith(":")) return frames;
+    }
+    if (!data.length) return frames;
+    const payload = data.join("\n");
+    if (payload !== "[DONE]") {
+      try {
+        JSON.parse(payload);
+      } catch {
+        return frames;
+      }
+    }
+    this.pending = new Uint8Array();
+    frames.push({ data: payload, event, observedAt });
+    return frames;
+  }
   finish(): { truncated: boolean } {
     return {
       truncated: new TextDecoder("utf-8", { fatal: true }).decode(this.pending).trim().length > 0,

package/src/protocols/index.ts

@@ -10,7 +10,7 @@ export type { SSEFrame, SSECheckpoint } from "./framing.js";
 export type { CliproxyProjection, ProjectionState } from "./types.js";
 export { assembleResponsesStream, assembleChatStream, assembleAnthropicStream };
 export { nanoTime } from "./values.js";
-export const PARSER_VERSION = "client-protocol-v1";
+export const PARSER_VERSION = "client-protocol-v2";
 export function protocolForRoute(route: string): CliproxyProjection["protocol"] {
   if (route === "POST /v1/messages" || route === "POST /v1/messages/count_tokens")
     return "anthropic_messages";
@@ -25,6 +25,8 @@ export function projectCapturedPayloads(args: {
   response?: Uint8Array;
   chunks?: readonly Uint8Array[];
   complete?: boolean;
+  /** Set only for capturePolicy hook-body-v1, never historical canonical SSE. */
+  stockHookChunks?: boolean;
 }): CliproxyProjection {
   const projection: CliproxyProjection = {
     version: 1,
@@ -68,7 +70,9 @@ export function projectCapturedPayloads(args: {
       if (bytes > 16 * 1024 * 1024)
         throw new Error("bounded replay limit; use event pages for larger calls");
       try {
-        for (const frame of reader.feed(chunk)) {
+        for (const frame of args.stockHookChunks
+          ? reader.feedStock(chunk, projection.protocol)
+          : reader.feed(chunk)) {
           if (frame.data === "[DONE]") {
             done = true;
             continue;