@vacbo/opencode-anthropic-fix 0.0.44 → 0.1.1

package/src/response/streaming.ts

@@ -4,7 +4,31 @@
 
 import { isAccountSpecificError, parseRateLimitReason } from "../backoff.js";
 import type { UsageStats } from "../types.js";
-import { stripMcpPrefixFromSSE } from "./mcp.js";
+import { stripMcpPrefixFromParsedEvent } from "./mcp.js";
+
+const MAX_UNTERMINATED_SSE_BUFFER = 256 * 1024;
+
+interface OpenContentBlockState {
+  type: string;
+  partialJson: string;
+}
+
+interface StreamTruncatedContext {
+  inFlightEvent?: string;
+  lastEventType?: string;
+  openContentBlockIndex?: number;
+  hasPartialJson?: boolean;
+}
+
+export class StreamTruncatedError extends Error {
+  readonly context: StreamTruncatedContext;
+
+  constructor(message: string, context: StreamTruncatedContext = {}) {
+    super(message);
+    this.name = "StreamTruncatedError";
+    this.context = context;
+  }
+}
 
 /**
  * Update running usage stats from a parsed SSE event.
@@ -59,6 +83,237 @@ export function getSSEDataPayload(eventBlock: string): string | null {
   return payload;
 }
 
+function getSSEEventType(eventBlock: string): string | null {
+  for (const line of eventBlock.split("\n")) {
+    if (!line.startsWith("event:")) continue;
+    const eventType = line.slice(6).trimStart();
+    if (eventType) return eventType;
+  }
+
+  return null;
+}
+
+function formatSSEEventBlock(eventType: string, parsed: unknown, prettyPrint: boolean): string {
+  const json = prettyPrint ? JSON.stringify(parsed, null, 2) : JSON.stringify(parsed);
+  const lines = [`event: ${eventType}`];
+
+  for (const line of json.split("\n")) {
+    lines.push(`data: ${line}`);
+  }
+
+  lines.push("", "");
+  return lines.join("\n");
+}
+
+function hasRecordedUsage(stats: UsageStats): boolean {
+  return stats.inputTokens > 0 || stats.outputTokens > 0 || stats.cacheReadTokens > 0 || stats.cacheWriteTokens > 0;
+}
+
+function getErrorMessage(parsed: unknown): string {
+  if (!parsed || typeof parsed !== "object") {
+    return "stream terminated with error event";
+  }
+
+  const error = (parsed as Record<string, unknown>).error;
+  if (!error || typeof error !== "object") {
+    return "stream terminated with error event";
+  }
+
+  const message = (error as Record<string, unknown>).message;
+  return typeof message === "string" && message ? message : "stream terminated with error event";
+}
+
+function getEventIndex(parsed: Record<string, unknown>, eventType: string): number {
+  const index = parsed.index;
+  if (typeof index !== "number") {
+    throw new Error(`invalid SSE ${eventType} event: missing numeric index`);
+  }
+
+  return index;
+}
+
+function getEventLabel(parsed: Record<string, unknown>, eventType: string): string {
+  switch (eventType) {
+    case "content_block_start": {
+      const contentBlock = parsed.content_block;
+      const blockType =
+        contentBlock && typeof contentBlock === "object" ? (contentBlock as Record<string, unknown>).type : undefined;
+      return typeof blockType === "string" && blockType ? `content_block_start(${blockType})` : eventType;
+    }
+
+    case "content_block_delta": {
+      const delta = parsed.delta;
+      const deltaType = delta && typeof delta === "object" ? (delta as Record<string, unknown>).type : undefined;
+      return typeof deltaType === "string" && deltaType ? `content_block_delta(${deltaType})` : eventType;
+    }
+
+    default:
+      return eventType;
+  }
+}
+
+function getOpenBlockContext(openContentBlocks: Map<number, OpenContentBlockState>): StreamTruncatedContext | null {
+  for (const [index, blockState] of openContentBlocks) {
+    if (blockState.type === "tool_use") {
+      return {
+        inFlightEvent: blockState.partialJson
+          ? "content_block_delta(input_json_delta)"
+          : "content_block_start(tool_use)",
+        openContentBlockIndex: index,
+        hasPartialJson: blockState.partialJson.length > 0,
+      };
+    }
+  }
+
+  const firstOpenBlock = openContentBlocks.entries().next().value as [number, OpenContentBlockState] | undefined;
+  if (!firstOpenBlock) {
+    return null;
+  }
+
+  const [index, blockState] = firstOpenBlock;
+  return {
+    inFlightEvent: `content_block_start(${blockState.type})`,
+    openContentBlockIndex: index,
+    hasPartialJson: blockState.partialJson.length > 0,
+  };
+}
+
+function createStreamTruncatedError(context: StreamTruncatedContext = {}): StreamTruncatedError {
+  return new StreamTruncatedError("Stream truncated without message_stop", context);
+}
+
+function getBufferedEventContext(eventBlock: string, lastEventType: string | null): StreamTruncatedContext {
+  const context: StreamTruncatedContext = {
+    lastEventType: lastEventType ?? undefined,
+  };
+
+  const payload = getSSEDataPayload(eventBlock);
+  if (!payload) {
+    return context;
+  }
+
+  try {
+    const parsed = JSON.parse(payload) as Record<string, unknown>;
+    const eventType = getSSEEventType(eventBlock) ?? (typeof parsed.type === "string" ? parsed.type : null);
+    if (eventType) {
+      context.inFlightEvent = getEventLabel(parsed, eventType);
+    }
+  } catch {
+    // JSON parse failed; context will be returned without inFlightEvent
+  }
+
+  return context;
+}
+
+function validateEventState(
+  parsed: Record<string, unknown>,
+  eventType: string,
+  openContentBlocks: Map<number, OpenContentBlockState>,
+): void {
+  switch (eventType) {
+    case "content_block_start": {
+      const index = getEventIndex(parsed, eventType);
+      const contentBlock = parsed.content_block;
+      if (!contentBlock || typeof contentBlock !== "object") {
+        throw new Error("invalid SSE content_block_start event: missing content_block");
+      }
+
+      if (openContentBlocks.has(index)) {
+        throw new Error(`duplicate content_block_start for index ${index}`);
+      }
+
+      const blockType = (contentBlock as Record<string, unknown>).type;
+      if (typeof blockType !== "string" || !blockType) {
+        throw new Error("invalid SSE content_block_start event: missing content_block.type");
+      }
+
+      openContentBlocks.set(index, {
+        type: blockType,
+        partialJson: "",
+      });
+      return;
+    }
+
+    case "content_block_delta": {
+      const index = getEventIndex(parsed, eventType);
+      const blockState = openContentBlocks.get(index);
+      if (!blockState) {
+        throw new Error(`orphan content_block_delta for index ${index}`);
+      }
+
+      const delta = parsed.delta;
+      if (!delta || typeof delta !== "object") {
+        throw new Error("invalid SSE content_block_delta event: missing delta");
+      }
+
+      const deltaType = (delta as Record<string, unknown>).type;
+      if (deltaType === "input_json_delta") {
+        if (blockState.type !== "tool_use") {
+          throw new Error(`orphan input_json_delta for non-tool_use block ${index}`);
+        }
+
+        const partialJson = (delta as Record<string, unknown>).partial_json;
+        if (typeof partialJson !== "string") {
+          throw new Error("invalid SSE content_block_delta event: missing delta.partial_json");
+        }
+
+        blockState.partialJson += partialJson;
+      }
+
+      return;
+    }
+
+    case "content_block_stop": {
+      const index = getEventIndex(parsed, eventType);
+      const blockState = openContentBlocks.get(index);
+      if (!blockState) {
+        throw new Error(`orphan content_block_stop for index ${index}`);
+      }
+
+      if (blockState.type === "tool_use" && blockState.partialJson) {
+        try {
+          JSON.parse(blockState.partialJson);
+        } catch {
+          throw new Error(`incomplete tool_use partial_json for index ${index}`);
+        }
+      }
+
+      openContentBlocks.delete(index);
+      return;
+    }
+
+    default:
+      return;
+  }
+}
+
+function getOpenBlockError(openContentBlocks: Map<number, OpenContentBlockState>): Error | null {
+  const openBlockContext = getOpenBlockContext(openContentBlocks);
+  return openBlockContext ? createStreamTruncatedError(openBlockContext) : null;
+}
+
+function getMessageStopBlockError(openContentBlocks: Map<number, OpenContentBlockState>): Error | null {
+  for (const [index, blockState] of openContentBlocks) {
+    if (blockState.partialJson) {
+      return new Error(`incomplete tool_use partial_json for index ${index}`);
+    }
+  }
+
+  return null;
+}
+
+function normalizeChunk(text: string): string {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function toStreamError(error: unknown): Error {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  return new Error(String(error));
+}
+
 /**
  * Parse one SSE event payload and return account-error details if present.
  */
