ethagent 3.3.4 → 4.0.0

package/src/providers/openai-responses.ts

@@ -1,306 +0,0 @@
-import type { ProviderId } from '../storage/config.js'
-import type { Message, Provider, ProviderCompleteOptions, StreamEvent } from './contracts.js'
-import { ProviderError } from './contracts.js'
-import { providerErrorFromResponse } from './errors.js'
-import { fetchWithRetryStreamEvents } from './retry.js'
-import { iterSseEvents } from './sse.js'
-import { buildResponsesBody } from './openai-responses-format.js'
-import { supportsOpenAIImages, type OpenAIToolDefinition } from './openai-chat.js'
-import { hasImageBlocks, ImageLoadError } from '../utils/images.js'
-
-const READ_TIMEOUT_MS = 45_000
-
-type DoneStopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'unknown'
-
-export type OpenAIResponsesProviderOptions = {
-  model: string
-  baseUrl: string
-  accessToken: string
-  accountId?: string
-  originator?: string
-  tools?: OpenAIToolDefinition[]
-  maxRetries?: number
-  refresh?: () => Promise<string>
-}
-
-type StreamingToolCall = {
-  callId: string
-  name: string
-  inputJson: string
-  started: boolean
-}
-
-export class OpenAIResponsesProvider implements Provider {
-  readonly id: ProviderId = 'openai'
-  readonly model: string
-  readonly supportsTools: boolean
-  private accessToken: string
-  private readonly baseUrl: string
-  private readonly accountId?: string
-  private readonly originator: string
-  private readonly tools: OpenAIToolDefinition[]
-  private readonly maxRetries?: number
-  private readonly refresh?: () => Promise<string>
-
-  constructor(opts: OpenAIResponsesProviderOptions) {
-    this.model = opts.model
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, '')
-    this.accessToken = opts.accessToken
-    this.accountId = opts.accountId
-    this.originator = opts.originator ?? 'codex_cli_rs'
-    this.tools = opts.tools ?? []
-    this.maxRetries = opts.maxRetries
-    this.refresh = opts.refresh
-    this.supportsTools = this.tools.length > 0
-  }
-
-  async *complete(
-    messages: Message[],
-    signal: AbortSignal,
-    options: ProviderCompleteOptions = {},
-  ): AsyncIterable<StreamEvent> {
-    if (!this.accessToken) {
-      const error = new ProviderError('missing OAuth access token for openai (sign in again via the model picker)')
-      yield { type: 'error', message: error.message }
-      return
-    }
-
-    if (hasImageBlocks(messages) && !supportsOpenAIImages(this.model)) {
-      yield { type: 'error', message: `image input is not enabled for ${this.model}` }
-      return
-    }
-
-    let attempt = 0
-    while (true) {
-      attempt += 1
-      let body: string
-      try {
-        body = JSON.stringify(await buildResponsesBody({
-          model: this.model,
-          messages,
-          tools: this.tools,
-          maxOutputTokens: options.maxTokens,
-        }))
-      } catch (err: unknown) {
-        if (err instanceof ImageLoadError) {
-          yield { type: 'error', message: err.message }
-          return
-        }
-        throw err
-      }
-
-      let response: Response
-      try {
-        response = yield* fetchWithRetryStreamEvents(`${this.baseUrl}/responses`, {
-          method: 'POST',
-          headers: this.requestHeaders(),
-          body,
-        }, { signal, maxRetries: this.maxRetries, rateLimitResetProvider: 'openai-compatible' })
-      } catch (err: unknown) {
-        if (signal.aborted) return
-        yield { type: 'error', message: networkErrorMessage(this.baseUrl, err) }
-        return
-      }
-
-      if (response.status === 401 && this.refresh && attempt === 1) {
-        try {
-          this.accessToken = await this.refresh()
-          continue
-        } catch (refreshErr) {
-          const message = refreshErr instanceof Error ? refreshErr.message : String(refreshErr)
-          yield { type: 'error', message: `OpenAI sign-in expired and refresh failed: ${message}` }
-          return
-        }
-      }
-
-      if (!response.ok) {
-        const error = await providerErrorFromResponse('openai', response)
-        yield { type: 'error', message: error.message }
-        return
-      }
-      if (!response.body) {
-        yield { type: 'error', message: 'empty response body' }
-        return
-      }
-
-      yield* this.parseStream(response.body, signal)
-      return
-    }
-  }
-
-  private requestHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      Accept: 'text/event-stream',
-      Authorization: `Bearer ${this.accessToken}`,
-      originator: this.originator,
-    }
-    if (this.accountId) headers['chatgpt-account-id'] = this.accountId
-    return headers
-  }
-
-  private async *parseStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): AsyncIterable<StreamEvent> {
-    const toolCalls = new Map<string, StreamingToolCall>()
-    let inputTokens: number | undefined
-    let outputTokens: number | undefined
-    let stopReason: DoneStopReason = 'unknown'
-
-    try {
-      for await (const frame of iterSseEvents(body, signal, READ_TIMEOUT_MS)) {
-        const eventName = frame.event ?? ''
-        if (!frame.data || frame.data === '[DONE]') continue
-        let parsed: Record<string, unknown>
-        try {
-          parsed = JSON.parse(frame.data) as Record<string, unknown>
-        } catch {
-          continue
-        }
-
-        switch (eventName) {
-          case 'response.output_text.delta': {
-            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
-            if (delta) yield { type: 'text', delta }
-            break
-          }
-          case 'response.reasoning_summary_text.delta':
-          case 'response.reasoning.delta':
-          case 'response.reasoning_text.delta': {
-            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
-            if (delta) yield { type: 'thinking', delta }
-            break
-          }
-          case 'response.output_item.added': {
-            const item = (parsed.item ?? {}) as Record<string, unknown>
-            if (item.type === 'function_call') {
-              const callId = pickString(item.call_id) ?? pickString(item.id) ?? `tool-${toolCalls.size}`
-              const name = pickString(item.name) ?? ''
-              toolCalls.set(callId, { callId, name, inputJson: '', started: false })
-              if (name) {
-                toolCalls.get(callId)!.started = true
-                yield { type: 'tool_use_start', id: callId, name }
-              }
-            }
-            break
-          }
-          case 'response.function_call_arguments.delta': {
-            const callId = resolveCallId(parsed, toolCalls)
-            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
-            if (!callId || !delta) break
-            const existing = toolCalls.get(callId)
-            if (!existing) break
-            existing.inputJson += delta
-            yield { type: 'tool_use_delta', id: callId, delta }
-            break
-          }
-          case 'response.output_item.done': {
-            const item = (parsed.item ?? {}) as Record<string, unknown>
-            if (item.type === 'function_call') {
-              const callId = pickString(item.call_id) ?? pickString(item.id)
-              if (!callId) break
-              const existing = toolCalls.get(callId)
-              const name = pickString(item.name) ?? existing?.name ?? ''
-              const argsJson = pickString(item.arguments) ?? existing?.inputJson ?? ''
-              stopReason = 'tool_use'
-              yield {
-                type: 'tool_use_stop',
-                id: callId,
-                name,
-                input: parseToolArguments(argsJson),
-              }
-              toolCalls.delete(callId)
-            }
-            break
-          }
-          case 'response.completed': {
-            const usage = (parsed.response as { usage?: Record<string, unknown> } | undefined)?.usage
-            const tokens = readUsage(usage)
-            if (tokens.input !== undefined) inputTokens = tokens.input
-            if (tokens.output !== undefined) outputTokens = tokens.output
-            if (stopReason !== 'tool_use') stopReason = 'end_turn'
-            break
-          }
-          case 'response.failed':
-          case 'response.error':
-          case 'error': {
-            const error = parsed.error as { message?: string } | undefined
-            const message = error?.message ?? 'Responses API error'
-            yield { type: 'error', message }
-            return
-          }
-          case 'response.incomplete': {
-            const reason = pickString((parsed.response as { incomplete_details?: { reason?: string } } | undefined)?.incomplete_details?.reason)
-            if (reason === 'max_output_tokens') stopReason = 'max_tokens'
-            break
-          }
-          default:
-            break
-        }
-      }
-    } catch (err: unknown) {
-      if (signal.aborted) return
-      yield { type: 'error', message: networkErrorMessage(this.baseUrl, err, 'stream error') }
-      return
-    }
-
-    if (signal.aborted) return
-    yield { type: 'done', inputTokens, outputTokens, stopReason }
-  }
-}
-
-function pickString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.length > 0 ? value : undefined
-}
-
-function resolveCallId(parsed: Record<string, unknown>, calls: Map<string, StreamingToolCall>): string | undefined {
-  return (
-    pickString(parsed.call_id)
-    ?? pickString(parsed.item_id)
-    ?? pickString((parsed.item as Record<string, unknown> | undefined)?.call_id)
-    ?? pickString((parsed.item as Record<string, unknown> | undefined)?.id)
-    ?? (calls.size === 1 ? Array.from(calls.keys())[0] : undefined)
-  )
-}
-
-function readUsage(usage: Record<string, unknown> | undefined): { input?: number; output?: number } {
-  if (!usage) return {}
-  const input = typeof usage.input_tokens === 'number'
-    ? usage.input_tokens
-    : typeof usage.prompt_tokens === 'number' ? usage.prompt_tokens : undefined
-  const output = typeof usage.output_tokens === 'number'
-    ? usage.output_tokens
-    : typeof usage.completion_tokens === 'number' ? usage.completion_tokens : undefined
-  return { input, output }
-}
-
-function parseToolArguments(input: string): Record<string, unknown> {
-  const trimmed = input.trim()
-  if (!trimmed) return {}
-  try {
-    return coerceToToolArguments(JSON.parse(trimmed))
-  } catch {
-    return {}
-  }
-}
-
-function coerceToToolArguments(value: unknown): Record<string, unknown> {
-  if (typeof value === 'string') {
-    const trimmed = value.trim()
-    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-      try {
-        return coerceToToolArguments(JSON.parse(trimmed))
-      } catch {
-        return {}
-      }
-    }
-    return {}
-  }
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    return value as Record<string, unknown>
-  }
-  return {}
-}
-
-function networkErrorMessage(baseUrl: string, err: unknown, fallback = 'network error'): string {
-  const message = (err as Error).message || fallback
-  return `openai request failed at ${baseUrl}: ${message}`
-}

