15 15
16Set `model` to `gpt-6-astra` or `gpt-6.1-sol` and `service_tier` to `ultrafast` in each `response.create` event.16Set `model` to `gpt-6-astra` or `gpt-6.1-sol` and `service_tier` to `ultrafast` in each `response.create` event.
17 17
18Install your language's SDK and WebSocket dependencies as described in [Connect and create responses](https://developers.openai.com/api/docs/guides/websocket-mode#connect-and-create-responses). Set `OPENAI_API_KEY` in your environment before running the example.
19
18Use Ultrafast across turns on one WebSocket20Use Ultrafast across turns on one WebSocket
19 21
20```javascript22```javascript
105 raise RuntimeError("Connection closed before the response finished.")111 raise RuntimeError("Connection closed before the response finished.")
106```112```
107 113
114```go
115package main
116
117import (
118 "context"
119 "fmt"
120 "time"
121
122 "github.com/openai/openai-go/v3"
123 "github.com/openai/openai-go/v3/responses"
124)
125
126func main() {
127 ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
128 defer cancel()
129
130 client := openai.NewClient()
131 conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})
132 if err != nil {
133 panic(err)
134 }
135 defer conn.Close()
136
137 previousResponseID := ""
138
139 for _, prompt := range []string{
140 "Explain why the sky is blue in one sentence.",
141 "Now explain why sunsets look red.",
142 } {
143 request := responses.ResponsesClientEventResponseCreateParam{
144 Model: "gpt-6-astra",
145 ServiceTier: "ultrafast",
146 Input: responses.ResponsesClientEventResponseCreateInputUnionParam{
147 OfString: openai.String(prompt),
148 },
149 }
150 if previousResponseID != "" {
151 request.PreviousResponseID = openai.String(previousResponseID)
152 }
153
154 if err := conn.Create(ctx, request); err != nil {
155 panic(err)
156 }
157
158 // FinalResponse reads events until the response finishes.
159 response, err := conn.FinalResponse(ctx)
160 if err != nil {
161 panic(err)
162 }
163 if response.Status != responses.ResponseStatusCompleted {
164 panic(fmt.Sprintf("Response ended with status %s", response.Status))
165 }
166
167 previousResponseID = response.ID
168 fmt.Println(response.OutputText())
169 }
170}
171```
172
173```java
174import com.openai.client.okhttp.OpenAIOkHttpClient;
175import com.openai.models.responses.ResponseStatus;
176import com.openai.models.responses.ResponsesClientEvent;
177import java.util.List;
178
179var client = OpenAIOkHttpClient.fromEnv();
180
181try (var connection = client.responses().connect()) {
182 String previousResponseId = null;
183
184 for (var prompt :
185 List.of(
186 "Explain why the sky is blue in one sentence.",
187 "Now explain why sunsets look red.")) {
188 var request =
189 ResponsesClientEvent.ResponseCreate.builder()
190 .model("gpt-6-astra")
191 .serviceTier(ResponsesClientEvent.ResponseCreate.ServiceTier.ULTRAFAST)
192 .input(prompt);
193 if (previousResponseId != null) {
194 request.previousResponseId(previousResponseId);
195 }
108 196
109The example streams two responses over the same connection. The second request sends the new prompt and passes the first response's ID as `previous_response_id`. Reuse the connection for later turns and tool results. See [Continue with incremental inputs](https://developers.openai.com/api/docs/guides/websocket-mode#continue-with-incremental-inputs).197 connection.send(ResponsesClientEvent.ofResponseCreate(request.build()));
198
199 var response = connection.finalResponse();
200 if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
201 throw new IllegalStateException(
202 "Response ended with status " + response.status().orElse(null));
203 }
204
205 previousResponseId = response.id();
206 response.output().stream()
207 .flatMap(item -> item.message().stream())
208 .flatMap(message -> message.content().stream())
209 .flatMap(content -> content.outputText().stream())
210 .forEach(text -> System.out.println(text.text()));
211 }
212} finally {
213 client.close();
214}
215```
216
217```ruby
218# Install: gem install openai async-websocket
219# Set OPENAI_API_KEY in your environment.
220
221require "async"
222require "openai"
223
224client = OpenAI::Client.new
225
226request = {
227 model: "gpt-6-astra",
228 service_tier: :ultrafast
229}
230prompts = [
231 "Explain why the sky is blue in one sentence.",
232 "Now explain why sunsets look red."
233]
234
235Sync do |task|
236 task.with_timeout(120) do
237 client.responses.connect(request_options: { timeout: 10 }) do |connection|
238 prompts.each do |prompt|
239 connection.response.create(**request, input: prompt)
240
241 loop do
242 event = connection.receive
243 raise "Connection closed before the response finished" unless event
244
245 case event
246 when OpenAI::Responses::ResponseCompletedEvent
247 request[:previous_response_id] = event.response.id
248 puts(event.response.output_text)
249 break
250 when OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponseIncompleteEvent,
251 OpenAI::Responses::ResponsesServerEvent::ResponseWsError
252 raise "Response failed: #{event.to_json}"
253 end
254 end
255 end
256 end
257 end
258end
259```
260
261
262The examples send two requests over the same connection and print each response. The Go, Java, and Ruby examples wait for the complete response before printing it. The second request sends the new prompt and passes the first response's ID as `previous_response_id`. Reuse the connection for later turns and tool results. See [Continue with incremental inputs](https://developers.openai.com/api/docs/guides/websocket-mode#continue-with-incremental-inputs).
110 263
111## HTTP alternative264## HTTP alternative
112 265
142```296```
143 297
144```go298```go
145client := openai.NewClient()299package main
146response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{300
301import (
302 "context"
303 "fmt"
304
305 "github.com/openai/openai-go/v3"
306 "github.com/openai/openai-go/v3/responses"
307)
308
309func main() {
310 client := openai.NewClient()
311
312 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
147 Model: "gpt-6-astra",313 Model: "gpt-6-astra",
148 ServiceTier: responses.ResponseNewParamsServiceTierUltrafast,314 ServiceTier: responses.ResponseNewParamsServiceTierUltrafast,
149 Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain why the sky is blue in one sentence.")},315 Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain why the sky is blue in one sentence.")},
150})316 })
151if err != nil {317 if err != nil {
152 panic(err)318 panic(err)
319 }
320
321 fmt.Println(response.OutputText())
153}322}
154fmt.Println(response.OutputText())
155```323```
156 324
157```java325```java
