feat: Bump support for cursor SDK (#2742)

Author: lforst

.changeset/bump-cursor-sdk-support.md

@@ -0,0 +1,5 @@
+---
+"braintrust": minor
+---
+
+feat: Bump support for cursor SDK

dev-packages/seinfeld/src/cassette.ts

@@ -45,6 +45,13 @@ export interface RecordedRequest {
 
 /** A single recorded response, as it appeared on the wire. */
 export interface RecordedResponse {
+  /** Original wire chunk sizes and inter-chunk delays for interactive streams. */
+  streamChunks?: Array<{
+    size: number;
+    delayMs: number;
+    /** Complete Connect request frames received before this response chunk. */
+    requestFrames?: number;
+  }>;
   status: number;
   statusText?: string;
   headers: Record<string, string>;

dev-packages/seinfeld/src/format/v1.ts

@@ -29,6 +29,15 @@ const recordedRequestSchema = z.object({
 });
 
 const recordedResponseSchema = z.object({
+  streamChunks: z
+    .array(
+      z.object({
+        size: z.number().int().positive(),
+        delayMs: z.number().nonnegative(),
+        requestFrames: z.number().int().nonnegative().optional(),
+      }),
+    )
+    .optional(),
   status: z.number().int().min(100).max(599),
   statusText: z.string().optional(),
   headers: z.record(z.string()),

dev-packages/seinfeld/src/http.ts

@@ -107,16 +107,23 @@ export async function recordResponseDraft(
 /** Build a Fetch API `Response` from a recorded response body. */
 export async function buildResponse(
   recorded: RecordedResponse | RecordedResponseOrDraft,
-  ctx?: { store: CassetteStore; name: string },
+  ctx?: {
+    store: CassetteStore;
+    name: string;
+    waitForRequestFrames?: (count: number) => Promise<void>;
+  },
 ): Promise<Response> {
   // Expand \n-joined set-cookie back into multiple header entries.
   // Strip encoding headers: stored bytes are already decoded by the fetch
   // layer (undici decompresses gzip/deflate before handing the body to us).
   // Preserving content-encoding would cause callers to attempt a second
   // decode of already-plain bytes, which throws a zlib error.
   const headers = expandSetCookieHeader(stripEncodingHeaders(recorded.headers));
-  const init: ResponseInit = { status: recorded.status, headers };
-  if (recorded.statusText) init.statusText = recorded.statusText;
+  const init: ResponseInit = {
+    status: recorded.status,
+    headers,
+    ...(recorded.statusText ? { statusText: recorded.statusText } : {}),
+  };
   // 1xx/204/304 responses must not have a body, per Fetch spec.
   if (isNullBodyStatus(recorded.status)) return new Response(null, init);
 
@@ -146,6 +153,33 @@ export async function buildResponse(
       ? recorded.body.bytes
       : await decodeBody(recorded.body, ctx);
   if (bytes.length === 0) return new Response(null, init);
+  if (recorded.streamChunks) {
+    // Interactive providers wait for client messages between chunks. Frame
+    // counts preserve that ordering even if replay's client is slower than
+    // recording's client; recorded delays alone cannot enforce it.
+    const chunks = recorded.streamChunks;
+    let index = 0;
+    let offset = 0;
+    const stream = new ReadableStream({
+      async pull(controller) {
+        if (index === chunks.length) {
+          controller.close();
+          return;
+        }
+        const { size, delayMs, requestFrames } = chunks[index++]!;
+        if (requestFrames !== undefined) {
+          if (!ctx?.waitForRequestFrames) {
+            throw new Error("Connect replay requires request frame tracking");
+          }
+          await ctx.waitForRequestFrames(requestFrames);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        controller.enqueue(bytes.slice(offset, offset + size));
+        offset += size;
+      },
+    });
+    return new Response(stream, init);
+  }
   // Copy into a fresh ArrayBuffer. (TS 5.7 typed Uint8Array as
   // Uint8Array<ArrayBufferLike>, and `.buffer` may be `SharedArrayBuffer` —
   // neither satisfies the DOM lib's strict ArrayBuffer-only BodyInit.)

dev-packages/seinfeld/src/internal/connect-request.ts

@@ -0,0 +1,67 @@
+import type { IncomingMessage } from "node:http";
+
+/** Count complete Connect envelopes without retaining their payloads. */
+export function trackConnectRequest(req: IncomingMessage) {
+  const header = Buffer.alloc(5);
+  let headerSize = 0;
+  let remaining = 0;
+  let frames = 0;
+  let closed = false;
+  let notify = () => {};
+
+  const onData = (data: Buffer) => {
+    let offset = 0;
+    while (offset < data.length) {
+      if (headerSize < header.length) {
+        const size = Math.min(header.length - headerSize, data.length - offset);
+        data.copy(header, headerSize, offset, offset + size);
+        headerSize += size;
+        offset += size;
+        if (headerSize < header.length) continue;
+        remaining = header.readUInt32BE(1);
+      }
+      const size = Math.min(remaining, data.length - offset);
+      remaining -= size;
+      offset += size;
+      if (remaining === 0) {
+        frames++;
+        headerSize = 0;
+      }
+    }
+    notify();
+  };
+  const onClose = () => {
+    closed = true;
+    notify();
+  };
+  req.on("data", onData);
+  req.on("end", onClose);
+  req.on("close", onClose);
+  req.on("error", onClose);
+
+  return {
+    get frames() {
+      return frames;
+    },
+    // Response stream pulls are sequential, so there is only one waiter.
+    async waitFor(count: number) {
+      while (frames < count) {
+        if (closed) {
+          throw new Error(
+            `Connect request ended after ${frames} frames; replay requires ${count}`,
+          );
+        }
+        await new Promise<void>((resolve) => {
+          notify = resolve;
+        });
+      }
+    },
+    dispose() {
+      req.off("data", onData);
+      req.off("end", onClose);
+      req.off("close", onClose);
+      req.off("error", onClose);
+      onClose();
+    },
+  };
+}