流式通信底层：用原生 fetch 与 ReadableStream 解析 SSE 事件流

Chunk 1 字节流末尾:  data: {"choices":[{"delta":{"content":"你好
Chunk 2 字节流开头:  世界"}}]}

data: [DONE]

export async function streamChatCompletion({
  url,
  apiKey,
  model,
  messages,
  tools,
  onContentDelta,
  onToolCallDelta,
  timeoutMs = 30000
}) {
  const controller = new AbortController()
  const timer = setTimeout(() => controller.abort(new Error('LLM 流式请求超时')), timeoutMs)

  try {
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${apiKey}`
      },
      body: JSON.stringify({ model, messages, tools, stream: true }),
      signal: controller.signal
    })

    if (!res.ok || !res.body) {
      const errText = await res.text().catch(() => '')
      throw new Error(`LLM HTTP ${res.status}: ${errText.slice(0, 200)}`)
    }

    const reader = res.body.getReader()
    const decoder = new TextDecoder('utf-8')
    let lineBuffer = ''
    let fullContent = ''
    // 按 index 聚合流式分片的 tool_calls
    const toolCallsMap = new Map()

    while (true) {
      const { value, done } = await reader.read()
      if (done) break

      // 关键点 1：必须开启 { stream: true } 保留跨块未完成的 UTF-8 字节序列
      lineBuffer += decoder.decode(value, { stream: true })

      // 关键点 2：只消费已遇到换行符的完整行，将尾部残余半行留给下一轮 Chunk
      const lines = lineBuffer.split('\n')
      lineBuffer = lines.pop() || ''

      for (const rawLine of lines) {
        const line = rawLine.trim()
        if (!line || line.startsWith(':')) continue // 忽略空行与 SSE 心跳注释
        if (!line.startsWith('data:')) continue

        const payload = line.slice(5).trim()
        if (payload === '[DONE]') continue

        const packet = JSON.parse(payload)
        const delta = packet.choices?.[0]?.delta
        if (!delta) continue

        // 拼接普通文本增量
        if (delta.content) {
          fullContent += delta.content
          onContentDelta?.(delta.content, fullContent)
        }

        // 拼接流式 tool_calls 增量碎片
        if (Array.isArray(delta.tool_calls)) {
          for (const tc of delta.tool_calls) {
            const idx = tc.index ?? 0
            if (!toolCallsMap.has(idx)) {
              toolCallsMap.set(idx, {
                id: tc.id || '',
                type: 'function',
                function: { name: tc.function?.name || '', arguments: '' }
              })
            }
            const entry = toolCallsMap.get(idx)
            if (tc.id) entry.id = tc.id
            if (tc.function?.name) entry.function.name += tc.function.name
            if (tc.function?.arguments) {
              entry.function.arguments += tc.function.arguments
              onToolCallDelta?.(entry.function.name, tc.function.arguments)
            }
          }
        }
      }
    }

    // 冲刷 TextDecoder 内部残余字节
    lineBuffer += decoder.decode()

    const toolCalls = [...toolCallsMap.entries()]
      .sort((a, b) => a[0] - b[0])
      .map(([, v]) => v)

    return {
      role: 'assistant',
      content: fullContent || null,
      ...(toolCalls.length ? { tool_calls: toolCalls } : {})
    }
  } finally {
    clearTimeout(timer)
  }
}