@@ -102,13 +357,13 @@ export function transformResponse(
   response: Response,
   onUsage?: ((stats: UsageStats) => void) | null,
   onAccountError?: ((details: { reason: string; invalidateToken: boolean }) => void) | null,
+  onStreamError?: ((error: Error) => void) | null,
 ): Response {
-  if (!response.body) return response;
+  if (!response.body || !isEventStreamResponse(response)) return response;
 
   const reader = response.body.getReader();
-  const decoder = new TextDecoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
   const encoder = new TextEncoder();
-  const EMPTY_CHUNK = new Uint8Array();
 
   const stats: UsageStats = {
     inputTokens: 0,
@@ -117,107 +372,179 @@ export function transformResponse(
     cacheWriteTokens: 0,
   };
   let sseBuffer = "";
-  let sseRewriteBuffer = "";
   let accountErrorHandled = false;
+  let hasSeenMessageStop = false;
+  let hasSeenError = false;
+  let lastEventType: string | null = null;
+  const strictEventValidation = !onUsage && !onAccountError;
+  const openContentBlocks = new Map<number, OpenContentBlockState>();
+
+  function enqueueNormalizedEvent(controller: ReadableStreamDefaultController<Uint8Array>, eventBlock: string): void {
+    const payload = getSSEDataPayload(eventBlock);
+    if (!payload) {
+      return;
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      throw new Error("invalid SSE event: malformed JSON payload");
+    }
+
+    const eventType =
+      getSSEEventType(eventBlock) ?? ((parsed as Record<string, unknown> | null)?.type as string | undefined);
+    if (typeof eventType !== "string" || !eventType) {
+      throw new Error("invalid SSE event: missing event type");
+    }
+
+    const parsedRecord = parsed as Record<string, unknown>;
+    lastEventType = getEventLabel(parsedRecord, eventType);
+    if (strictEventValidation) {
+      validateEventState(parsedRecord, eventType, openContentBlocks);
+    }
+    stripMcpPrefixFromParsedEvent(parsedRecord);
+
+    if (onUsage) {
+      extractUsageFromSSEEvent(parsedRecord, stats);
+    }
+
+    if (onAccountError && !accountErrorHandled) {
+      const details = getMidStreamAccountError(parsedRecord);
+      if (details) {
+        accountErrorHandled = true;
+        onAccountError(details);
+      }
+    }
+
+    if (eventType === "message_stop") {
+      if (strictEventValidation) {
+        const openBlockError = getMessageStopBlockError(openContentBlocks);
+        if (openBlockError) {
+          throw openBlockError;
+        }
+
+        openContentBlocks.clear();
+      }
+
+      hasSeenMessageStop = true;
+    }
+
+    if (eventType === "error") {
+      hasSeenError = true;
+    }
+
+    controller.enqueue(encoder.encode(formatSSEEventBlock(eventType, parsedRecord, strictEventValidation)));
+
+    if (eventType === "error" && strictEventValidation) {
+      throw new Error(getErrorMessage(parsedRecord));
+    }
+  }
+
+  function processBufferedEvents(controller: ReadableStreamDefaultController<Uint8Array>): boolean {
+    let emitted = false;
 
-  function processSSEBuffer(flush = false): void {
     while (true) {
       const boundary = sseBuffer.indexOf("\n\n");
-
       if (boundary === -1) {
-        if (!flush) return;
-        if (!sseBuffer.trim()) {
-          sseBuffer = "";
-          return;
+        if (sseBuffer.length > MAX_UNTERMINATED_SSE_BUFFER) {
+          throw new Error("unterminated SSE event buffer exceeded limit");
         }
+        return emitted;
       }
 
-      const eventBlock = boundary === -1 ? sseBuffer : sseBuffer.slice(0, boundary);
-      sseBuffer = boundary === -1 ? "" : sseBuffer.slice(boundary + 2);
+      const eventBlock = sseBuffer.slice(0, boundary);
+      sseBuffer = sseBuffer.slice(boundary + 2);
 
-      const payload = getSSEDataPayload(eventBlock);
-      if (!payload) {
-        if (boundary === -1) return;
+      if (!eventBlock.trim()) {
         continue;
       }
 
-      try {
-        const parsed = JSON.parse(payload);
+      enqueueNormalizedEvent(controller, eventBlock);
+      emitted = true;
+    }
+  }
 
-        if (onUsage) {
-          extractUsageFromSSEEvent(parsed, stats);
-        }
+  async function failStream(controller: ReadableStreamDefaultController<Uint8Array>, error: unknown): Promise<void> {
+    const streamError = toStreamError(error);
 
-        if (onAccountError && !accountErrorHandled) {
-          const details = getMidStreamAccountError(parsed);
-          if (details) {
-            accountErrorHandled = true;
-            onAccountError(details);
-          }
-        }
+    if (onStreamError) {
+      try {
+        onStreamError(streamError);
       } catch {
-        // Ignore malformed event payloads.
+        // Error handler failed; continue with cleanup
       }
-
-      if (boundary === -1) return;
     }
-  }
-
-  function rewriteSSEChunk(chunk: string, flush = false): string {
-    sseRewriteBuffer += chunk;
 
-    if (!flush) {
-      const boundary = sseRewriteBuffer.lastIndexOf("\n");
-      if (boundary === -1) return "";
-      const complete = sseRewriteBuffer.slice(0, boundary + 1);
-      sseRewriteBuffer = sseRewriteBuffer.slice(boundary + 1);
-      return stripMcpPrefixFromSSE(complete);
+    try {
+      await reader.cancel(streamError);
+    } catch {
+      // Reader cancel failed; stream may already be closed
     }
 
-    if (!sseRewriteBuffer) return "";
-    const finalText = stripMcpPrefixFromSSE(sseRewriteBuffer);
-    sseRewriteBuffer = "";
-    return finalText;
+    controller.error(streamError);
   }
 
   const stream = new ReadableStream({
     async pull(controller) {
-      const { done, value } = await reader.read();
-      if (done) {
-        processSSEBuffer(true);
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            const flushedText = decoder.decode();
+            if (flushedText) {
+              sseBuffer += normalizeChunk(flushedText);
+              processBufferedEvents(controller);
+            }
+
+            if (sseBuffer.trim()) {
+              if (strictEventValidation) {
+                throw createStreamTruncatedError(getBufferedEventContext(sseBuffer, lastEventType));
+              }
+
+              enqueueNormalizedEvent(controller, sseBuffer);
+              sseBuffer = "";
+            }
+
+            if (strictEventValidation) {
+              const openBlockError = getOpenBlockError(openContentBlocks);
+              if (openBlockError) {
+                throw openBlockError;
+              }
+
+              if (!hasSeenMessageStop && !hasSeenError) {
+                throw createStreamTruncatedError({
+                  inFlightEvent: lastEventType ?? undefined,
+                  lastEventType: lastEventType ?? undefined,
+                });
+              }
+            }
+
+            if (onUsage && hasRecordedUsage(stats)) {
+              onUsage(stats);
+            }
+
+            controller.close();
+            return;
+          }
 
-        const rewrittenTail = rewriteSSEChunk("", true);
-        if (rewrittenTail) {
-          controller.enqueue(encoder.encode(rewrittenTail));
-        }
+          const text = decoder.decode(value, { stream: true });
+          if (!text) {
+            continue;
+          }
 
-        if (
-          onUsage &&
-          (stats.inputTokens > 0 || stats.outputTokens > 0 || stats.cacheReadTokens > 0 || stats.cacheWriteTokens > 0)
-        ) {
-          onUsage(stats);
+          sseBuffer += normalizeChunk(text);
+          if (processBufferedEvents(controller)) {
+            return;
+          }
         }
-        controller.close();
-        return;
-      }
-
-      const text = decoder.decode(value, { stream: true });
-
-      if (onUsage || onAccountError) {
-        // Normalize CRLF for parser only; preserve original bytes for passthrough.
-        sseBuffer += text.replace(/\r\n/g, "\n");
-        processSSEBuffer(false);
-      }
-
-      const rewrittenText = rewriteSSEChunk(text, false);
-      if (rewrittenText) {
-        controller.enqueue(encoder.encode(rewrittenText));
-      } else {
-        // Keep the pull/read loop progressing when this chunk only extends a
-        // partial line buffered for later rewrite.
-        controller.enqueue(EMPTY_CHUNK);
+      } catch (error) {
+        await failStream(controller, error);
       }
     },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
   });
 
   return new Response(stream, {