mirror of
https://github.com/netbirdio/netbird.git
synced 2026-10-03 12:09:09 +02:00
mlsmaycon
6ade3839aa
Request/response parsers and SSE/event-stream metering, the embedded pricing table, and the builtin middleware set: request parser, router, policy limit-check/record, cost meter, guardrail, identity inject, response parser. Includes the path-routed providers — Google Vertex AI (keyfile:: service-account OAuth minting) and AWS Bedrock (bearer auth, invoke/converse/streaming, optional /bedrock prefix) — plus the Models allowlist and unmeterable-publisher deny.
118 lines
2.6 KiB
Go
118 lines
2.6 KiB
Go
package llm
|
|
|
|
import (
|
|
"bufio"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
// Event represents a single server-sent event. Type is the dispatch name
|
|
// carried on an "event:" line (empty when the stream uses only "data:"
|
|
// lines). Data is the concatenation of every "data:" line that made up the
|
|
// event, joined by a single newline.
|
|
type Event struct {
|
|
Type string
|
|
Data string
|
|
}
|
|
|
|
// Scanner reads SSE events from an underlying byte stream. Events are
|
|
// delimited by a blank line ("\n\n"). CRLF line endings are normalized to LF
|
|
// transparently so fixtures captured from live servers can be replayed.
|
|
//
|
|
// Scanner is not safe for concurrent use.
|
|
type Scanner struct {
|
|
r *bufio.Reader
|
|
maxLine int
|
|
}
|
|
|
|
// NewScanner wraps the given reader. The default underlying buffer size is
|
|
// large enough for typical provider events (~64 KiB); callers needing
|
|
// larger events can wrap the reader in their own bufio.Reader beforehand.
|
|
func NewScanner(r io.Reader) *Scanner {
|
|
return &Scanner{
|
|
r: bufio.NewReaderSize(r, 64*1024),
|
|
maxLine: 1 << 20,
|
|
}
|
|
}
|
|
|
|
// Next returns the next event. It returns io.EOF after the final event has
|
|
// been consumed. A trailing event that is not terminated by a blank line is
|
|
// still returned before io.EOF so that servers which close the connection
|
|
// without a trailing newline are handled correctly.
|
|
func (s *Scanner) Next() (Event, error) {
|
|
var (
|
|
event Event
|
|
dataBuf strings.Builder
|
|
hasData bool
|
|
hasAny bool
|
|
)
|
|
|
|
for {
|
|
line, err := s.readLine()
|
|
if err != nil {
|
|
if errors.Is(err, io.EOF) && hasAny {
|
|
event.Data = dataBuf.String()
|
|
return event, nil
|
|
}
|
|
return Event{}, err
|
|
}
|
|
|
|
if line == "" {
|
|
if !hasAny {
|
|
continue
|
|
}
|
|
event.Data = dataBuf.String()
|
|
return event, nil
|
|
}
|
|
|
|
hasAny = true
|
|
if strings.HasPrefix(line, ":") {
|
|
continue
|
|
}
|
|
|
|
field, value := splitField(line)
|
|
switch field {
|
|
case "event":
|
|
event.Type = value
|
|
case "data":
|
|
if hasData {
|
|
dataBuf.WriteByte('\n')
|
|
}
|
|
dataBuf.WriteString(value)
|
|
hasData = true
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Scanner) readLine() (string, error) {
|
|
line, err := s.r.ReadString('\n')
|
|
if err != nil {
|
|
if errors.Is(err, io.EOF) && line != "" {
|
|
return trimEOL(line), nil
|
|
}
|
|
return "", err
|
|
}
|
|
if len(line) > s.maxLine {
|
|
return "", fmt.Errorf("sse line exceeds %d bytes", s.maxLine)
|
|
}
|
|
return trimEOL(line), nil
|
|
}
|
|
|
|
func trimEOL(line string) string {
|
|
line = strings.TrimRight(line, "\n")
|
|
line = strings.TrimRight(line, "\r")
|
|
return line
|
|
}
|
|
|
|
func splitField(line string) (string, string) {
|
|
idx := strings.IndexByte(line, ':')
|
|
if idx < 0 {
|
|
return line, ""
|
|
}
|
|
field := line[:idx]
|
|
value := strings.TrimPrefix(line[idx+1:], " ")
|
|
return field, value
|
|
}
|