mirror of
https://github.com/hanzoai/go-openai-realtime.git
synced 2026-09-30 21:54:42 +00:00
zeekayandClaude Opus 5
410e64940f
Modules declare go 1.27.1 and the build images follow. go fix applied the modernizers, and the examples print streamed deltas with Print instead of using them as format strings; omitzero is not applied, since it changes what the JSON says. Co-Authored-By: Claude Opus 5 <[email protected]>
957 lines
30 KiB
Go
957 lines
30 KiB
Go
//nolint:errcheck // no error
|
|
package openairt_test
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
openairt "github.com/hanzoai/go-openai-realtime"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestErrorEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_890",
|
|
"type": "error",
|
|
"error": {
|
|
"type": "invalid_request_error",
|
|
"code": "invalid_event",
|
|
"message": "The 'type' field is missing.",
|
|
"param": null,
|
|
"event_id": "event_567"
|
|
}
|
|
}`
|
|
expected := openairt.ErrorEvent{
|
|
Type: openairt.ServerEventTypeError,
|
|
EventID: "event_890",
|
|
Error: openairt.Error{
|
|
Type: "invalid_request_error",
|
|
Code: "invalid_event",
|
|
Message: "The 'type' field is missing.",
|
|
Param: "",
|
|
EventID: "event_567",
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeError, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ErrorEvent))
|
|
}
|
|
|
|
func TestServerToolChoice(t *testing.T) {
|
|
data := `{"type": "function", "function": {"name": "get_current_weather"}}`
|
|
expectedFunction := openairt.ToolChoice{
|
|
Type: openairt.ToolTypeFunction,
|
|
Function: openairt.ToolFunction{
|
|
Name: "get_current_weather",
|
|
},
|
|
}
|
|
expected := openairt.ServerToolChoice{Function: expectedFunction}
|
|
actual := openairt.ServerToolChoice{}
|
|
err := json.Unmarshal([]byte(data), &actual)
|
|
require.NoError(t, err)
|
|
require.Equal(t, expected, actual)
|
|
require.Equal(t, expectedFunction, actual.Get())
|
|
|
|
data = `"auto"`
|
|
expected = openairt.ServerToolChoice{String: openairt.ToolChoiceAuto}
|
|
actual = openairt.ServerToolChoice{}
|
|
err = json.Unmarshal([]byte(data), &actual)
|
|
require.NoError(t, err)
|
|
require.Equal(t, expected, actual)
|
|
require.Equal(t, openairt.ToolChoiceAuto, actual.Get())
|
|
|
|
data = `"none"`
|
|
expected = openairt.ServerToolChoice{String: openairt.ToolChoiceNone}
|
|
actual = openairt.ServerToolChoice{}
|
|
err = json.Unmarshal([]byte(data), &actual)
|
|
require.NoError(t, err)
|
|
require.Equal(t, expected, actual)
|
|
require.Equal(t, openairt.ToolChoiceNone, actual.Get())
|
|
|
|
data = `"required"`
|
|
expected = openairt.ServerToolChoice{String: openairt.ToolChoiceRequired}
|
|
actual = openairt.ServerToolChoice{}
|
|
err = json.Unmarshal([]byte(data), &actual)
|
|
require.NoError(t, err)
|
|
require.Equal(t, expected, actual)
|
|
require.Equal(t, openairt.ToolChoiceRequired, actual.Get())
|
|
}
|
|
|
|
func TestSessionCreatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_1234",
|
|
"type": "session.created",
|
|
"session": {
|
|
"id": "sess_001",
|
|
"object": "realtime.session",
|
|
"model": "gpt-4o-realtime-preview-2024-10-01",
|
|
"modalities": ["text", "audio"],
|
|
"instructions": "",
|
|
"voice": "alloy",
|
|
"input_audio_format": "pcm16",
|
|
"output_audio_format": "pcm16",
|
|
"input_audio_transcription": null,
|
|
"turn_detection": {
|
|
"type": "server_vad",
|
|
"threshold": 0.5,
|
|
"prefix_padding_ms": 300,
|
|
"silence_duration_ms": 200
|
|
},
|
|
"tools": [],
|
|
"tool_choice": "auto",
|
|
"temperature": 0.8,
|
|
"max_response_output_tokens": null
|
|
}
|
|
}`
|
|
temperature := float32(0.8)
|
|
expected := openairt.SessionCreatedEvent{
|
|
EventID: "event_1234",
|
|
Type: openairt.ServerEventTypeSessionCreated,
|
|
Session: openairt.ServerSession{
|
|
ID: "sess_001",
|
|
Object: "realtime.session",
|
|
Model: openairt.GPT4oRealtimePreview20241001,
|
|
Modalities: []openairt.Modality{openairt.ModalityText, openairt.ModalityAudio},
|
|
Instructions: "",
|
|
Voice: openairt.VoiceAlloy,
|
|
InputAudioFormat: openairt.AudioFormatPcm16,
|
|
OutputAudioFormat: openairt.AudioFormatPcm16,
|
|
InputAudioTranscription: nil,
|
|
TurnDetection: &openairt.ServerTurnDetection{
|
|
Type: openairt.ServerTurnDetectionTypeServerVad,
|
|
Threshold: 0.5,
|
|
PrefixPaddingMs: 300,
|
|
SilenceDurationMs: 200,
|
|
},
|
|
Tools: []openairt.Tool{},
|
|
ToolChoice: openairt.ServerToolChoice{String: openairt.ToolChoiceAuto},
|
|
Temperature: &temperature,
|
|
MaxOutputTokens: 0,
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeSessionCreated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.SessionCreatedEvent))
|
|
}
|
|
|
|
func TestSessionUpdatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_5678",
|
|
"type": "session.updated",
|
|
"session": {
|
|
"id": "sess_001",
|
|
"object": "realtime.session",
|
|
"model": "gpt-4o-realtime-preview-2024-10-01",
|
|
"modalities": ["text"],
|
|
"instructions": "New instructions",
|
|
"voice": "alloy",
|
|
"input_audio_format": "pcm16",
|
|
"output_audio_format": "pcm16",
|
|
"input_audio_transcription": {
|
|
"model": "whisper-1"
|
|
},
|
|
"turn_detection": {
|
|
"type": "none"
|
|
},
|
|
"tools": [],
|
|
"tool_choice": "none",
|
|
"temperature": 0.7,
|
|
"max_response_output_tokens": 200
|
|
}
|
|
}`
|
|
temperature := float32(0.7)
|
|
expected := openairt.SessionUpdatedEvent{
|
|
EventID: "event_5678",
|
|
Type: openairt.ServerEventTypeSessionUpdated,
|
|
Session: openairt.ServerSession{
|
|
ID: "sess_001",
|
|
Object: "realtime.session",
|
|
Model: openairt.GPT4oRealtimePreview20241001,
|
|
Modalities: []openairt.Modality{openairt.ModalityText},
|
|
Instructions: "New instructions",
|
|
Voice: openairt.VoiceAlloy,
|
|
InputAudioFormat: openairt.AudioFormatPcm16,
|
|
OutputAudioFormat: openairt.AudioFormatPcm16,
|
|
InputAudioTranscription: &openairt.InputAudioTranscription{
|
|
Model: "whisper-1",
|
|
},
|
|
TurnDetection: &openairt.ServerTurnDetection{
|
|
Type: openairt.ServerTurnDetectionTypeNone,
|
|
},
|
|
Tools: []openairt.Tool{},
|
|
ToolChoice: openairt.ServerToolChoice{String: openairt.ToolChoiceNone},
|
|
Temperature: &temperature,
|
|
MaxOutputTokens: 200,
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeSessionUpdated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.SessionUpdatedEvent))
|
|
|
|
data = `{
|
|
"event_id": "event_5678",
|
|
"type": "session.updated",
|
|
"session": {
|
|
"id": "sess_001",
|
|
"object": "realtime.session",
|
|
"model": "gpt-4o-realtime-preview-2024-10-01",
|
|
"modalities": ["text"],
|
|
"instructions": "New instructions",
|
|
"voice": "alloy",
|
|
"input_audio_format": "pcm16",
|
|
"output_audio_format": "pcm16",
|
|
"input_audio_transcription": {
|
|
"model": "whisper-1"
|
|
},
|
|
"turn_detection": {
|
|
"type": "none"
|
|
},
|
|
"tools": [],
|
|
"tool_choice": "none",
|
|
"temperature": 0.7,
|
|
"max_response_output_tokens": "inf"
|
|
}
|
|
}`
|
|
expected.Session.MaxOutputTokens = openairt.Inf
|
|
actual, err = openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeSessionUpdated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.SessionUpdatedEvent))
|
|
}
|
|
|
|
func TestConversationCreatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_9101",
|
|
"type": "conversation.created",
|
|
"conversation": {
|
|
"id": "conv_001",
|
|
"object": "realtime.conversation"
|
|
}
|
|
}`
|
|
expected := openairt.ConversationCreatedEvent{
|
|
EventID: "event_9101",
|
|
Type: openairt.ServerEventTypeConversationCreated,
|
|
Conversation: openairt.Conversation{
|
|
ID: "conv_001",
|
|
Object: "realtime.conversation",
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeConversationCreated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ConversationCreatedEvent))
|
|
}
|
|
|
|
func TestConversationItemCreatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_1920",
|
|
"type": "conversation.item.created",
|
|
"previous_item_id": "msg_002",
|
|
"item": {
|
|
"id": "msg_003",
|
|
"object": "realtime.item",
|
|
"type": "message",
|
|
"status": "completed",
|
|
"role": "user",
|
|
"content": [
|
|
{
|
|
"type": "input_audio",
|
|
"transcript": null
|
|
}
|
|
]
|
|
}
|
|
}`
|
|
expected := openairt.ConversationItemCreatedEvent{
|
|
EventID: "event_1920",
|
|
Type: openairt.ServerEventTypeConversationItemCreated,
|
|
PreviousItemID: "msg_002",
|
|
Item: openairt.ResponseMessageItem{
|
|
Object: "realtime.item",
|
|
MessageItem: openairt.MessageItem{
|
|
ID: "msg_003",
|
|
Type: openairt.MessageItemTypeMessage,
|
|
Status: openairt.ItemStatusCompleted,
|
|
Role: openairt.MessageRoleUser,
|
|
Content: []openairt.MessageContentPart{
|
|
{
|
|
Type: openairt.MessageContentTypeInputAudio,
|
|
Transcript: "",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeConversationItemCreated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ConversationItemCreatedEvent))
|
|
}
|
|
|
|
func TestConversationItemInputAudioTranscriptionCompletedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_2122",
|
|
"type": "conversation.item.input_audio_transcription.completed",
|
|
"item_id": "msg_003",
|
|
"content_index": 1,
|
|
"transcript": "Hello, how are you?"
|
|
}`
|
|
expected := openairt.ConversationItemInputAudioTranscriptionCompletedEvent{
|
|
EventID: "event_2122",
|
|
Type: openairt.ServerEventTypeConversationItemInputAudioTranscriptionCompleted,
|
|
ItemID: "msg_003",
|
|
ContentIndex: 1,
|
|
Transcript: "Hello, how are you?",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeConversationItemInputAudioTranscriptionCompleted, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ConversationItemInputAudioTranscriptionCompletedEvent))
|
|
}
|
|
|
|
func TestConversationItemInputAudioTranscriptionFailedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_2324",
|
|
"type": "conversation.item.input_audio_transcription.failed",
|
|
"item_id": "msg_003",
|
|
"content_index": 0,
|
|
"error": {
|
|
"type": "transcription_error",
|
|
"code": "audio_unintelligible",
|
|
"message": "The audio could not be transcribed.",
|
|
"param": null
|
|
}
|
|
}`
|
|
expected := openairt.ConversationItemInputAudioTranscriptionFailedEvent{
|
|
EventID: "event_2324",
|
|
Type: openairt.ServerEventTypeConversationItemInputAudioTranscriptionFailed,
|
|
ItemID: "msg_003",
|
|
ContentIndex: 0,
|
|
Error: openairt.Error{
|
|
Type: "transcription_error",
|
|
Code: "audio_unintelligible",
|
|
Message: "The audio could not be transcribed.",
|
|
Param: "",
|
|
EventID: "",
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeConversationItemInputAudioTranscriptionFailed, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ConversationItemInputAudioTranscriptionFailedEvent))
|
|
}
|
|
|
|
func TestConversationItemTruncatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_2526",
|
|
"type": "conversation.item.truncated",
|
|
"item_id": "msg_004",
|
|
"content_index": 2,
|
|
"audio_end_ms": 1500
|
|
}`
|
|
expected := openairt.ConversationItemTruncatedEvent{
|
|
EventID: "event_2526",
|
|
Type: openairt.ServerEventTypeConversationItemTruncated,
|
|
ItemID: "msg_004",
|
|
ContentIndex: 2,
|
|
AudioEndMs: 1500,
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeConversationItemTruncated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ConversationItemTruncatedEvent))
|
|
}
|
|
|
|
func TestConversationItemDeletedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_2728",
|
|
"type": "conversation.item.deleted",
|
|
"item_id": "msg_005"
|
|
}`
|
|
expected := openairt.ConversationItemDeletedEvent{
|
|
EventID: "event_2728",
|
|
Type: openairt.ServerEventTypeConversationItemDeleted,
|
|
ItemID: "msg_005",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeConversationItemDeleted, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ConversationItemDeletedEvent))
|
|
}
|
|
|
|
func TestInputAudioBufferCommittedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_1121",
|
|
"type": "input_audio_buffer.committed",
|
|
"previous_item_id": "msg_001",
|
|
"item_id": "msg_002"
|
|
}`
|
|
expected := openairt.InputAudioBufferCommittedEvent{
|
|
EventID: "event_1121",
|
|
Type: openairt.ServerEventTypeInputAudioBufferCommitted,
|
|
PreviousItemID: "msg_001",
|
|
ItemID: "msg_002",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeInputAudioBufferCommitted, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.InputAudioBufferCommittedEvent))
|
|
}
|
|
|
|
func TestInputAudioBufferClearedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_1314",
|
|
"type": "input_audio_buffer.cleared"
|
|
}`
|
|
expected := openairt.InputAudioBufferClearedEvent{
|
|
EventID: "event_1314",
|
|
Type: openairt.ServerEventTypeInputAudioBufferCleared,
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeInputAudioBufferCleared, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.InputAudioBufferClearedEvent))
|
|
}
|
|
|
|
func TestInputAudioBufferSpeechStartedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_1516",
|
|
"type": "input_audio_buffer.speech_started",
|
|
"audio_start_ms": 1000,
|
|
"item_id": "msg_003"
|
|
}`
|
|
expected := openairt.InputAudioBufferSpeechStartedEvent{
|
|
EventID: "event_1516",
|
|
Type: openairt.ServerEventTypeInputAudioBufferSpeechStarted,
|
|
AudioStartMs: 1000,
|
|
ItemID: "msg_003",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeInputAudioBufferSpeechStarted, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.InputAudioBufferSpeechStartedEvent))
|
|
}
|
|
|
|
func TestInputAudioBufferSpeechStoppedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_1718",
|
|
"type": "input_audio_buffer.speech_stopped",
|
|
"audio_end_ms": 2000,
|
|
"item_id": "msg_003"
|
|
}`
|
|
expected := openairt.InputAudioBufferSpeechStoppedEvent{
|
|
EventID: "event_1718",
|
|
Type: openairt.ServerEventTypeInputAudioBufferSpeechStopped,
|
|
AudioEndMs: 2000,
|
|
ItemID: "msg_003",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeInputAudioBufferSpeechStopped, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.InputAudioBufferSpeechStoppedEvent))
|
|
}
|
|
|
|
func TestResponseCreatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_2930",
|
|
"type": "response.created",
|
|
"response": {
|
|
"id": "resp_001",
|
|
"object": "realtime.response",
|
|
"status": "in_progress",
|
|
"status_details": null,
|
|
"output": [],
|
|
"usage": null
|
|
}
|
|
}`
|
|
expected := openairt.ResponseCreatedEvent{
|
|
EventID: "event_2930",
|
|
Type: openairt.ServerEventTypeResponseCreated,
|
|
Response: openairt.Response{
|
|
ID: "resp_001",
|
|
Object: "realtime.response",
|
|
Status: "in_progress",
|
|
StatusDetails: nil,
|
|
Output: []openairt.ResponseMessageItem{},
|
|
Usage: nil,
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseCreated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseCreatedEvent))
|
|
}
|
|
|
|
func TestResponseDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"type": "response.done",
|
|
"event_id": "event_APnPcL4wUvPmXTFejvDzn",
|
|
"response": {
|
|
"object": "realtime.response",
|
|
"id": "resp_APnPbMhvCmC0K8qZALSeI",
|
|
"status": "completed",
|
|
"status_details": null,
|
|
"output": [
|
|
{
|
|
"id": "item_APnPbzHkH7zf8AteO9hdx",
|
|
"object": "realtime.item",
|
|
"type": "message",
|
|
"status": "completed",
|
|
"role": "assistant",
|
|
"content": [
|
|
{ "type": "audio", "transcript": "Hello! How can I help you today?" }
|
|
]
|
|
}
|
|
],
|
|
"usage": {
|
|
"total_tokens": 198,
|
|
"input_tokens": 136,
|
|
"output_tokens": 62,
|
|
"input_token_details": {
|
|
"text_tokens": 119,
|
|
"audio_tokens": 17,
|
|
"cached_tokens": 0,
|
|
"cached_tokens_details": { "text_tokens": 0, "audio_tokens": 0 }
|
|
},
|
|
"output_token_details": { "text_tokens": 19, "audio_tokens": 43 }
|
|
}
|
|
}
|
|
}`
|
|
expected := openairt.ResponseDoneEvent{
|
|
EventID: "event_APnPcL4wUvPmXTFejvDzn",
|
|
Type: openairt.ServerEventTypeResponseDone,
|
|
Response: openairt.Response{
|
|
ID: "resp_APnPbMhvCmC0K8qZALSeI",
|
|
Object: "realtime.response",
|
|
Status: openairt.ResponseStatusCompleted,
|
|
StatusDetails: nil,
|
|
Output: []openairt.ResponseMessageItem{
|
|
{
|
|
Object: "realtime.item",
|
|
ID: "item_APnPbzHkH7zf8AteO9hdx",
|
|
Type: openairt.MessageItemTypeMessage,
|
|
Status: openairt.ItemStatusCompleted,
|
|
Role: openairt.MessageRoleAssistant,
|
|
Content: []openairt.MessageContentPart{
|
|
{
|
|
Type: openairt.MessageContentTypeAudio,
|
|
Transcript: "Hello! How can I help you today?",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Usage: &openairt.Usage{
|
|
TotalTokens: 198,
|
|
InputTokens: 136,
|
|
OutputTokens: 62,
|
|
InputTokenDetails: openairt.InputTokenDetails{
|
|
TextTokens: 119,
|
|
AudioTokens: 17,
|
|
CachedTokens: 0,
|
|
CachedTokensDetails: openairt.CachedTokensDetails{
|
|
TextTokens: 0,
|
|
AudioTokens: 0,
|
|
},
|
|
},
|
|
OutputTokenDetails: openairt.OutputTokenDetails{
|
|
TextTokens: 19,
|
|
AudioTokens: 43,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseDoneEvent))
|
|
}
|
|
|
|
func TestResponseOutputItemAddedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_3334",
|
|
"type": "response.output_item.added",
|
|
"response_id": "resp_001",
|
|
"output_index": 10,
|
|
"item": {
|
|
"id": "msg_007",
|
|
"object": "realtime.item",
|
|
"type": "message",
|
|
"status": "in_progress",
|
|
"role": "assistant",
|
|
"content": []
|
|
}
|
|
}`
|
|
expected := openairt.ResponseOutputItemAddedEvent{
|
|
EventID: "event_3334",
|
|
Type: openairt.ServerEventTypeResponseOutputItemAdded,
|
|
ResponseID: "resp_001",
|
|
OutputIndex: 10,
|
|
Item: openairt.ResponseMessageItem{
|
|
Object: "realtime.item",
|
|
MessageItem: openairt.MessageItem{
|
|
ID: "msg_007",
|
|
Type: openairt.MessageItemTypeMessage,
|
|
Status: openairt.ItemStatusInProgress,
|
|
Role: openairt.MessageRoleAssistant,
|
|
Content: []openairt.MessageContentPart{},
|
|
},
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseOutputItemAdded, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseOutputItemAddedEvent))
|
|
}
|
|
|
|
func TestResponseOutputItemDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_3536",
|
|
"type": "response.output_item.done",
|
|
"response_id": "resp_001",
|
|
"output_index": 0,
|
|
"item": {
|
|
"id": "msg_007",
|
|
"object": "realtime.item",
|
|
"type": "message",
|
|
"status": "completed",
|
|
"role": "assistant",
|
|
"content": [
|
|
{
|
|
"type": "text",
|
|
"text": "Sure, I can help with that."
|
|
}
|
|
]
|
|
}
|
|
}`
|
|
expected := openairt.ResponseOutputItemDoneEvent{
|
|
EventID: "event_3536",
|
|
Type: openairt.ServerEventTypeResponseOutputItemDone,
|
|
ResponseID: "resp_001",
|
|
OutputIndex: 0,
|
|
Item: openairt.ResponseMessageItem{
|
|
Object: "realtime.item",
|
|
MessageItem: openairt.MessageItem{
|
|
ID: "msg_007",
|
|
Type: openairt.MessageItemTypeMessage,
|
|
Status: openairt.ItemStatusCompleted,
|
|
Role: openairt.MessageRoleAssistant,
|
|
Content: []openairt.MessageContentPart{
|
|
{
|
|
Type: openairt.MessageContentTypeText,
|
|
Text: "Sure, I can help with that.",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseOutputItemDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseOutputItemDoneEvent))
|
|
}
|
|
|
|
func TestResponseContentPartAddedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_3738",
|
|
"type": "response.content_part.added",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_007",
|
|
"output_index": 1,
|
|
"content_index": 2,
|
|
"part": {
|
|
"type": "text",
|
|
"text": ""
|
|
}
|
|
}`
|
|
expected := openairt.ResponseContentPartAddedEvent{
|
|
EventID: "event_3738",
|
|
Type: openairt.ServerEventTypeResponseContentPartAdded,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_007",
|
|
OutputIndex: 1,
|
|
ContentIndex: 2,
|
|
Part: openairt.MessageContentPart{
|
|
Type: openairt.MessageContentTypeText,
|
|
Text: "",
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseContentPartAdded, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseContentPartAddedEvent))
|
|
}
|
|
|
|
func TestResponseContentPartDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_3940",
|
|
"type": "response.content_part.done",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_007",
|
|
"output_index": 0,
|
|
"content_index": 0,
|
|
"part": {
|
|
"type": "text",
|
|
"text": "Sure, I can help with that."
|
|
}
|
|
}`
|
|
expected := openairt.ResponseContentPartDoneEvent{
|
|
EventID: "event_3940",
|
|
Type: openairt.ServerEventTypeResponseContentPartDone,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_007",
|
|
OutputIndex: 0,
|
|
ContentIndex: 0,
|
|
Part: openairt.MessageContentPart{
|
|
Type: openairt.MessageContentTypeText,
|
|
Text: "Sure, I can help with that.",
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseContentPartDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseContentPartDoneEvent))
|
|
}
|
|
|
|
func TestResponseTextDelta(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_4142",
|
|
"type": "response.text.delta",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_007",
|
|
"output_index": 0,
|
|
"content_index": 0,
|
|
"delta": "Sure, I can h"
|
|
}`
|
|
expected := openairt.ResponseTextDeltaEvent{
|
|
EventID: "event_4142",
|
|
Type: openairt.ServerEventTypeResponseTextDelta,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_007",
|
|
OutputIndex: 0,
|
|
ContentIndex: 0,
|
|
Delta: "Sure, I can h",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseTextDelta, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseTextDeltaEvent))
|
|
}
|
|
|
|
func TestResponseTextDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_4344",
|
|
"type": "response.text.done",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_007",
|
|
"output_index": 0,
|
|
"content_index": 0,
|
|
"text": "Sure, I can help with that."
|
|
}`
|
|
expected := openairt.ResponseTextDoneEvent{
|
|
EventID: "event_4344",
|
|
Type: openairt.ServerEventTypeResponseTextDone,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_007",
|
|
OutputIndex: 0,
|
|
ContentIndex: 0,
|
|
Text: "Sure, I can help with that.",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseTextDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseTextDoneEvent))
|
|
}
|
|
|
|
func TestResponseAudioTranscriptDelta(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_4546",
|
|
"type": "response.audio_transcript.delta",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_008",
|
|
"output_index": 1,
|
|
"content_index": 2,
|
|
"delta": "Hello, how can I a"
|
|
}`
|
|
expected := openairt.ResponseAudioTranscriptDeltaEvent{
|
|
EventID: "event_4546",
|
|
Type: openairt.ServerEventTypeResponseAudioTranscriptDelta,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_008",
|
|
OutputIndex: 1,
|
|
ContentIndex: 2,
|
|
Delta: "Hello, how can I a",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseAudioTranscriptDelta, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseAudioTranscriptDeltaEvent))
|
|
}
|
|
|
|
func TestResponseAudioTranscriptDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_4748",
|
|
"type": "response.audio_transcript.done",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_008",
|
|
"output_index": 0,
|
|
"content_index": 0,
|
|
"transcript": "Hello, how can I assist you today?"
|
|
}`
|
|
expected := openairt.ResponseAudioTranscriptDoneEvent{
|
|
EventID: "event_4748",
|
|
Type: openairt.ServerEventTypeResponseAudioTranscriptDone,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_008",
|
|
OutputIndex: 0,
|
|
ContentIndex: 0,
|
|
Transcript: "Hello, how can I assist you today?",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseAudioTranscriptDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseAudioTranscriptDoneEvent))
|
|
}
|
|
|
|
func TestResponseAudioDeltaEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_4950",
|
|
"type": "response.audio.delta",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_008",
|
|
"output_index": 0,
|
|
"content_index": 0,
|
|
"delta": "Base64EncodedAudioDelta"
|
|
}`
|
|
expected := openairt.ResponseAudioDeltaEvent{
|
|
EventID: "event_4950",
|
|
Type: openairt.ServerEventTypeResponseAudioDelta,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_008",
|
|
OutputIndex: 0,
|
|
ContentIndex: 0,
|
|
Delta: "Base64EncodedAudioDelta",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseAudioDelta, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseAudioDeltaEvent))
|
|
}
|
|
|
|
func TestResponseAudioDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_5152",
|
|
"type": "response.audio.done",
|
|
"response_id": "resp_001",
|
|
"item_id": "msg_008",
|
|
"output_index": 0,
|
|
"content_index": 0
|
|
}`
|
|
expected := openairt.ResponseAudioDoneEvent{
|
|
EventID: "event_5152",
|
|
Type: openairt.ServerEventTypeResponseAudioDone,
|
|
ResponseID: "resp_001",
|
|
ItemID: "msg_008",
|
|
OutputIndex: 0,
|
|
ContentIndex: 0,
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseAudioDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseAudioDoneEvent))
|
|
}
|
|
|
|
func TestResponseFunctionCallArgumentsDelta(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_5354",
|
|
"type": "response.function_call_arguments.delta",
|
|
"response_id": "resp_002",
|
|
"item_id": "fc_001",
|
|
"output_index": 0,
|
|
"call_id": "call_001",
|
|
"delta": "{\"location\": \"San\""
|
|
}`
|
|
expected := openairt.ResponseFunctionCallArgumentsDeltaEvent{
|
|
EventID: "event_5354",
|
|
Type: openairt.ServerEventTypeResponseFunctionCallArgumentsDelta,
|
|
ResponseID: "resp_002",
|
|
ItemID: "fc_001",
|
|
OutputIndex: 0,
|
|
CallID: "call_001",
|
|
Delta: "{\"location\": \"San\"",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseFunctionCallArgumentsDelta, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseFunctionCallArgumentsDeltaEvent))
|
|
}
|
|
|
|
func TestResponseFunctionCallArgumentsDoneEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_5556",
|
|
"type": "response.function_call_arguments.done",
|
|
"response_id": "resp_002",
|
|
"item_id": "fc_001",
|
|
"output_index": 1,
|
|
"call_id": "call_001",
|
|
"arguments": "{\"location\": \"San Francisco\"}"
|
|
}`
|
|
expected := openairt.ResponseFunctionCallArgumentsDoneEvent{
|
|
EventID: "event_5556",
|
|
Type: openairt.ServerEventTypeResponseFunctionCallArgumentsDone,
|
|
ResponseID: "resp_002",
|
|
ItemID: "fc_001",
|
|
OutputIndex: 1,
|
|
CallID: "call_001",
|
|
Arguments: "{\"location\": \"San Francisco\"}",
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeResponseFunctionCallArgumentsDone, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.ResponseFunctionCallArgumentsDoneEvent))
|
|
}
|
|
|
|
func TestRateLimitsUpdatedEvent(t *testing.T) {
|
|
data := `{
|
|
"event_id": "event_5758",
|
|
"type": "rate_limits.updated",
|
|
"rate_limits": [
|
|
{
|
|
"name": "requests",
|
|
"limit": 1000,
|
|
"remaining": 999,
|
|
"reset_seconds": 60.0
|
|
},
|
|
{
|
|
"name": "tokens",
|
|
"limit": 50000,
|
|
"remaining": 49950,
|
|
"reset_seconds": 60.0
|
|
}
|
|
]
|
|
}`
|
|
expected := openairt.RateLimitsUpdatedEvent{
|
|
EventID: "event_5758",
|
|
Type: openairt.ServerEventTypeRateLimitsUpdated,
|
|
RateLimits: []openairt.RateLimit{
|
|
{
|
|
Name: "requests",
|
|
Limit: 1000,
|
|
Remaining: 999,
|
|
ResetSeconds: 60,
|
|
},
|
|
{
|
|
Name: "tokens",
|
|
Limit: 50000,
|
|
Remaining: 49950,
|
|
ResetSeconds: 60,
|
|
},
|
|
},
|
|
}
|
|
actual, err := openairt.UnmarshalServerEvent([]byte(data))
|
|
require.NoError(t, err)
|
|
require.Equal(t, openairt.ServerEventTypeRateLimitsUpdated, actual.ServerEventType())
|
|
require.Equal(t, expected, actual.(openairt.RateLimitsUpdatedEvent))
|
|
}
|