package/src/providers/openaiChatWire.ts

@@ -1,124 +0,0 @@
-import type { Message, MessageContentBlock } from './contracts.js'
-import { messageTextContent } from '../utils/messages.js'
-import { loadImageBlock } from '../utils/images.js'
-
-export async function toWireMessages(messages: Message[]): Promise<Array<Record<string, unknown>>> {
-  const out: Array<Record<string, unknown>> = []
-
-  for (const message of messages) {
-    if (typeof message.content === 'string') {
-      out.push({ role: message.role, content: message.content })
-      continue
-    }
-
-    if (message.role === 'user') {
-      const toolResults = message.content.filter(isToolResultBlock)
-      if (toolResults.length > 0) {
-        for (const block of toolResults) {
-          out.push({
-            role: 'tool',
-            tool_call_id: block.toolUseId,
-            content: block.content,
-          })
-        }
-        const nonToolBlocks = message.content.filter(block => block.type !== 'tool_result')
-        if (nonToolBlocks.length > 0) {
-          out.push({ role: 'user', content: await toOpenAIUserContent(nonToolBlocks) })
-        }
-        continue
-      }
-      out.push({ role: 'user', content: await toOpenAIUserContent(message.content) })
-      continue
-    }
-
-    if (message.role === 'assistant') {
-      const textParts = message.content.filter(isTextBlock).map(block => block.text)
-      const toolCalls = message.content.filter(isToolUseBlock).map(block => ({
-        id: block.id,
-        type: 'function',
-        function: {
-          name: block.name,
-          arguments: JSON.stringify(block.input),
-        },
-      }))
-      out.push({
-        role: 'assistant',
-        content: textParts.join(''),
-        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-      })
-      continue
-    }
-
-    const toolResults = message.content.filter(isToolResultBlock)
-    if (toolResults.length > 0) {
-      for (const block of toolResults) {
-        out.push({
-          role: 'tool',
-          tool_call_id: block.toolUseId,
-          content: block.content,
-        })
-      }
-      continue
-    }
-
-    out.push({ role: message.role, content: messageTextContent(message) })
-  }
-
-  return normalizeSystemMessages(out)
-}
-
-async function toOpenAIUserContent(blocks: MessageContentBlock[]): Promise<Array<Record<string, unknown>>> {
-  const parts: Array<Record<string, unknown>> = []
-  for (const block of blocks) {
-    if (block.type === 'text') {
-      if (block.text.length > 0) parts.push({ type: 'text', text: block.text })
-      continue
-    }
-    if (block.type === 'image') {
-      const loaded = await loadImageBlock(block)
-      if (loaded.url) {
-        parts.push({ type: 'image_url', image_url: { url: loaded.url } })
-      } else if (loaded.dataBase64 && loaded.mimeType) {
-        parts.push({ type: 'image_url', image_url: { url: `data:${loaded.mimeType};base64,${loaded.dataBase64}` } })
-      }
-      continue
-    }
-  }
-  return parts.length > 0 ? parts : [{ type: 'text', text: '' }]
-}
-
-function normalizeSystemMessages(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
-  const systemContents: string[] = []
-  const nonSystem: Array<Record<string, unknown>> = []
-
-  for (const message of messages) {
-    if (message.role === 'system') {
-      if (typeof message.content === 'string' && message.content.length > 0) {
-        systemContents.push(message.content)
-      }
-      continue
-    }
-    nonSystem.push(message)
-  }
-
-  if (systemContents.length === 0) return nonSystem
-  return [
-    {
-      role: 'system',
-      content: systemContents.join('\n\n'),
-    },
-    ...nonSystem,
-  ]
-}
-
-function isTextBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'text' }> {
-  return block.type === 'text'
-}
-
-function isToolUseBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_use' }> {
-  return block.type === 'tool_use'
-}
-
-function isToolResultBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_result' }> {
-  return block.type === 'tool_result'
-}

