mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
303 lines
9.2 KiB
Go
303 lines
9.2 KiB
Go
package pluginhost
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/pluginapi"
|
|
)
|
|
|
|
// This file normalizes plugin executor SSE streams before stream translation.
|
|
//
|
|
// Same-format stream translators assume each incoming payload is exactly one
|
|
// complete event. A passthrough plugin relaying raw host HTTP stream bytes
|
|
// does not guarantee that: chunks may hold several coalesced events or split
|
|
// one event at an arbitrary byte. deframeExecutorSSEChunks rebuilds event
|
|
// boundaries so the translators always receive exactly one event at a time.
|
|
//
|
|
// Payloads that are not SSE at all (bare JSON objects, the stock example's
|
|
// unterminated "plugin-example" text) are never parsed: they are forwarded
|
|
// with their original chunk boundary intact, so consecutive bare objects
|
|
// without line breaks are not concatenated, and multi-line bare JSON is not
|
|
// split per line.
|
|
|
|
// executorSSEDeframer accumulates incoming plugin stream chunks only while
|
|
// they can still belong to an incomplete SSE event. Once an event boundary
|
|
// (a blank line) is reached the event is emitted whole. Chunk bytes that can
|
|
// no longer belong to an SSE event are released verbatim with their chunk
|
|
// boundary intact instead of being buffered or split. A partial prefix such
|
|
// as "da" is buffered because later bytes may complete a "data:" line.
|
|
//
|
|
// The deframer also remembers whether the stream has ever produced an SSE
|
|
// event (sawSSE). Established SSE streams treat blank lines between events
|
|
// as framing even when a blank line arrives in a later chunk, and bare
|
|
// lines are emitted one line at a time so a following SSE event can still
|
|
// be recognized. Streams that have never produced an SSE event stay in
|
|
// bare mode, where payloads are forwarded with their chunk boundaries
|
|
// intact and never split or merged.
|
|
type executorSSEDeframer struct {
|
|
buffer []byte
|
|
sawSSE bool
|
|
}
|
|
|
|
func (d *executorSSEDeframer) feed(payload []byte) [][]byte {
|
|
if len(payload) == 0 {
|
|
return nil
|
|
}
|
|
// Fast path: nothing pending, no SSE event seen yet, and the chunk
|
|
// cannot begin an SSE event. Emit the chunk untouched so bare payloads
|
|
// keep their boundaries, including bare content that opens with a
|
|
// newline.
|
|
if len(d.buffer) == 0 && !d.sawSSE && !canBeginSSEEvent(payload) {
|
|
return [][]byte{payload}
|
|
}
|
|
d.buffer = append(d.buffer, payload...)
|
|
|
|
var chunks [][]byte
|
|
for {
|
|
if len(d.buffer) == 0 {
|
|
break
|
|
}
|
|
// Leading blank lines are the unmatched second half of an earlier
|
|
// event boundary and are dropped. In bare mode this only runs after
|
|
// an SSE event started in an earlier chunk (the fast path above
|
|
// keeps newline-led bare payloads untouched).
|
|
dropBlankSSELine := false
|
|
if idx := bytes.IndexByte(d.buffer, '\n'); idx >= 0 && isBlankSSELine(d.buffer[:idx]) {
|
|
d.advance(idx + 1)
|
|
dropBlankSSELine = true
|
|
}
|
|
if dropBlankSSELine {
|
|
continue
|
|
}
|
|
if len(d.buffer) == 0 {
|
|
break
|
|
}
|
|
if !sseDataLinePrefix(d.buffer) && !bytes.HasPrefix(d.buffer, []byte("event:")) && !bytes.HasPrefix(d.buffer, []byte(":")) {
|
|
// Leftover bytes do not begin a new SSE event. A partial
|
|
// "data:"/"event:" prefix stays buffered. In SSE mode only the
|
|
// first complete line is released so an SSE event that follows
|
|
// in a later chunk is still deframed; in bare mode the whole
|
|
// leftover is released so bare content keeps its chunk
|
|
// boundary (no line-based splitting or merging).
|
|
if isSSEFieldPrefixPartial(d.buffer) {
|
|
break
|
|
}
|
|
if d.sawSSE {
|
|
idx := bytes.IndexByte(d.buffer, '\n')
|
|
if idx < 0 {
|
|
break
|
|
}
|
|
chunks = append(chunks, bytes.Clone(d.buffer[:idx+1]))
|
|
d.advance(idx + 1)
|
|
continue
|
|
}
|
|
chunks = append(chunks, bytes.Clone(d.buffer))
|
|
d.buffer = nil
|
|
break
|
|
}
|
|
event, complete := d.takeEvent()
|
|
if !complete {
|
|
break
|
|
}
|
|
d.sawSSE = true
|
|
if len(event) > 0 {
|
|
chunks = append(chunks, event)
|
|
}
|
|
}
|
|
return chunks
|
|
}
|
|
|
|
// flush returns any buffered partial event at end of stream.
|
|
func (d *executorSSEDeframer) flush() []byte {
|
|
pending := d.buffer
|
|
d.buffer = nil
|
|
// Trailing CR/LF bytes are line framing only: the partial content before
|
|
// them is what remains to be delivered, so a final "data: [DONE]\r" still
|
|
// reads as the terminal marker. Interior whitespace (including a
|
|
// leading newline) belongs to the payload and is preserved.
|
|
pending = bytes.TrimRight(pending, "\r\n")
|
|
if len(pending) == 0 {
|
|
return nil
|
|
}
|
|
return pending
|
|
}
|
|
|
|
// canBeginSSEEvent reports whether payload could start an SSE event: a data
|
|
// line, an event line, a comment line, or a strict prefix of the "data:" or
|
|
// "event:" field names that later bytes may complete. A leading newline
|
|
// alone is not enough: bare JSON may open with a newline and must stay one
|
|
// untouched payload.
|
|
func canBeginSSEEvent(b []byte) bool {
|
|
if len(b) == 0 {
|
|
return false
|
|
}
|
|
switch b[0] {
|
|
case ':':
|
|
return true
|
|
case 'd':
|
|
return sseFieldPrefixCandidate(b, "data:")
|
|
case 'e':
|
|
return sseFieldPrefixCandidate(b, "event:")
|
|
}
|
|
return false
|
|
}
|
|
|
|
func sseFieldPrefixCandidate(b []byte, field string) bool {
|
|
if len(b) <= len(field) {
|
|
return bytes.HasPrefix([]byte(field), b)
|
|
}
|
|
return bytes.HasPrefix(b, []byte(field))
|
|
}
|
|
|
|
// isSSEFieldPrefixPartial reports whether b is a strict prefix of "data:" or
|
|
// "event:": the field name may be completed by a later chunk, so these bytes
|
|
// must stay buffered instead of being released.
|
|
func isSSEFieldPrefixPartial(b []byte) bool {
|
|
if len(b) == 0 || len(b) >= len("event:") {
|
|
return false
|
|
}
|
|
return bytes.HasPrefix([]byte("data:"), b) || bytes.HasPrefix([]byte("event:"), b)
|
|
}
|
|
|
|
// sseDataLinePrefix reports whether b begins with an SSE data line. The
|
|
// space after the colon is optional in SSE, so any payload bytes after
|
|
// "data:" count as a data line.
|
|
func sseDataLinePrefix(b []byte) bool {
|
|
return bytes.HasPrefix(b, []byte("data:"))
|
|
}
|
|
|
|
// takeEvent extracts the next complete SSE event when one is available.
|
|
// Comment-only blocks are consumed but not returned: they are SSE
|
|
// keep-alives with no data semantics, matching how built-in executors ignore
|
|
// ":" lines instead of forwarding them as payloads.
|
|
func (d *executorSSEDeframer) takeEvent() ([]byte, bool) {
|
|
if len(d.buffer) == 0 {
|
|
return nil, false
|
|
}
|
|
idx := indexSSEFrameBoundary(d.buffer)
|
|
if idx < 0 {
|
|
return nil, false
|
|
}
|
|
end := idx + 1
|
|
event := bytes.Clone(d.buffer[:end])
|
|
d.advance(end)
|
|
if isSSECommentOnlyEvent(event) {
|
|
return nil, true
|
|
}
|
|
return event, true
|
|
}
|
|
|
|
func (d *executorSSEDeframer) advance(n int) {
|
|
rest := d.buffer[n:]
|
|
if len(rest) == 0 {
|
|
d.buffer = nil
|
|
return
|
|
}
|
|
d.buffer = append(d.buffer[:0], rest...)
|
|
}
|
|
|
|
// deframeExecutorSSEChunks reassembles full SSE events from arbitrary chunk
|
|
// boundaries and passes bare payloads through with their chunk boundaries
|
|
// intact. It only runs for same-format streams with a registered native
|
|
// stream translator.
|
|
//
|
|
// It never synthesizes a terminal marker: emitTranslatedExecutorStreamTail
|
|
// in the translation goroutine owns that responsibility (it feeds one
|
|
// [DONE] through TranslateStream at channel close for [DONE]-terminated
|
|
// formats). Emitting a second synthetic marker here would run plugin
|
|
// response hooks twice and could surface two terminal frames.
|
|
func deframeExecutorSSEChunks(ctx context.Context, in <-chan pluginapi.ExecutorStreamChunk) <-chan pluginapi.ExecutorStreamChunk {
|
|
if in == nil {
|
|
return nil
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
out := make(chan pluginapi.ExecutorStreamChunk)
|
|
go func() {
|
|
defer close(out)
|
|
deframer := &executorSSEDeframer{}
|
|
|
|
emit := func(payloads [][]byte) bool {
|
|
for _, payload := range payloads {
|
|
if len(payload) == 0 {
|
|
continue
|
|
}
|
|
if !sendExecutorPluginStreamChunk(ctx, out, pluginapi.ExecutorStreamChunk{Payload: payload}) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case chunk, ok := <-in:
|
|
if !ok {
|
|
if tail := deframer.flush(); len(tail) > 0 {
|
|
_ = emit([][]byte{tail})
|
|
}
|
|
return
|
|
}
|
|
if chunk.Err != nil {
|
|
// Buffered partial events belong to the failed prefix;
|
|
// emit them before the error is forwarded.
|
|
if tail := deframer.flush(); len(tail) > 0 {
|
|
if !emit([][]byte{tail}) {
|
|
return
|
|
}
|
|
}
|
|
_ = sendExecutorPluginStreamChunk(ctx, out, chunk)
|
|
continue
|
|
}
|
|
if !emit(deframer.feed(chunk.Payload)) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
return out
|
|
}
|
|
|
|
// indexSSEFrameBoundary scans complete lines and returns the index of the LF
|
|
// ending the blank line that terminates an SSE event, or -1 while the event
|
|
// is incomplete. Handling line by line keeps LF, CRLF, and mixed endings
|
|
// correct, including a CRLF blank line split across chunk boundaries.
|
|
func indexSSEFrameBoundary(b []byte) int {
|
|
pos := 0
|
|
for {
|
|
idx := bytes.IndexByte(b[pos:], '\n')
|
|
if idx < 0 {
|
|
return -1
|
|
}
|
|
lineEnd := pos + idx
|
|
if isBlankSSELine(b[pos:lineEnd]) {
|
|
return lineEnd
|
|
}
|
|
pos = lineEnd + 1
|
|
}
|
|
}
|
|
|
|
func isBlankSSELine(line []byte) bool {
|
|
line = bytes.TrimSuffix(line, []byte{'\r'})
|
|
return len(line) == 0
|
|
}
|
|
|
|
func isSSECommentOnlyEvent(event []byte) bool {
|
|
sawComment := false
|
|
for _, line := range bytes.Split(event, []byte("\n")) {
|
|
trimmed := bytes.TrimSpace(line)
|
|
if len(trimmed) == 0 {
|
|
continue
|
|
}
|
|
if !bytes.HasPrefix(trimmed, []byte(":")) {
|
|
return false
|
|
}
|
|
sawComment = true
|
|
}
|
|
return sawComment
|
|
}
|