add openai realtime streaming adapter with reconnection logic

2026-02-01 01:55:36 +01:00
parent 917eeed978
commit d694a39ceb
4 changed files with 1097 additions and 2 deletions
@@ -0,0 +1,544 @@
+package transcriber
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/leonardotrapani/hyprvoice/internal/provider"
+)
+
+// mockOpenAIRealtimeServer creates a mock WebSocket server for OpenAI Realtime API
+func mockOpenAIRealtimeServer(t *testing.T, handler func(*websocket.Conn)) *httptest.Server {
+	upgrader := websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool { return true },
+	}
+
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// verify auth header
+		auth := r.Header.Get("Authorization")
+		if !strings.HasPrefix(auth, "Bearer ") {
+			t.Errorf("expected Bearer auth header, got: %s", auth)
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+
+		// verify model in query
+		model := r.URL.Query().Get("model")
+		if model == "" {
+			t.Error("expected model query parameter")
+		}
+
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			t.Errorf("upgrade failed: %v", err)
+			return
+		}
+		defer conn.Close()
+
+		handler(conn)
+	}))
+}
+
+func TestOpenAIRealtimeAdapter_ImplementsInterface(t *testing.T) {
+	var _ StreamingAdapter = (*OpenAIRealtimeAdapter)(nil)
+}
+
+func TestOpenAIRealtimeAdapter_Start(t *testing.T) {
+	var mu sync.Mutex
+	sessionCreated := false
+	sessionUpdated := false
+
+	server := mockOpenAIRealtimeServer(t, func(conn *websocket.Conn) {
+		// send session.created event
+		sessionCreatedEvent := map[string]interface{}{
+			"type":     "session.created",
+			"event_id": "event_123",
+			"session": map[string]interface{}{
+				"id":    "sess_123",
+				"model": "gpt-4o-realtime-preview",
+			},
+		}
+		if err := conn.WriteJSON(sessionCreatedEvent); err != nil {
+			t.Errorf("write session.created: %v", err)
+		}
+		mu.Lock()
+		sessionCreated = true
+		mu.Unlock()
+
+		// read session.update from client
+		_, msg, err := conn.ReadMessage()
+		if err != nil {
+			return
+		}
+
+		var update map[string]interface{}
+		if err := json.Unmarshal(msg, &update); err != nil {
+			t.Errorf("unmarshal session.update: %v", err)
+			return
+		}
+
+		if update["type"] != "session.update" {
+			t.Errorf("expected session.update, got %s", update["type"])
+		}
+		mu.Lock()
+		sessionUpdated = true
+		mu.Unlock()
+
+		// send session.updated response
+		sessionUpdatedEvent := map[string]interface{}{
+			"type":     "session.updated",
+			"event_id": "event_124",
+		}
+		if err := conn.WriteJSON(sessionUpdatedEvent); err != nil {
+			t.Errorf("write session.updated: %v", err)
+		}
+
+		// keep connection open until client closes
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				return
+			}
+		}
+	})
+	defer server.Close()
+
+	// extract host for endpoint
+	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
+
+	endpoint := &provider.EndpointConfig{
+		BaseURL: wsURL,
+		Path:    "",
+	}
+
+	adapter := NewOpenAIRealtimeAdapter(endpoint, "sk-test-key", "gpt-4o-realtime-preview", "en")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	err := adapter.Start(ctx, "")
+	if err != nil {
+		t.Fatalf("Start failed: %v", err)
+	}
+	defer adapter.Close()
+
+	// give time for events to process
+	time.Sleep(100 * time.Millisecond)
+
+	mu.Lock()
+	created := sessionCreated
+	updated := sessionUpdated
+	mu.Unlock()
+
+	if !created {
+		t.Error("session.created was not sent")
+	}
+	if !updated {
+		t.Error("session.update was not received by server")
+	}
+}
+
+func TestOpenAIRealtimeAdapter_SendChunk(t *testing.T) {
+	var mu sync.Mutex
+	receivedAudio := false
+
+	server := mockOpenAIRealtimeServer(t, func(conn *websocket.Conn) {
+		// send session.created
+		sessionCreatedEvent := map[string]interface{}{
+			"type": "session.created",
+			"session": map[string]interface{}{
+				"id": "sess_123",
+			},
+		}
+		conn.WriteJSON(sessionCreatedEvent)
+
+		// read session.update
+		conn.ReadMessage()
+
+		// send session.updated
+		conn.WriteJSON(map[string]interface{}{"type": "session.updated"})
+
+		// read audio chunk
+		_, msg, err := conn.ReadMessage()
+		if err != nil {
+			return
+		}
+
+		var audioMsg map[string]interface{}
+		if err := json.Unmarshal(msg, &audioMsg); err != nil {
+			t.Errorf("unmarshal audio: %v", err)
+			return
+		}
+
+		if audioMsg["type"] == "input_audio_buffer.append" {
+			audio, ok := audioMsg["audio"].(string)
+			if ok && len(audio) > 0 {
+				mu.Lock()
+				receivedAudio = true
+				mu.Unlock()
+			}
+		}
+
+		// keep connection open
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				return
+			}
+		}
+	})
+	defer server.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
+	endpoint := &provider.EndpointConfig{BaseURL: wsURL, Path: ""}
+	adapter := NewOpenAIRealtimeAdapter(endpoint, "sk-test", "gpt-4o-realtime-preview", "")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	if err := adapter.Start(ctx, ""); err != nil {
+		t.Fatalf("Start failed: %v", err)
+	}
+	defer adapter.Close()
+
+	// give time for connection setup
+	time.Sleep(100 * time.Millisecond)
+
+	// send audio chunk (16kHz PCM16)
+	audio := make([]byte, 320) // 10ms of 16kHz audio
+	for i := range audio {
+		audio[i] = byte(i % 256)
+	}
+
+	if err := adapter.SendChunk(audio); err != nil {
+		t.Fatalf("SendChunk failed: %v", err)
+	}
+
+	// give time for message to be sent
+	time.Sleep(100 * time.Millisecond)
+
+	mu.Lock()
+	received := receivedAudio
+	mu.Unlock()
+
+	if !received {
+		t.Error("server did not receive audio chunk")
+	}
+}
+
+func TestOpenAIRealtimeAdapter_TranscriptionResults(t *testing.T) {
+	server := mockOpenAIRealtimeServer(t, func(conn *websocket.Conn) {
+		// send session.created
+		conn.WriteJSON(map[string]interface{}{"type": "session.created", "session": map[string]interface{}{"id": "sess_123"}})
+
+		// read session.update
+		conn.ReadMessage()
+
+		// send session.updated
+		conn.WriteJSON(map[string]interface{}{"type": "session.updated"})
+
+		// simulate transcription events
+		time.Sleep(50 * time.Millisecond)
+
+		// speech started
+		conn.WriteJSON(map[string]interface{}{
+			"type": "input_audio_buffer.speech_started",
+		})
+
+		// partial transcription
+		conn.WriteJSON(map[string]interface{}{
+			"type":  "conversation.item.input_audio_transcription.delta",
+			"delta": "Hello",
+		})
+
+		// more partial
+		conn.WriteJSON(map[string]interface{}{
+			"type":  "conversation.item.input_audio_transcription.delta",
+			"delta": " world",
+		})
+
+		// final transcription
+		conn.WriteJSON(map[string]interface{}{
+			"type":       "conversation.item.input_audio_transcription.completed",
+			"transcript": "Hello world",
+		})
+
+		// keep connection open
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				return
+			}
+		}
+	})
+	defer server.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
+	endpoint := &provider.EndpointConfig{BaseURL: wsURL, Path: ""}
+	adapter := NewOpenAIRealtimeAdapter(endpoint, "sk-test", "gpt-4o-realtime-preview", "en")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	if err := adapter.Start(ctx, ""); err != nil {
+		t.Fatalf("Start failed: %v", err)
+	}
+	defer adapter.Close()
+
+	results := adapter.Results()
+
+	// collect results
+	var partials []string
+	var finals []string
+	timeout := time.After(2 * time.Second)
+
+	for {
+		select {
+		case result, ok := <-results:
+			if !ok {
+				goto done
+			}
+			if result.Error != nil {
+				continue
+			}
+			if result.IsFinal {
+				finals = append(finals, result.Text)
+			} else {
+				partials = append(partials, result.Text)
+			}
+			if len(finals) > 0 {
+				goto done
+			}
+		case <-timeout:
+			goto done
+		}
+	}
+done:
+
+	if len(partials) != 2 {
+		t.Errorf("expected 2 partial results, got %d: %v", len(partials), partials)
+	}
+
+	if len(finals) != 1 {
+		t.Errorf("expected 1 final result, got %d: %v", len(finals), finals)
+	}
+
+	if len(finals) > 0 && finals[0] != "Hello world" {
+		t.Errorf("expected final 'Hello world', got %q", finals[0])
+	}
+}
+
+func TestOpenAIRealtimeAdapter_ErrorHandling(t *testing.T) {
+	server := mockOpenAIRealtimeServer(t, func(conn *websocket.Conn) {
+		// send session.created
+		conn.WriteJSON(map[string]interface{}{"type": "session.created", "session": map[string]interface{}{"id": "sess_123"}})
+
+		// read session.update
+		conn.ReadMessage()
+
+		// send session.updated
+		conn.WriteJSON(map[string]interface{}{"type": "session.updated"})
+
+		// send error event
+		time.Sleep(50 * time.Millisecond)
+		conn.WriteJSON(map[string]interface{}{
+			"type": "error",
+			"error": map[string]interface{}{
+				"type":    "invalid_request_error",
+				"code":    "invalid_audio",
+				"message": "Audio format is invalid",
+			},
+		})
+
+		// keep connection open
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				return
+			}
+		}
+	})
+	defer server.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
+	endpoint := &provider.EndpointConfig{BaseURL: wsURL, Path: ""}
+	adapter := NewOpenAIRealtimeAdapter(endpoint, "sk-test", "gpt-4o-realtime-preview", "")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	if err := adapter.Start(ctx, ""); err != nil {
+		t.Fatalf("Start failed: %v", err)
+	}
+	defer adapter.Close()
+
+	results := adapter.Results()
+
+	// wait for error
+	select {
+	case result := <-results:
+		if result.Error == nil {
+			t.Error("expected error result")
+		}
+		if !strings.Contains(result.Error.Error(), "invalid_audio") {
+			t.Errorf("expected error containing 'invalid_audio', got: %v", result.Error)
+		}
+	case <-time.After(2 * time.Second):
+		t.Error("timeout waiting for error result")
+	}
+}
+
+func TestOpenAIRealtimeAdapter_Reconnection(t *testing.T) {
+	connectCount := 0
+	var mu sync.Mutex
+
+	server := mockOpenAIRealtimeServer(t, func(conn *websocket.Conn) {
+		mu.Lock()
+		connectCount++
+		count := connectCount
+		mu.Unlock()
+
+		// send session.created
+		conn.WriteJSON(map[string]interface{}{"type": "session.created", "session": map[string]interface{}{"id": "sess_" + string(rune('0'+count))}})
+
+		// read session.update
+		conn.ReadMessage()
+
+		// send session.updated
+		conn.WriteJSON(map[string]interface{}{"type": "session.updated"})
+
+		// first connection: close immediately to trigger reconnect
+		if count == 1 {
+			time.Sleep(50 * time.Millisecond)
+			conn.Close()
+			return
+		}
+
+		// second connection: stay open
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				return
+			}
+		}
+	})
+	defer server.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
+	endpoint := &provider.EndpointConfig{BaseURL: wsURL, Path: ""}
+	adapter := NewOpenAIRealtimeAdapter(endpoint, "sk-test", "gpt-4o-realtime-preview", "")
+	adapter.retryDelays = []time.Duration{10 * time.Millisecond, 20 * time.Millisecond, 40 * time.Millisecond}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	if err := adapter.Start(ctx, ""); err != nil {
+		t.Fatalf("Start failed: %v", err)
+	}
+	defer adapter.Close()
+
+	// wait for reconnection
+	time.Sleep(500 * time.Millisecond)
+
+	mu.Lock()
+	finalCount := connectCount
+	mu.Unlock()
+
+	if finalCount < 2 {
+		t.Errorf("expected at least 2 connections (reconnection), got %d", finalCount)
+	}
+}
+
+func TestOpenAIRealtimeAdapter_Close(t *testing.T) {
+	server := mockOpenAIRealtimeServer(t, func(conn *websocket.Conn) {
+		conn.WriteJSON(map[string]interface{}{"type": "session.created", "session": map[string]interface{}{"id": "sess_123"}})
+		conn.ReadMessage()
+		conn.WriteJSON(map[string]interface{}{"type": "session.updated"})
+
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				return
+			}
+		}
+	})
+	defer server.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
+	endpoint := &provider.EndpointConfig{BaseURL: wsURL, Path: ""}
+	adapter := NewOpenAIRealtimeAdapter(endpoint, "sk-test", "gpt-4o-realtime-preview", "")
+
+	ctx := context.Background()
+
+	if err := adapter.Start(ctx, ""); err != nil {
+		t.Fatalf("Start failed: %v", err)
+	}
+
+	// close should not block or panic
+	err := adapter.Close()
+	if err != nil {
+		t.Errorf("Close returned error: %v", err)
+	}
+
+	// results channel should be closed
+	select {
+	case _, ok := <-adapter.Results():
+		if ok {
+			// drain any remaining results
+			for range adapter.Results() {
+			}
+		}
+	case <-time.After(time.Second):
+		t.Error("results channel not closed after Close()")
+	}
+}
+
+func TestResample16to24(t *testing.T) {
+	// test with simple audio data
+	input := make([]byte, 32) // 16 samples at 16kHz
+	for i := 0; i < 16; i++ {
+		// write sample value (little-endian)
+		sample := int16(i * 1000)
+		input[i*2] = byte(sample)
+		input[i*2+1] = byte(sample >> 8)
+	}
+
+	output := resample16to24(input)
+
+	// 16 samples at 16kHz = 24 samples at 24kHz (ratio 1.5)
+	expectedSamples := 24
+	if len(output) != expectedSamples*2 {
+		t.Errorf("expected %d bytes, got %d", expectedSamples*2, len(output))
+	}
+
+	// output should have reasonable values (interpolated)
+	for i := 0; i < expectedSamples; i++ {
+		sample := int16(output[i*2]) | (int16(output[i*2+1]) << 8)
+		if sample < -32768 || sample > 32767 {
+			t.Errorf("sample %d out of range: %d", i, sample)
+		}
+	}
+}
+
+func TestResample16to24_EmptyInput(t *testing.T) {
+	output := resample16to24([]byte{})
+	if len(output) != 0 {
+		t.Errorf("expected empty output for empty input, got %d bytes", len(output))
+	}
+}
+
+func TestResample16to24_SingleSample(t *testing.T) {
+	input := []byte{0x00, 0x10} // single sample
+	output := resample16to24(input)
+	// with only 1 sample, output should be minimal
+	if len(output) == 0 {
+		t.Error("expected non-empty output for single sample")
+	}
+}