package/src/providers/registry.ts

@@ -1,120 +0,0 @@
-import type { EthagentConfig } from '../storage/config.js'
-import { localProviderBaseUrlFor } from '../storage/config.js'
-import { getKey } from '../storage/secrets.js'
-import type { Provider } from './contracts.js'
-import type { SessionMode } from '../runtime/sessionMode.js'
-import { AnthropicProvider } from './anthropic.js'
-import { GeminiProvider } from './gemini.js'
-import { OpenAIChatProvider } from './openai-chat.js'
-import { OpenAIResponsesProvider } from './openai-responses.js'
-import { anthropicTools, geminiTools, openAITools } from '../tools/registry.js'
-import { openAIBaseUrlFor, OPENAI_OAUTH_DEFAULT_MODEL, isOpenAIOAuthAllowedModel } from '../models/catalog.js'
-import {
-  getOpenAIOAuthCredentials,
-  setOpenAIOAuthCredentials,
-  type OpenAIOAuthCredentials,
-} from '../auth/openaiOAuth/credentials.js'
-import { refreshOpenAIAccessToken, shouldRefresh } from '../auth/openaiOAuth/refresh.js'
-import type { Tool } from '../tools/contracts.js'
-
-export const OPENAI_CHATGPT_BACKEND_URL = 'https://chatgpt.com/backend-api/codex'
-
-export function isLocalProvider(provider: string): boolean {
-  return provider === 'llamacpp'
-}
-
-export function createProvider(config: EthagentConfig, options: { mode?: SessionMode; dynamicTools?: Tool[] } = {}): Provider {
-  const mode = options.mode ?? 'chat'
-  const toolContext = { hasIdentity: Boolean(config.identity), dynamicTools: options.dynamicTools }
-  switch (config.provider) {
-    case 'llamacpp':
-      return new OpenAIChatProvider({
-        id: 'llamacpp',
-        model: config.model,
-        baseUrl: localProviderBaseUrlFor('llamacpp', config.baseUrl),
-        apiKey: 'llamacpp',
-        tools: openAITools(mode, toolContext),
-        hasVisionProjector: Boolean(config.localMmprojPath),
-      })
-    case 'openai':
-      return createOpenAIProvider(config, openAITools(mode, toolContext))
-    case 'anthropic':
-      return new AnthropicProvider({ model: config.model, tools: anthropicTools(mode, toolContext) })
-    case 'gemini':
-      return new GeminiProvider({ model: config.model, tools: geminiTools(mode, toolContext) })
-  }
-}
-
-function createOpenAIProvider(config: EthagentConfig, tools: ReturnType<typeof openAITools>): Provider {
-  return new OpenAIRoutingProvider(config, tools)
-}
-
-class OpenAIRoutingProvider implements Provider {
-  readonly id = 'openai' as const
-  readonly model: string
-  readonly supportsTools: boolean
-  private delegate: Provider | null = null
-  private readonly config: EthagentConfig
-  private readonly tools: ReturnType<typeof openAITools>
-
-  constructor(config: EthagentConfig, tools: ReturnType<typeof openAITools>) {
-    this.config = config
-    this.tools = tools
-    this.model = config.model
-    this.supportsTools = tools.length > 0
-  }
-
-  async *complete(...args: Parameters<Provider['complete']>): ReturnType<Provider['complete']> {
-    if (!this.delegate) this.delegate = await this.resolveDelegate()
-    yield* this.delegate.complete(...args)
-  }
-
-  private async resolveDelegate(): Promise<Provider> {
-    const oauth = await loadFreshOAuthCredentials()
-    if (oauth) {
-      const oauthModel = isOpenAIOAuthAllowedModel(this.model) ? this.model : OPENAI_OAUTH_DEFAULT_MODEL
-      return new OpenAIResponsesProvider({
-        model: oauthModel,
-        baseUrl: OPENAI_CHATGPT_BACKEND_URL,
-        accessToken: oauth.accessToken,
-        accountId: oauth.accountId,
-        tools: this.tools,
-        refresh: async () => {
-          const next = await loadFreshOAuthCredentials({ force: true })
-          if (!next) throw new Error('No OAuth credentials available')
-          return next.accessToken
-        },
-      })
-    }
-    return new OpenAIChatProvider({
-      id: 'openai',
-      model: this.model,
-      baseUrl: openAIBaseUrlFor(this.config),
-      loadApiKey: () => getKey('openai'),
-      tools: this.tools,
-    })
-  }
-}
-
-async function loadFreshOAuthCredentials(options: { force?: boolean } = {}): Promise<OpenAIOAuthCredentials | null> {
-  const current = await getOpenAIOAuthCredentials()
-  if (!current) return null
-  if (!options.force && !shouldRefresh(current)) return current
-
-  try {
-    const refreshed = await refreshOpenAIAccessToken(current.refreshToken)
-    const now = Date.now()
-    const next: OpenAIOAuthCredentials = {
-      accessToken: refreshed.accessToken,
-      refreshToken: refreshed.refreshToken,
-      idToken: refreshed.idToken ?? current.idToken,
-      accountId: refreshed.accountId ?? current.accountId,
-      expiresAt: now + refreshed.expiresIn * 1000,
-      lastRefreshAt: now,
-    }
-    await setOpenAIOAuthCredentials(next)
-    return next
-  } catch {
-    return current
-  }
-}

