chore: import upstream snapshot with attribution

apps/sim/lib/copilot/request/go/parser.ts

@@ -0,0 +1,129 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+
+const logger = createLogger('CopilotSseParser')
+
+export class FatalSseEventError extends Error {}
+
+function createParseFailure(message: string, preview: string): FatalSseEventError {
+  logger.error(message, { preview })
+  return new FatalSseEventError(message)
+}
+
+function normalizeSseLine(line: string): string {
+  return line.endsWith('\r') ? line.slice(0, -1) : line
+}
+
+/**
+ * Processes an SSE stream by calling onEvent for each parsed event.
+ *
+ * @param onEvent Called per parsed event. Return true to stop processing.
+ */
+export async function processSSEStream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  decoder: TextDecoder,
+  abortSignal: AbortSignal | undefined,
+  onEvent: (event: unknown) => boolean | undefined | Promise<boolean | undefined>
+): Promise<void> {
+  let buffer = ''
+
+  try {
+    try {
+      while (true) {
+        if (abortSignal?.aborted) {
+          logger.info('SSE stream aborted by signal')
+          break
+        }
+
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        let stopped = false
+        for (const line of lines) {
+          const normalizedLine = normalizeSseLine(line)
+          if (abortSignal?.aborted) {
+            logger.info('SSE stream aborted mid-chunk (between events)')
+            return
+          }
+          if (!normalizedLine.trim()) continue
+          if (!normalizedLine.startsWith('data: ')) continue
+
+          const jsonStr = normalizedLine.slice(6)
+          if (jsonStr === '[DONE]') continue
+
+          let parsed: unknown
+          try {
+            parsed = JSON.parse(jsonStr)
+          } catch (error) {
+            const preview = jsonStr.slice(0, 200)
+            const detail = toError(error).message
+            throw createParseFailure(`Failed to parse SSE event JSON: ${detail}`, preview)
+          }
+
+          try {
+            if (await onEvent(parsed)) {
+              stopped = true
+              break
+            }
+          } catch (error) {
+            if (error instanceof FatalSseEventError) {
+              throw error
+            }
+            logger.warn('Failed to handle SSE event', {
+              preview: jsonStr.slice(0, 200),
+              error: toError(error).message,
+            })
+          }
+        }
+        if (stopped) break
+      }
+    } catch (error) {
+      const aborted =
+        abortSignal?.aborted || (error instanceof DOMException && error.name === 'AbortError')
+      if (aborted) {
+        logger.info('SSE stream read aborted')
+        return
+      }
+      throw error
+    }
+
+    const normalizedBuffer = normalizeSseLine(buffer)
+    if (normalizedBuffer.trim() && normalizedBuffer.startsWith('data: ')) {
+      const jsonStr = normalizedBuffer.slice(6)
+      if (jsonStr === '[DONE]') {
+        return
+      }
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(jsonStr)
+      } catch (error) {
+        const preview = normalizedBuffer.slice(0, 200)
+        const detail = toError(error).message
+        throw createParseFailure(`Failed to parse final SSE buffer JSON: ${detail}`, preview)
+      }
+
+      try {
+        await onEvent(parsed)
+      } catch (error) {
+        if (error instanceof FatalSseEventError) {
+          throw error
+        }
+        logger.warn('Failed to handle final SSE event', {
+          preview: normalizedBuffer.slice(0, 200),
+          error: toError(error).message,
+        })
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock()
+    } catch {
+      logger.warn('Failed to release SSE reader lock')
+    }
+  }
+}