mirror of
https://github.com/hanzo-go/openai.git
synced 2026-09-24 00:31:39 +00:00
zeekayandHanzo Dev
88762272c3
The fork kept the upstream module path (module github.com/sashabaranov/ go-openai), so every consumer could only reach it through a "replace github.com/sashabaranov/go-openai => github.com/hanzoai/go-openai" directive — and Go replace directives do NOT propagate to consumers, so each downstream repo had to copy the same replace or fail to compile against fork-only fields (e.g. ReasoningContent). That is the opposite of one-and- only-one-way. Declare the fork's OWN module path so it can be required directly and inherited transitively. Package name stays 'openai' (import identifier unchanged); only the module path + internal self-imports (/internal, /jsonschema) are renamed. Upstream issue-URL comments are left intact as attribution. Builds + vets clean. Co-authored-by: Hanzo Dev <[email protected]>
119 lines
2.3 KiB
Go
119 lines
2.3 KiB
Go
package openai
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
|
|
utils "github.com/hanzoai/go-openai/internal"
|
|
)
|
|
|
|
var (
|
|
headerData = []byte("data: ")
|
|
errorPrefix = []byte(`data: {"error":`)
|
|
)
|
|
|
|
type streamable interface {
|
|
ChatCompletionStreamResponse | CompletionResponse
|
|
}
|
|
|
|
type streamReader[T streamable] struct {
|
|
emptyMessagesLimit uint
|
|
isFinished bool
|
|
|
|
reader *bufio.Reader
|
|
response *http.Response
|
|
errAccumulator utils.ErrorAccumulator
|
|
unmarshaler utils.Unmarshaler
|
|
|
|
httpHeader
|
|
}
|
|
|
|
func (stream *streamReader[T]) Recv() (response T, err error) {
|
|
rawLine, err := stream.RecvRaw()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = stream.unmarshaler.Unmarshal(rawLine, &response)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (stream *streamReader[T]) RecvRaw() ([]byte, error) {
|
|
if stream.isFinished {
|
|
return nil, io.EOF
|
|
}
|
|
|
|
return stream.processLines()
|
|
}
|
|
|
|
//nolint:gocognit
|
|
func (stream *streamReader[T]) processLines() ([]byte, error) {
|
|
var (
|
|
emptyMessagesCount uint
|
|
hasErrorPrefix bool
|
|
)
|
|
|
|
for {
|
|
rawLine, readErr := stream.reader.ReadBytes('\n')
|
|
if readErr != nil || hasErrorPrefix {
|
|
respErr := stream.unmarshalError()
|
|
if respErr != nil {
|
|
return nil, fmt.Errorf("error, %w", respErr.Error)
|
|
}
|
|
return nil, readErr
|
|
}
|
|
|
|
noSpaceLine := bytes.TrimSpace(rawLine)
|
|
if bytes.HasPrefix(noSpaceLine, errorPrefix) {
|
|
hasErrorPrefix = true
|
|
}
|
|
if !bytes.HasPrefix(noSpaceLine, headerData) || hasErrorPrefix {
|
|
if hasErrorPrefix {
|
|
noSpaceLine = bytes.TrimPrefix(noSpaceLine, headerData)
|
|
}
|
|
writeErr := stream.errAccumulator.Write(noSpaceLine)
|
|
if writeErr != nil {
|
|
return nil, writeErr
|
|
}
|
|
emptyMessagesCount++
|
|
if emptyMessagesCount > stream.emptyMessagesLimit {
|
|
return nil, ErrTooManyEmptyStreamMessages
|
|
}
|
|
|
|
continue
|
|
}
|
|
|
|
noPrefixLine := bytes.TrimPrefix(noSpaceLine, headerData)
|
|
if string(noPrefixLine) == "[DONE]" {
|
|
stream.isFinished = true
|
|
return nil, io.EOF
|
|
}
|
|
|
|
return noPrefixLine, nil
|
|
}
|
|
}
|
|
|
|
func (stream *streamReader[T]) unmarshalError() (errResp *ErrorResponse) {
|
|
errBytes := stream.errAccumulator.Bytes()
|
|
if len(errBytes) == 0 {
|
|
return
|
|
}
|
|
|
|
err := stream.unmarshaler.Unmarshal(errBytes, &errResp)
|
|
if err != nil {
|
|
errResp = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (stream *streamReader[T]) Close() error {
|
|
return stream.response.Body.Close()
|
|
}
|