package/src/providers/retry.ts

@@ -1,58 +0,0 @@
-import type { ProviderRetryStreamEvent } from './contracts.js'
-import { fetchWithRetry, type FetchWithRetryOptions, type RetryEvent } from '../utils/withRetry.js'
-
-type FetchSettled =
-  | { state: 'resolved'; response: Response }
-  | { state: 'rejected'; error: unknown }
-
-export async function* fetchWithRetryStreamEvents(
-  input: string,
-  init: RequestInit,
-  options: FetchWithRetryOptions = {},
-): AsyncGenerator<ProviderRetryStreamEvent, Response, void> {
-  const retryEvents: ProviderRetryStreamEvent[] = []
-  let settled: FetchSettled | undefined
-  let wake: (() => void) | undefined
-
-  const wakeWaiter = () => {
-    const current = wake
-    wake = undefined
-    current?.()
-  }
-
-  const waitForChange = (): Promise<void> => new Promise(resolve => {
-    wake = resolve
-    if (settled || retryEvents.length > 0) wakeWaiter()
-  })
-
-  const fetchPromise = fetchWithRetry(input, init, {
-    ...options,
-    onRetry: (event: RetryEvent) => {
-      options.onRetry?.(event)
-      retryEvents.push({ type: 'retry', ...event })
-      wakeWaiter()
-    },
-  }).then(
-    response => {
-      settled = { state: 'resolved', response }
-      wakeWaiter()
-    },
-    error => {
-      settled = { state: 'rejected', error }
-      wakeWaiter()
-    },
-  )
-
-  while (!settled || retryEvents.length > 0) {
-    while (retryEvents.length > 0) {
-      yield retryEvents.shift()!
-    }
-    if (settled) break
-    await waitForChange()
-  }
-
-  await fetchPromise
-  if (settled?.state === 'resolved') return settled.response
-  if (settled?.state === 'rejected') throw settled.error
-  throw new Error('Fetch retry completed without a response')
-}

