revert and fix tests

Author: RulaKhaled

packages/cloudflare/src/request.ts

@@ -117,7 +117,7 @@ export function wrapRequestHandler(
           }
 
           // Classify response to detect actual streaming
-          const classification = await classifyResponseStreaming(res);
+          const classification = classifyResponseStreaming(res);
 
           if (classification.isStreaming && classification.response.body) {
             // Streaming response detected - monitor consumption to keep span alive

packages/cloudflare/src/utils/streaming.ts

@@ -6,81 +6,37 @@ export type StreamingGuess = {
 /**
  * Classifies a Response as streaming or non-streaming.
  *
- * Uses multiple heuristics:
+ * Heuristics:
  * - No body → not streaming
- * - Content-Type: text/event-stream → streaming
- * - Content-Length header present → not streaming
- * - Otherwise: attempts immediate read with timeout to detect behavior
- *   - Timeout (no data ready) → not streaming (typical SSR/buffered response)
- *   - Stream empty (done) → not streaming
- *   - Got data without Content-Length → streaming (e.g., Vercel AI SDK)
- *   - Got data with Content-Length → not streaming
+ * - Known streaming Content-Types → streaming (SSE, NDJSON, JSON streaming)
+ * - text/plain without Content-Length → streaming (some AI APIs)
+ * - Otherwise → not streaming (conservative default, including HTML/SSR)
  *
- * The timeout prevents blocking on responses that are being generated (like SSR),
- * while still detecting true streaming responses that produce data immediately.
- *
- * Note: Probing will tee() the stream and return a new Response object.
- *
- * @param res - The Response to classify
- * @returns Classification result with safe-to-return Response
+ * We avoid probing the stream to prevent blocking on transform streams (like injectTraceMetaTags)
+ * or SSR streams that may not have data ready immediately.
  */
-export async function classifyResponseStreaming(res: Response): Promise<StreamingGuess> {
+export function classifyResponseStreaming(res: Response): StreamingGuess {
   if (!res.body) {
     return { response: res, isStreaming: false };
   }
 
   const contentType = res.headers.get('content-type') ?? '';
   const contentLength = res.headers.get('content-length');
 
-  // Fast path: Server-Sent Events
-  if (/^text\/event-stream\b/i.test(contentType)) {
+  // Streaming: Known streaming content types
+  // - text/event-stream: Server-Sent Events (Vercel AI SDK, real-time APIs)
+  // - application/x-ndjson, application/ndjson: Newline-delimited JSON
+  // - application/stream+json: JSON streaming
+  // - text/plain (without Content-Length): Some AI APIs use this for streaming text
+  if (
+    /^text\/event-stream\b/i.test(contentType) ||
+    /^application\/(x-)?ndjson\b/i.test(contentType) ||
+    /^application\/stream\+json\b/i.test(contentType) ||
+    (/^text\/plain\b/i.test(contentType) && !contentLength)
+  ) {
     return { response: res, isStreaming: true };
   }
 
-  // Fast path: Content-Length indicates buffered response
-  if (contentLength && /^\d+$/.test(contentLength)) {
-    return { response: res, isStreaming: false };
-  }
-
-  // Probe the stream by trying to read first chunk immediately with a timeout
-  // After tee(), must use the teed stream (original is locked)
-  const [probeStream, passStream] = res.body.tee();
-  const reader = probeStream.getReader();
-
-  try {
-    // Use a short timeout to avoid blocking on responses that aren't immediately ready
-    // Streaming responses (like Vercel AI) typically start producing data right away
-    // Buffered responses (like Remix SSR) will block until content is generated
-    const PROBE_TIMEOUT_MS = 10;
-
-    const timeoutPromise = new Promise<{ done: boolean; value?: unknown; timedOut: true }>(resolve => {
-      setTimeout(() => resolve({ done: false, value: undefined, timedOut: true }), PROBE_TIMEOUT_MS);
-    });
-
-    const readPromise = reader.read().then(result => ({ ...result, timedOut: false as const }));
-    const result = await Promise.race([readPromise, timeoutPromise]);
-
-    reader.releaseLock();
-
-    const teededResponse = new Response(passStream, res);
-
-    if (result.timedOut) {
-      // Timeout means data isn't immediately available - likely a buffered response
-      // being generated (like SSR). Treat as non-streaming.
-      return { response: teededResponse, isStreaming: false };
-    }
-
-    if (result.done) {
-      // Stream completed immediately - buffered (empty body)
-      return { response: teededResponse, isStreaming: false };
-    }
-
-    // Got data immediately without Content-Length - likely streaming
-    // Got data immediately with Content-Length - buffered
-    return { response: teededResponse, isStreaming: contentLength == null };
-  } catch {
-    reader.releaseLock();
-    // Error reading - treat as non-streaming to be safe
-    return { response: new Response(passStream, res), isStreaming: false };
-  }
+  // Default: treat as non-streaming
+  return { response: res, isStreaming: false };
 }