openai 0.129.0 → 0.130.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +7 -0
- data/README.md +1 -1
- data/lib/openai/models/live/fork_server_event.rb +75 -1
- data/lib/openai/models/live/media_session_config.rb +54 -1
- data/lib/openai/models/live/server_event.rb +75 -1
- data/lib/openai/models/live/session_usage.rb +29 -7
- data/lib/openai/models/live/sideband_server_event.rb +75 -1
- data/lib/openai/version.rb +1 -1
- data/rbi/openai/models/live/fork_server_event.rbi +122 -0
- data/rbi/openai/models/live/media_session_config.rbi +90 -3
- data/rbi/openai/models/live/server_event.rbi +122 -0
- data/rbi/openai/models/live/session_usage.rbi +37 -9
- data/rbi/openai/models/live/sideband_server_event.rbi +122 -0
- data/sig/openai/models/live/fork_server_event.rbs +80 -0
- data/sig/openai/models/live/media_session_config.rbs +63 -3
- data/sig/openai/models/live/server_event.rbs +80 -0
- data/sig/openai/models/live/session_usage.rbs +38 -7
- data/sig/openai/models/live/sideband_server_event.rbs +80 -0
- metadata +1 -1
|
@@ -51,6 +51,15 @@ module OpenAI
|
|
|
51
51
|
}
|
|
52
52
|
attr_accessor :delegation
|
|
53
53
|
|
|
54
|
+
# Whole seconds of inactivity after which a Live WebRTC session with a speech wake
|
|
55
|
+
# policy pauses inference. The connection and conversation history are retained.
|
|
56
|
+
# Omit to keep inference active until the session ends.
|
|
57
|
+
sig { returns(T.nilable(Integer)) }
|
|
58
|
+
attr_reader :idle_timeout_s
|
|
59
|
+
|
|
60
|
+
sig { params(idle_timeout_s: Integer).void }
|
|
61
|
+
attr_writer :idle_timeout_s
|
|
62
|
+
|
|
54
63
|
# Ordered text-only history supplied before startup. Supports developer, user, and
|
|
55
64
|
# assistant messages with one text part each; at most 128 messages and a
|
|
56
65
|
# configured rendered-token limit (8,192 by default).
|
|
@@ -116,6 +125,14 @@ module OpenAI
|
|
|
116
125
|
sig { params(triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash]).void }
|
|
117
126
|
attr_writer :triggers
|
|
118
127
|
|
|
128
|
+
# Inference starts when the Live WebRTC session connects. After an idle pause,
|
|
129
|
+
# microphone speech resumes inference.
|
|
130
|
+
sig { returns(T.nilable(OpenAI::Live::MediaSessionConfig::WakePolicy)) }
|
|
131
|
+
attr_reader :wake_policy
|
|
132
|
+
|
|
133
|
+
sig { params(wake_policy: OpenAI::Live::MediaSessionConfig::WakePolicy::OrHash).void }
|
|
134
|
+
attr_writer :wake_policy
|
|
135
|
+
|
|
119
136
|
# Startup configuration for a Live media session. Follow the
|
|
120
137
|
# [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
|
|
121
138
|
# when writing frontend instructions and the backend prompt under
|
|
@@ -137,6 +154,8 @@ module OpenAI
|
|
|
137
154
|
)
|
|
138
155
|
),
|
|
139
156
|
|
|
157
|
+
idle_timeout_s: Integer,
|
|
158
|
+
|
|
140
159
|
input: T::Array[
|
|
141
160
|
T.any(
|
|
142
161
|
OpenAI::Live::InitialItem::Developer::OrHash,
|
|
@@ -151,7 +170,9 @@ module OpenAI
|
|
|
151
170
|
|
|
152
171
|
store: T::Boolean,
|
|
153
172
|
|
|
154
|
-
triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash]
|
|
173
|
+
triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash],
|
|
174
|
+
|
|
175
|
+
wake_policy: OpenAI::Live::MediaSessionConfig::WakePolicy::OrHash
|
|
155
176
|
)
|
|
156
177
|
.returns(T.attached_class)
|
|
157
178
|
end
|
|
@@ -174,6 +195,11 @@ module OpenAI
|
|
|
174
195
|
# API.
|
|
175
196
|
delegation: nil,
|
|
176
197
|
|
|
198
|
+
# Whole seconds of inactivity after which a Live WebRTC session with a speech wake
|
|
199
|
+
# policy pauses inference. The connection and conversation history are retained.
|
|
200
|
+
# Omit to keep inference active until the session ends.
|
|
201
|
+
idle_timeout_s: nil,
|
|
202
|
+
|
|
177
203
|
# Ordered text-only history supplied before startup. Supports developer, user, and
|
|
178
204
|
# assistant messages with one text part each; at most 128 messages and a
|
|
179
205
|
# configured rendered-token limit (8,192 by default).
|
|
@@ -200,8 +226,12 @@ module OpenAI
|
|
|
200
226
|
# independently of delegation. On update, omit triggers to keep the current
|
|
201
227
|
# configuration, send a list to replace it, or send an empty list to disable
|
|
202
228
|
# triggers.
|
|
229
|
+
triggers: nil,
|
|
230
|
+
|
|
231
|
+
# Inference starts when the Live WebRTC session connects. After an idle pause,
|
|
232
|
+
# microphone speech resumes inference.
|
|
203
233
|
|
|
204
|
-
|
|
234
|
+
wake_policy: nil
|
|
205
235
|
)
|
|
206
236
|
end
|
|
207
237
|
|
|
@@ -218,6 +248,7 @@ module OpenAI
|
|
|
218
248
|
OpenAI::Live::MediaSessionConfig::Delegation::Decisions
|
|
219
249
|
)
|
|
220
250
|
),
|
|
251
|
+
idle_timeout_s: Integer,
|
|
221
252
|
input: T::Array[
|
|
222
253
|
T.any(
|
|
223
254
|
OpenAI::Live::InitialItem::Developer,
|
|
@@ -228,7 +259,8 @@ module OpenAI
|
|
|
228
259
|
instructions: T.nilable(String),
|
|
229
260
|
safety_identifier: T.nilable(String),
|
|
230
261
|
store: T::Boolean,
|
|
231
|
-
triggers: T::Array[OpenAI::Live::DecisionTrigger]
|
|
262
|
+
triggers: T::Array[OpenAI::Live::DecisionTrigger],
|
|
263
|
+
wake_policy: OpenAI::Live::MediaSessionConfig::WakePolicy
|
|
232
264
|
}
|
|
233
265
|
)
|
|
234
266
|
end
|
|
@@ -518,6 +550,61 @@ module OpenAI
|
|
|
518
550
|
|
|
519
551
|
end
|
|
520
552
|
|
|
553
|
+
class WakePolicy < OpenAI::Internal::Type::BaseModel
|
|
554
|
+
OrHash = T.type_alias do
|
|
555
|
+
T.any(
|
|
556
|
+
OpenAI::Live::MediaSessionConfig::WakePolicy,
|
|
557
|
+
OpenAI::Internal::AnyHash
|
|
558
|
+
)
|
|
559
|
+
end
|
|
560
|
+
|
|
561
|
+
# The wake policy type, always `speech`.
|
|
562
|
+
sig { returns(Symbol) }
|
|
563
|
+
attr_accessor :type
|
|
564
|
+
|
|
565
|
+
# The speech detection threshold for resuming paused inference, from 0 to 1
|
|
566
|
+
# inclusive. Defaults to 0.5. Higher values require stronger evidence of speech.
|
|
567
|
+
# This setting is independent of active turn detection.
|
|
568
|
+
sig { returns(T.nilable(Float)) }
|
|
569
|
+
attr_reader :vad_threshold
|
|
570
|
+
|
|
571
|
+
sig { params(vad_threshold: Float).void }
|
|
572
|
+
attr_writer :vad_threshold
|
|
573
|
+
|
|
574
|
+
# Inference starts when the Live WebRTC session connects. After an idle pause,
|
|
575
|
+
# microphone speech resumes inference.
|
|
576
|
+
sig do
|
|
577
|
+
params(
|
|
578
|
+
|
|
579
|
+
vad_threshold: Float,
|
|
580
|
+
|
|
581
|
+
type: Symbol
|
|
582
|
+
)
|
|
583
|
+
.returns(T.attached_class)
|
|
584
|
+
end
|
|
585
|
+
def self.new(
|
|
586
|
+
|
|
587
|
+
# The speech detection threshold for resuming paused inference, from 0 to 1
|
|
588
|
+
# inclusive. Defaults to 0.5. Higher values require stronger evidence of speech.
|
|
589
|
+
# This setting is independent of active turn detection.
|
|
590
|
+
vad_threshold: nil,
|
|
591
|
+
|
|
592
|
+
# The wake policy type, always `speech`.
|
|
593
|
+
|
|
594
|
+
type: :speech
|
|
595
|
+
)
|
|
596
|
+
end
|
|
597
|
+
|
|
598
|
+
sig do
|
|
599
|
+
override.returns(
|
|
600
|
+
{type: Symbol, vad_threshold: Float}
|
|
601
|
+
)
|
|
602
|
+
end
|
|
603
|
+
def to_hash
|
|
604
|
+
end
|
|
605
|
+
|
|
606
|
+
end
|
|
607
|
+
|
|
521
608
|
end
|
|
522
609
|
|
|
523
610
|
end
|
|
@@ -17,6 +17,8 @@ module OpenAI
|
|
|
17
17
|
T.any(
|
|
18
18
|
OpenAI::Live::SessionStartedEvent,
|
|
19
19
|
OpenAI::Live::SessionUpdatedEvent,
|
|
20
|
+
OpenAI::Live::ServerEvent::SessionResumed,
|
|
21
|
+
OpenAI::Live::ServerEvent::SessionPaused,
|
|
20
22
|
OpenAI::Live::InputAudioMutedEvent,
|
|
21
23
|
OpenAI::Live::InputAudioUnmutedEvent,
|
|
22
24
|
OpenAI::Live::OutputAudioFixturePlayingEvent,
|
|
@@ -46,6 +48,126 @@ module OpenAI
|
|
|
46
48
|
)
|
|
47
49
|
end
|
|
48
50
|
|
|
51
|
+
class SessionResumed < OpenAI::Internal::Type::BaseModel
|
|
52
|
+
OrHash = T.type_alias do
|
|
53
|
+
T.any(
|
|
54
|
+
OpenAI::Live::ServerEvent::SessionResumed,
|
|
55
|
+
OpenAI::Internal::AnyHash
|
|
56
|
+
)
|
|
57
|
+
end
|
|
58
|
+
|
|
59
|
+
# The unique ID of the Live server event.
|
|
60
|
+
sig { returns(String) }
|
|
61
|
+
attr_accessor :event_id
|
|
62
|
+
|
|
63
|
+
sig { returns(Symbol) }
|
|
64
|
+
attr_accessor :type
|
|
65
|
+
|
|
66
|
+
# The event_id of the client command associated with this server event, when
|
|
67
|
+
# supplied.
|
|
68
|
+
sig { returns(T.nilable(String)) }
|
|
69
|
+
attr_reader :client_event_id
|
|
70
|
+
|
|
71
|
+
sig { params(client_event_id: String).void }
|
|
72
|
+
attr_writer :client_event_id
|
|
73
|
+
|
|
74
|
+
# Sent when speech resumes paused inference and it is ready for audio in a Live
|
|
75
|
+
# WebRTC session. Delivered to the sideband and, when permitted by its event
|
|
76
|
+
# settings, the data channel.
|
|
77
|
+
sig do
|
|
78
|
+
params(
|
|
79
|
+
|
|
80
|
+
event_id: String,
|
|
81
|
+
|
|
82
|
+
client_event_id: String,
|
|
83
|
+
|
|
84
|
+
type: Symbol
|
|
85
|
+
)
|
|
86
|
+
.returns(T.attached_class)
|
|
87
|
+
end
|
|
88
|
+
def self.new(
|
|
89
|
+
|
|
90
|
+
# The unique ID of the Live server event.
|
|
91
|
+
event_id:,
|
|
92
|
+
|
|
93
|
+
# The event_id of the client command associated with this server event, when
|
|
94
|
+
# supplied.
|
|
95
|
+
client_event_id: nil,
|
|
96
|
+
|
|
97
|
+
type: :"session.resumed"
|
|
98
|
+
)
|
|
99
|
+
end
|
|
100
|
+
|
|
101
|
+
sig do
|
|
102
|
+
override.returns(
|
|
103
|
+
{event_id: String, type: Symbol, client_event_id: T.nilable(String)}
|
|
104
|
+
)
|
|
105
|
+
end
|
|
106
|
+
def to_hash
|
|
107
|
+
end
|
|
108
|
+
|
|
109
|
+
end
|
|
110
|
+
|
|
111
|
+
class SessionPaused < OpenAI::Internal::Type::BaseModel
|
|
112
|
+
OrHash = T.type_alias do
|
|
113
|
+
T.any(
|
|
114
|
+
OpenAI::Live::ServerEvent::SessionPaused,
|
|
115
|
+
OpenAI::Internal::AnyHash
|
|
116
|
+
)
|
|
117
|
+
end
|
|
118
|
+
|
|
119
|
+
# The unique ID of the Live server event.
|
|
120
|
+
sig { returns(String) }
|
|
121
|
+
attr_accessor :event_id
|
|
122
|
+
|
|
123
|
+
sig { returns(Symbol) }
|
|
124
|
+
attr_accessor :type
|
|
125
|
+
|
|
126
|
+
# The event_id of the client command associated with this server event, when
|
|
127
|
+
# supplied.
|
|
128
|
+
sig { returns(T.nilable(String)) }
|
|
129
|
+
attr_reader :client_event_id
|
|
130
|
+
|
|
131
|
+
sig { params(client_event_id: String).void }
|
|
132
|
+
attr_writer :client_event_id
|
|
133
|
+
|
|
134
|
+
# Sent when the idle timeout pauses inference in a Live WebRTC session. The WebRTC
|
|
135
|
+
# connection, sideband, and session ID persist. Delivered to the sideband and,
|
|
136
|
+
# when permitted by its event settings, the data channel.
|
|
137
|
+
sig do
|
|
138
|
+
params(
|
|
139
|
+
|
|
140
|
+
event_id: String,
|
|
141
|
+
|
|
142
|
+
client_event_id: String,
|
|
143
|
+
|
|
144
|
+
type: Symbol
|
|
145
|
+
)
|
|
146
|
+
.returns(T.attached_class)
|
|
147
|
+
end
|
|
148
|
+
def self.new(
|
|
149
|
+
|
|
150
|
+
# The unique ID of the Live server event.
|
|
151
|
+
event_id:,
|
|
152
|
+
|
|
153
|
+
# The event_id of the client command associated with this server event, when
|
|
154
|
+
# supplied.
|
|
155
|
+
client_event_id: nil,
|
|
156
|
+
|
|
157
|
+
type: :"session.paused"
|
|
158
|
+
)
|
|
159
|
+
end
|
|
160
|
+
|
|
161
|
+
sig do
|
|
162
|
+
override.returns(
|
|
163
|
+
{event_id: String, type: Symbol, client_event_id: T.nilable(String)}
|
|
164
|
+
)
|
|
165
|
+
end
|
|
166
|
+
def to_hash
|
|
167
|
+
end
|
|
168
|
+
|
|
169
|
+
end
|
|
170
|
+
|
|
49
171
|
class SessionInputAudioAppend < OpenAI::Internal::Type::BaseModel
|
|
50
172
|
OrHash = T.type_alias do
|
|
51
173
|
T.any(
|
|
@@ -14,32 +14,60 @@ module OpenAI
|
|
|
14
14
|
)
|
|
15
15
|
end
|
|
16
16
|
|
|
17
|
-
# The cumulative
|
|
18
|
-
#
|
|
17
|
+
# The cumulative billable duration in whole seconds. When present, the active and
|
|
18
|
+
# paused breakdown adds up to this total.
|
|
19
19
|
sig { returns(Float) }
|
|
20
20
|
attr_accessor :seconds
|
|
21
21
|
|
|
22
|
-
#
|
|
23
|
-
#
|
|
22
|
+
# The remaining billable seconds attributed to active audio and any unused prepaid
|
|
23
|
+
# duration.
|
|
24
|
+
sig { returns(T.nilable(Integer)) }
|
|
25
|
+
attr_reader :active_seconds
|
|
26
|
+
|
|
27
|
+
sig { params(active_seconds: Integer).void }
|
|
28
|
+
attr_writer :active_seconds
|
|
29
|
+
|
|
30
|
+
# Billable time attributed to paused inference at the configured rate, rounded
|
|
31
|
+
# down to whole seconds.
|
|
32
|
+
sig { returns(T.nilable(Integer)) }
|
|
33
|
+
attr_reader :paused_seconds
|
|
34
|
+
|
|
35
|
+
sig { params(paused_seconds: Integer).void }
|
|
36
|
+
attr_writer :paused_seconds
|
|
37
|
+
|
|
38
|
+
# Cumulative billable duration for a Live session. Eligible WebRTC sessions also
|
|
39
|
+
# report the active and paused breakdown. Do not sum values across usage events.
|
|
24
40
|
sig do
|
|
25
41
|
params(
|
|
26
42
|
|
|
27
|
-
seconds: Float
|
|
43
|
+
seconds: Float,
|
|
44
|
+
|
|
45
|
+
active_seconds: Integer,
|
|
46
|
+
|
|
47
|
+
paused_seconds: Integer
|
|
28
48
|
)
|
|
29
49
|
.returns(T.attached_class)
|
|
30
50
|
end
|
|
31
51
|
def self.new(
|
|
32
52
|
|
|
33
|
-
# The cumulative
|
|
34
|
-
#
|
|
53
|
+
# The cumulative billable duration in whole seconds. When present, the active and
|
|
54
|
+
# paused breakdown adds up to this total.
|
|
55
|
+
seconds:,
|
|
56
|
+
|
|
57
|
+
# The remaining billable seconds attributed to active audio and any unused prepaid
|
|
58
|
+
# duration.
|
|
59
|
+
active_seconds: nil,
|
|
60
|
+
|
|
61
|
+
# Billable time attributed to paused inference at the configured rate, rounded
|
|
62
|
+
# down to whole seconds.
|
|
35
63
|
|
|
36
|
-
|
|
64
|
+
paused_seconds: nil
|
|
37
65
|
)
|
|
38
66
|
end
|
|
39
67
|
|
|
40
68
|
sig do
|
|
41
69
|
override.returns(
|
|
42
|
-
{seconds: Float}
|
|
70
|
+
{seconds: Float, active_seconds: Integer, paused_seconds: Integer}
|
|
43
71
|
)
|
|
44
72
|
end
|
|
45
73
|
def to_hash
|
|
@@ -14,6 +14,8 @@ module OpenAI
|
|
|
14
14
|
T.any(
|
|
15
15
|
OpenAI::Live::SessionStartedEvent,
|
|
16
16
|
OpenAI::Live::SessionUpdatedEvent,
|
|
17
|
+
OpenAI::Live::SidebandServerEvent::SessionResumed,
|
|
18
|
+
OpenAI::Live::SidebandServerEvent::SessionPaused,
|
|
17
19
|
OpenAI::Live::InputAudioMutedEvent,
|
|
18
20
|
OpenAI::Live::InputAudioUnmutedEvent,
|
|
19
21
|
OpenAI::Live::OutputAudioFixturePlayingEvent,
|
|
@@ -43,6 +45,126 @@ module OpenAI
|
|
|
43
45
|
)
|
|
44
46
|
end
|
|
45
47
|
|
|
48
|
+
class SessionResumed < OpenAI::Internal::Type::BaseModel
|
|
49
|
+
OrHash = T.type_alias do
|
|
50
|
+
T.any(
|
|
51
|
+
OpenAI::Live::SidebandServerEvent::SessionResumed,
|
|
52
|
+
OpenAI::Internal::AnyHash
|
|
53
|
+
)
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
# The unique ID of the Live server event.
|
|
57
|
+
sig { returns(String) }
|
|
58
|
+
attr_accessor :event_id
|
|
59
|
+
|
|
60
|
+
sig { returns(Symbol) }
|
|
61
|
+
attr_accessor :type
|
|
62
|
+
|
|
63
|
+
# The event_id of the client command associated with this server event, when
|
|
64
|
+
# supplied.
|
|
65
|
+
sig { returns(T.nilable(String)) }
|
|
66
|
+
attr_reader :client_event_id
|
|
67
|
+
|
|
68
|
+
sig { params(client_event_id: String).void }
|
|
69
|
+
attr_writer :client_event_id
|
|
70
|
+
|
|
71
|
+
# Sent when speech resumes paused inference and it is ready for audio in a Live
|
|
72
|
+
# WebRTC session. Delivered to the sideband and, when permitted by its event
|
|
73
|
+
# settings, the data channel.
|
|
74
|
+
sig do
|
|
75
|
+
params(
|
|
76
|
+
|
|
77
|
+
event_id: String,
|
|
78
|
+
|
|
79
|
+
client_event_id: String,
|
|
80
|
+
|
|
81
|
+
type: Symbol
|
|
82
|
+
)
|
|
83
|
+
.returns(T.attached_class)
|
|
84
|
+
end
|
|
85
|
+
def self.new(
|
|
86
|
+
|
|
87
|
+
# The unique ID of the Live server event.
|
|
88
|
+
event_id:,
|
|
89
|
+
|
|
90
|
+
# The event_id of the client command associated with this server event, when
|
|
91
|
+
# supplied.
|
|
92
|
+
client_event_id: nil,
|
|
93
|
+
|
|
94
|
+
type: :"session.resumed"
|
|
95
|
+
)
|
|
96
|
+
end
|
|
97
|
+
|
|
98
|
+
sig do
|
|
99
|
+
override.returns(
|
|
100
|
+
{event_id: String, type: Symbol, client_event_id: T.nilable(String)}
|
|
101
|
+
)
|
|
102
|
+
end
|
|
103
|
+
def to_hash
|
|
104
|
+
end
|
|
105
|
+
|
|
106
|
+
end
|
|
107
|
+
|
|
108
|
+
class SessionPaused < OpenAI::Internal::Type::BaseModel
|
|
109
|
+
OrHash = T.type_alias do
|
|
110
|
+
T.any(
|
|
111
|
+
OpenAI::Live::SidebandServerEvent::SessionPaused,
|
|
112
|
+
OpenAI::Internal::AnyHash
|
|
113
|
+
)
|
|
114
|
+
end
|
|
115
|
+
|
|
116
|
+
# The unique ID of the Live server event.
|
|
117
|
+
sig { returns(String) }
|
|
118
|
+
attr_accessor :event_id
|
|
119
|
+
|
|
120
|
+
sig { returns(Symbol) }
|
|
121
|
+
attr_accessor :type
|
|
122
|
+
|
|
123
|
+
# The event_id of the client command associated with this server event, when
|
|
124
|
+
# supplied.
|
|
125
|
+
sig { returns(T.nilable(String)) }
|
|
126
|
+
attr_reader :client_event_id
|
|
127
|
+
|
|
128
|
+
sig { params(client_event_id: String).void }
|
|
129
|
+
attr_writer :client_event_id
|
|
130
|
+
|
|
131
|
+
# Sent when the idle timeout pauses inference in a Live WebRTC session. The WebRTC
|
|
132
|
+
# connection, sideband, and session ID persist. Delivered to the sideband and,
|
|
133
|
+
# when permitted by its event settings, the data channel.
|
|
134
|
+
sig do
|
|
135
|
+
params(
|
|
136
|
+
|
|
137
|
+
event_id: String,
|
|
138
|
+
|
|
139
|
+
client_event_id: String,
|
|
140
|
+
|
|
141
|
+
type: Symbol
|
|
142
|
+
)
|
|
143
|
+
.returns(T.attached_class)
|
|
144
|
+
end
|
|
145
|
+
def self.new(
|
|
146
|
+
|
|
147
|
+
# The unique ID of the Live server event.
|
|
148
|
+
event_id:,
|
|
149
|
+
|
|
150
|
+
# The event_id of the client command associated with this server event, when
|
|
151
|
+
# supplied.
|
|
152
|
+
client_event_id: nil,
|
|
153
|
+
|
|
154
|
+
type: :"session.paused"
|
|
155
|
+
)
|
|
156
|
+
end
|
|
157
|
+
|
|
158
|
+
sig do
|
|
159
|
+
override.returns(
|
|
160
|
+
{event_id: String, type: Symbol, client_event_id: T.nilable(String)}
|
|
161
|
+
)
|
|
162
|
+
end
|
|
163
|
+
def to_hash
|
|
164
|
+
end
|
|
165
|
+
|
|
166
|
+
end
|
|
167
|
+
|
|
46
168
|
class SessionInputAudioAppend < OpenAI::Internal::Type::BaseModel
|
|
47
169
|
OrHash = T.type_alias do
|
|
48
170
|
T.any(
|
|
@@ -4,6 +4,8 @@ module OpenAI
|
|
|
4
4
|
type fork_server_event =
|
|
5
5
|
OpenAI::Live::SessionStartedEvent
|
|
6
6
|
| OpenAI::Live::SessionUpdatedEvent
|
|
7
|
+
| OpenAI::Live::ForkServerEvent::SessionResumed
|
|
8
|
+
| OpenAI::Live::ForkServerEvent::SessionPaused
|
|
7
9
|
| OpenAI::Live::InputAudioMutedEvent
|
|
8
10
|
| OpenAI::Live::InputAudioUnmutedEvent
|
|
9
11
|
| OpenAI::Live::OutputAudioFixturePlayingEvent
|
|
@@ -34,6 +36,84 @@ module OpenAI
|
|
|
34
36
|
module ForkServerEvent
|
|
35
37
|
extend OpenAI::Internal::Type::Union
|
|
36
38
|
|
|
39
|
+
type session_resumed =
|
|
40
|
+
{
|
|
41
|
+
event_id: String,
|
|
42
|
+
?type: :"session.resumed",
|
|
43
|
+
?client_event_id: String
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
class SessionResumed < OpenAI::Internal::Type::BaseModel
|
|
47
|
+
# The unique ID of the Live server event.
|
|
48
|
+
attr_accessor event_id: String
|
|
49
|
+
|
|
50
|
+
attr_accessor type: :"session.resumed"
|
|
51
|
+
|
|
52
|
+
# The event_id of the client command associated with this server event, when
|
|
53
|
+
# supplied.
|
|
54
|
+
attr_reader client_event_id: String?
|
|
55
|
+
|
|
56
|
+
# The event_id of the client command associated with this server event, when
|
|
57
|
+
# supplied.
|
|
58
|
+
def client_event_id=: (String) -> String
|
|
59
|
+
|
|
60
|
+
# @param event_id
|
|
61
|
+
# The unique ID of the Live server event.
|
|
62
|
+
# @param client_event_id
|
|
63
|
+
# The event_id of the client command associated with this server event, when
|
|
64
|
+
# supplied.
|
|
65
|
+
def initialize: (
|
|
66
|
+
event_id: String,
|
|
67
|
+
?client_event_id: String,
|
|
68
|
+
?type: :"session.resumed"
|
|
69
|
+
) -> void
|
|
70
|
+
|
|
71
|
+
def to_hash: -> {
|
|
72
|
+
event_id: String,
|
|
73
|
+
?type: :"session.resumed",
|
|
74
|
+
?client_event_id: String
|
|
75
|
+
}
|
|
76
|
+
end
|
|
77
|
+
|
|
78
|
+
type session_paused =
|
|
79
|
+
{
|
|
80
|
+
event_id: String,
|
|
81
|
+
?type: :"session.paused",
|
|
82
|
+
?client_event_id: String
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
class SessionPaused < OpenAI::Internal::Type::BaseModel
|
|
86
|
+
# The unique ID of the Live server event.
|
|
87
|
+
attr_accessor event_id: String
|
|
88
|
+
|
|
89
|
+
attr_accessor type: :"session.paused"
|
|
90
|
+
|
|
91
|
+
# The event_id of the client command associated with this server event, when
|
|
92
|
+
# supplied.
|
|
93
|
+
attr_reader client_event_id: String?
|
|
94
|
+
|
|
95
|
+
# The event_id of the client command associated with this server event, when
|
|
96
|
+
# supplied.
|
|
97
|
+
def client_event_id=: (String) -> String
|
|
98
|
+
|
|
99
|
+
# @param event_id
|
|
100
|
+
# The unique ID of the Live server event.
|
|
101
|
+
# @param client_event_id
|
|
102
|
+
# The event_id of the client command associated with this server event, when
|
|
103
|
+
# supplied.
|
|
104
|
+
def initialize: (
|
|
105
|
+
event_id: String,
|
|
106
|
+
?client_event_id: String,
|
|
107
|
+
?type: :"session.paused"
|
|
108
|
+
) -> void
|
|
109
|
+
|
|
110
|
+
def to_hash: -> {
|
|
111
|
+
event_id: String,
|
|
112
|
+
?type: :"session.paused",
|
|
113
|
+
?client_event_id: String
|
|
114
|
+
}
|
|
115
|
+
end
|
|
116
|
+
|
|
37
117
|
type session_input_audio_append =
|
|
38
118
|
{ audio: String, ?type: :"session.input_audio.append" }
|
|
39
119
|
|