package/src/providers/sse.ts

@@ -1,93 +0,0 @@
-export type SseEvent = {
-  event: string | null
-  data: string
-}
-
-export async function* iterSseFrames(
-  body: ReadableStream<Uint8Array>,
-  signal: AbortSignal,
-  readTimeoutMs: number,
-): AsyncIterable<string> {
-  for await (const event of iterSseEvents(body, signal, readTimeoutMs)) {
-    yield event.data
-  }
-}
-
-export async function* iterSseEvents(
-  body: ReadableStream<Uint8Array>,
-  signal: AbortSignal,
-  readTimeoutMs: number,
-): AsyncIterable<SseEvent> {
-  const reader = body.getReader()
-  const decoder = new TextDecoder()
-  let buffer = ''
-  try {
-    while (!signal.aborted) {
-      const { done, value } = await readWithTimeout(reader, readTimeoutMs)
-      if (done) break
-      buffer += decoder.decode(value, { stream: true })
-      let boundary = findFrameBoundary(buffer)
-      while (boundary !== -1) {
-        const raw = buffer.slice(0, boundary)
-        const separator = buffer.slice(boundary).match(/^\r?\n\r?\n/)?.[0] ?? '\n\n'
-        buffer = buffer.slice(boundary + separator.length)
-        const event = extractSseEvent(raw)
-        if (event) yield event
-        boundary = findFrameBoundary(buffer)
-      }
-    }
-
-    const tail = buffer.trim()
-    if (tail) {
-      const event = extractSseEvent(tail)
-      if (event) yield event
-    }
-  } finally {
-    try { reader.releaseLock() } catch { void 0 }
-  }
-}
-
-export async function readWithTimeout(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-  timeoutMs: number,
-): Promise<ReadableStreamReadResult<Uint8Array>> {
-  let timer: NodeJS.Timeout | undefined
-  const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => {
-      reject(new Error(`no response from model in ${Math.round(timeoutMs / 1000)}s`))
-    }, timeoutMs)
-  })
-  try {
-    return await Promise.race([reader.read(), timeout])
-  } finally {
-    if (timer) clearTimeout(timer)
-  }
-}
-
-export function extractDataPayload(frame: string): string | null {
-  return extractSseEvent(frame)?.data ?? null
-}
-
-function extractSseEvent(frame: string): SseEvent | null {
-  const lines = frame.split(/\r?\n/)
-  const dataLines: string[] = []
-  let eventName: string | null = null
-
-  for (const line of lines) {
-    if (line.startsWith('event:')) {
-      eventName = line.slice(6).trim() || null
-      continue
-    }
-    if (line.startsWith('data:')) {
-      dataLines.push(line.slice(5).replace(/^ /, ''))
-    }
-  }
-
-  if (dataLines.length === 0) return null
-  return { event: eventName, data: dataLines.join('\n') }
-}
-
-function findFrameBoundary(buffer: string): number {
-  const match = /\r?\n\r?\n/.exec(buffer)
-  return match?.index ?? -1
-}