prepare repo for new message sse decoder

complete.go

@@ -50,14 +50,14 @@ type CompletionResponse struct {
 // StreamingCompletionResponse contains the server sent events decoder, the response body from the request, and a
 // cancel function to enforce a timeout.
 type StreamingCompletionResponse struct {
-	decoder *SSEDecoder
+	decoder *CompletionSSEDecoder
 	body    io.ReadCloser
 	cancel  context.CancelFunc
 }
 
 // Decode is a method for CompleteStreamResponse that returns the next event
 // from the server-sent events decoder, or an error if one occurred.
-func (c StreamingCompletionResponse) Decode() (*Event, error) {
+func (c StreamingCompletionResponse) Decode() (*CompletionEvent, error) {
 	return c.decoder.Decode()
 }
 
@@ -146,5 +146,5 @@ func (c *Client) StreamingCompletionRequest(ctx context.Context, payload Complet
 		return nil, fmt.Errorf("%s: %s", errorResponse.Error.Type, errorResponse.Error.Message)
 	}
 
-	return &StreamingCompletionResponse{NewSSEDecoder(res.Body), res.Body, cancel}, nil
+	return &StreamingCompletionResponse{NewCompletionSSEDecoder(res.Body), res.Body, cancel}, nil
 }

sse_decoder.go

@@ -9,39 +9,39 @@ import (
 	"strings"
 )
 
-// ResponseData represents the data payload in a Server-Sent Events (SSE) message.
-type ResponseData struct {
+// CompletionEventData represents the data payload in a Server-Sent Events (SSE) message.
+type CompletionEventData struct {
 	Completion string `json:"completion"`
 	StopReason string `json:"stop_reason"`
 	Model      string `json:"model"`
 	Stop       string `json:"stop"`
 	LogID      string `json:"log_id"`
 }
 
-// Event represents a single Server-Sent Event. It includes the event type, data, ID, and retry fields.
-type Event struct {
+// CompletionEvent represents a single Server-Sent CompletionEvent. It includes the event type, data, ID, and retry fields.
+type CompletionEvent struct {
 	Event string
-	Data  *ResponseData
+	Data  *CompletionEventData
 	ID    string
 	Retry int
 }
 
-// SSEDecoder is a decoder for Server-Sent Events. It maintains a buffer reader and the current event being processed.
-type SSEDecoder struct {
-	currentEvent Event
+// CompletionSSEDecoder is a decoder for Server-Sent Events. It maintains a buffer reader and the current event being processed.
+type CompletionSSEDecoder struct {
+	currentEvent CompletionEvent
 	Reader       *bufio.Reader
 }
 
-// NewSSEDecoder initializes a new SSEDecoder with the provided reader.
-func NewSSEDecoder(r io.Reader) *SSEDecoder {
-	return &SSEDecoder{
+// NewCompletionSSEDecoder initializes a new SSEDecoder with the provided reader.
+func NewCompletionSSEDecoder(r io.Reader) *CompletionSSEDecoder {
+	return &CompletionSSEDecoder{
 		Reader: bufio.NewReader(r),
 	}
 }
 
 // Decode reads from the buffered reader line by line, parses Server-Sent Events and sets fields on the current event.
 // It returns the complete event when encountering an empty line, and nil otherwise. It will return EOF when nothing is left.
-func (d *SSEDecoder) Decode() (*Event, error) {
+func (d *CompletionSSEDecoder) Decode() (*CompletionEvent, error) {
 	line, err := d.Reader.ReadString('\n')
 	if err != nil {
 		return nil, err
@@ -55,7 +55,7 @@ func (d *SSEDecoder) Decode() (*Event, error) {
 		}
 
 		ev := d.currentEvent
-		d.currentEvent = Event{ID: ev.ID} // preserve LastEventID for the next event
+		d.currentEvent = CompletionEvent{ID: ev.ID} // preserve LastEventID for the next event
 		return &ev, nil
 	}
 
@@ -79,7 +79,7 @@ func (d *SSEDecoder) Decode() (*Event, error) {
 	case "event":
 		d.currentEvent.Event = fieldValue
 	case "data":
-		var data ResponseData
+		var data CompletionEventData
 		err := json.Unmarshal([]byte(fieldValue), &data)
 		if err != nil {
 			return nil, fmt.Errorf("error decoding data field: %w", err)

sse_decoder_test.go

@@ -12,7 +12,7 @@ func TestDecode(t *testing.T) {
 		name    string
 		input   string
 		wantErr bool
-		wantEv  *Event
+		wantEv  *CompletionEvent
 	}{
 		{
 			name:    "has : prefix",
@@ -42,26 +42,26 @@ func TestDecode(t *testing.T) {
 			name:    "id field",
 			input:   "id: testID\n\r",
 			wantErr: false,
-			wantEv:  &Event{ID: "testID"},
+			wantEv:  &CompletionEvent{ID: "testID"},
 		},
 		{
 			name:    "event field",
 			input:   "event: testEvent\n\r",
 			wantErr: false,
-			wantEv:  &Event{Event: "testEvent"},
+			wantEv:  &CompletionEvent{Event: "testEvent"},
 		},
 		{
 			name:    "retry field",
 			input:   "retry: 5\n\r",
 			wantErr: false,
-			wantEv:  &Event{Retry: 5},
+			wantEv:  &CompletionEvent{Retry: 5},
 		},
 		{
 			name:    "data field",
 			input:   "data: {\"completion\":\"testCompletion\",\"stop_reason\":\"testReason\",\"model\":\"testModel\",\"stop\":\"testStop\",\"log_id\":\"testLogId\"}\n\r",
 			wantErr: false,
-			wantEv: &Event{
-				Data: &ResponseData{
+			wantEv: &CompletionEvent{
+				Data: &CompletionEventData{
 					Completion: "testCompletion",
 					StopReason: "testReason",
 					Model:      "testModel",
@@ -92,7 +92,7 @@ func TestDecode(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			r := strings.NewReader(tt.input + "\n")
-			dec := NewSSEDecoder(r)
+			dec := NewCompletionSSEDecoder(r)
 
 			ev, err := dec.Decode()
 			if !tt.wantErr {