Documentation 2026-10-05 22:59 UTC to 2026-10-06 22:58 UTC

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

22 22 

23### Resolve upload errors23### Resolve upload errors

24 24 

25File checks during session creation or file attachment can return HTTP 429 with

26`files_api_rate_limit_exceeded`. See [Files API rate limits](https://developers.openai.com/api/docs/guides/agents-api/errors#files-api-rate-limits)

27for the response and recovery steps.

28 

25For HTTP 400, use `error.param` and `error.message` to identify the input to correct.29For HTTP 400, use `error.param` and `error.message` to identify the input to correct.

26For example, a destination outside `/workspace` returns:30For example, a destination outside `/workspace` returns:

27 31 

12 12 

13## Configure the sandbox13## Configure the sandbox

14 14 

15Set `environment.type` to `openai_hosted` and add only the settings your workload15Set `environment.type` to `openai_hosted` in your create-session request. Add

16needs. The working directory is `/workspace`.16only the settings your workload needs. The sandbox's working directory is

17`/workspace`.

18 

19Choose the resources and network access your task needs with `container_size`

20and `network`. If you use an environment template, omitted settings inherit the

21template.

22 

23### Prepare packages and files

24 

25Use these settings to make dependencies and inputs available in the sandbox:

17 26 

18- `packages`: Install Python, system, or global `npm` packages with `python`, `system`, or `npm` lists. Pin versions when needed, such as `pandas==2.2.3`.27- `packages`: Install Python, system, or global `npm` packages with `python`, `system`, or `npm` lists. Pin versions when needed, such as `pandas==2.2.3`.

19- `setup_commands`: Run ordered shell commands before the agent starts, such as `[{ "command": "mkdir -p reports" }]`. Each command has its own optional `cwd`, defaulting to `/workspace`.

20- `files`: [Supply input files](https://developers.openai.com/api/docs/guides/agents-api/environments/files#upload-files) by Files API ID or inline base64 content.28- `files`: [Supply input files](https://developers.openai.com/api/docs/guides/agents-api/environments/files#upload-files) by Files API ID or inline base64 content.

21- `env`: Set string-valued environment variables. Agent-generated code can read these values. IMPORTANT: For secrets, use [vault credentials](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults#use-vault-secrets-for-api-requests-from-a-sandbox) to keep the real values outside the sandbox. Runtime-reserved names, including `PATH`, `CODEX_*`, and `OPENAI_API_KEY`, are rejected.

22- `skills`, `plugins`, `capability_directories`: Add [skills](https://developers.openai.com/api/docs/guides/tools-skills#agents-api) and [plugins](https://developers.openai.com/api/docs/guides/agents-api/tools/plugins).

23- `environment_template_id`: [Reuse saved configuration](https://developers.openai.com/api/docs/guides/agents-api/tools/plugins#reuse-a-hosted-plugin-setup) across sessions. Omitted settings inherit the template; network overrides cannot broaden its policy.

24 29 

25Packages and input files are prepared before setup commands run. A nonzero setup30### Run setup commands

26exit status prevents the agent from starting. Use a setup command to check required31 

27dependencies or files. Templates save configuration, not a running workspace.32Use `setup_commands` to run shell commands in order before the agent starts. For

33example, `[{ "command": "mkdir -p reports" }]` creates a directory. Each command

34can set its own `cwd`; the default is `/workspace`.

35 

36Packages and input files are prepared before setup commands run. Use a setup

37command to check required dependencies or files. A nonzero setup exit status

38prevents the agent from starting.

39 

40### Set environment variables

41 

42Use `env` to set string-valued environment variables. Agent-generated code can

43read these values.

44 

45For secrets, use [vault credentials](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults#use-vault-secrets-for-api-requests-from-a-sandbox)

46to keep the real values outside the sandbox. Runtime-reserved names, including

47`PATH`, `CODEX_*`, and `OPENAI_API_KEY`, are rejected.

28 48 

29### Choose a container size49### Choose a container size

30 50 

65destinations need their own entries. Hosted stdio MCP servers currently require85destinations need their own entries. Hosted stdio MCP servers currently require

66`enabled` access; see [stdio MCP requirements](https://developers.openai.com/api/docs/guides/agents-api/tools/mcp#start-a-server-over-stdio).86`enabled` access; see [stdio MCP requirements](https://developers.openai.com/api/docs/guides/agents-api/tools/mcp#start-a-server-over-stdio).

67 87 

88### Add skills and plugins

89 

90Use `skills`, `plugins`, and `capability_directories` to add

91[skills](https://developers.openai.com/api/docs/guides/tools-skills#agents-api) and

92[plugins](https://developers.openai.com/api/docs/guides/agents-api/tools/plugins).

93 

94### Reuse configuration across sessions

95 

96Set `environment_template_id` to [reuse saved configuration](https://developers.openai.com/api/docs/guides/agents-api/tools/plugins#reuse-a-hosted-plugin-setup).

97Omitted settings inherit the template. Network overrides cannot broaden its policy.

98Templates save configuration, not a running workspace.

99 

68### Check that setup succeeded100### Check that setup succeeded

69 101 

70The create-session response means setup has started. Retrieve102The create-session response means setup has started. To check its status, retrieve

71`GET /v1/agents/environments/{environment_id}` using the session's `environment.id`:103`GET /v1/agents/environments/{environment_id}` using the session's `environment.id`.

72`provisioning` means setup is running; `connected` means setup succeeded.104 

73For `failed`, read `environment.error` in the `agent.session.environment.failed`105| Status | What to do |

74event. Wait for `connected` before adding or listing live files.106| -------------- | ------------------------------------------------------------------------- |

107| `provisioning` | Wait while setup runs. |

108| `connected` | Setup succeeded. You can add or list live files. |

109| `failed` | Read `environment.error` in the `agent.session.environment.failed` event. |

110 

111Wait for `connected` before adding or listing live files.

75 112 

76## Files and lifetime113## Files and lifetime

77 114 

40| 409: `conflict_error` | **Cause:** The operation conflicts with the current resource state. <br /> **Solution:** Read the message and retrieve the current state before retrying. |40| 409: `conflict_error` | **Cause:** The operation conflicts with the current resource state. <br /> **Solution:** Read the message and retrieve the current state before retrying. |

41| 409: `executor_version_incompatible` | **Cause:** The executor version isn't supported. <br /> **Solution:** Upgrade the executor, then retry. |41| 409: `executor_version_incompatible` | **Cause:** The executor version isn't supported. <br /> **Solution:** Upgrade the executor, then retry. |

42| 424: `mcp_server_startup_failed` | **Cause:** An MCP server failed to start. <br /> **Solution:** Check the server's configuration and credentials. See [Troubleshoot connections](https://developers.openai.com/api/docs/guides/agents-api/tools/mcp#troubleshoot-connections). |42| 424: `mcp_server_startup_failed` | **Cause:** An MCP server failed to start. <br /> **Solution:** Check the server's configuration and credentials. See [Troubleshoot connections](https://developers.openai.com/api/docs/guides/agents-api/tools/mcp#troubleshoot-connections). |

43| 429: `files_api_rate_limit_exceeded` | **Cause:** File requests exceeded the Files API limit for your user. <br /> **Solution:** Reduce concurrent requests and follow the [Files API rate-limit guidance](#files-api-rate-limits). |

43| 500: `internal_error` | **Cause:** The service encountered an unexpected error. <br /> **Solution:** [Check saved work before retrying](#retry-transient-failures). See the shared [server-error guidance](https://developers.openai.com/api/docs/guides/error-codes#api-errors). |44| 500: `internal_error` | **Cause:** The service encountered an unexpected error. <br /> **Solution:** [Check saved work before retrying](#retry-transient-failures). See the shared [server-error guidance](https://developers.openai.com/api/docs/guides/error-codes#api-errors). |

44| 503: `service_unavailable_error`, `server_is_overloaded` | **Cause:** The service or a dependency is temporarily unavailable or overloaded. <br /> **Solution:** Follow the shared [503 guidance](https://developers.openai.com/api/docs/guides/error-codes#api-errors) and [check saved work before retrying](#retry-transient-failures). |45| 503: `service_unavailable_error`, `server_is_overloaded` | **Cause:** The service or a dependency is temporarily unavailable or overloaded. <br /> **Solution:** Follow the shared [503 guidance](https://developers.openai.com/api/docs/guides/error-codes#api-errors) and [check saved work before retrying](#retry-transient-failures). |

45 46 

47### Files API rate limits

48 

49Session creation and file attachment requests can return HTTP 429 with

50`files_api_rate_limit_exceeded`. The Agents API checks files through the Files API.

51These checks consume the authenticated user's Files API allowance. Each attached file can require its own check.

52 

53```json

54{

55 "error": {

56 "type": "rate_limit_error",

57 "code": "files_api_rate_limit_exceeded",

58 "message": "The Files API rate limit for your user has been exceeded. Reduce the rate of requests that access files, then try again.",

59 "param": null

60 }

61}

62```

63 

64Reduce the number of concurrent requests that access files. Retry with exponential

65backoff and a limit on attempts. Immediate retries can continue to exhaust the

66allowance.

67 

68This HTTP response means the operation failed. It differs from a session or turn

69that fails asynchronously after a successful creation response. Check

70`error.code` to identify this condition instead of matching the message text.

71 

46## Turn errors72## Turn errors

47 73 

48A failed turn has `status: "failed"` and an `error` with a `code` and `message`.74A failed turn has `status: "failed"` and an `error` with a `code` and `message`.

187 187 

188See [Configuring Agents](https://developers.openai.com/api/docs/guides/agents-api/configuration) for reusable agent settings and [Architecture](https://developers.openai.com/api/docs/guides/agents-api/architecture) for environment choices. Sessions with `environment.type: "none"` require initial input. The [Create session reference](https://developers.openai.com/api/reference/resources/beta/subresources/agents/subresources/sessions/methods/create) lists the request fields.188See [Configuring Agents](https://developers.openai.com/api/docs/guides/agents-api/configuration) for reusable agent settings and [Architecture](https://developers.openai.com/api/docs/guides/agents-api/architecture) for environment choices. Sessions with `environment.type: "none"` require initial input. The [Create session reference](https://developers.openai.com/api/reference/resources/beta/subresources/agents/subresources/sessions/methods/create) lists the request fields.

189 189 

190If the session uses Files API attachments, file checks can return HTTP 429 with

191`files_api_rate_limit_exceeded`. See [Files API rate limits](https://developers.openai.com/api/docs/guides/agents-api/errors#files-api-rate-limits)

192for recovery steps.

193 

190### Input size194### Input size

191 195 

192The agent runtime accepts requests up to 4 MiB (4,194,304 bytes). Keep the combined size of your `input` and output schema (`agent.text.format.schema`) below this limit. Leave some space for metadata added by the Agents API. Files uploaded to the environment follow separate [file limits](https://developers.openai.com/api/docs/guides/agents-api/environments/files#file-limits).196The agent runtime accepts requests up to 4 MiB (4,194,304 bytes). Keep the combined size of your `input` and output schema (`agent.text.format.schema`) below this limit. Leave some space for metadata added by the Agents API. Files uploaded to the environment follow separate [file limits](https://developers.openai.com/api/docs/guides/agents-api/environments/files#file-limits).

188 188 

189 See the [chatkit-js repo](https://github.com/openai/chatkit-js) on GitHub.189 See the [chatkit-js repo](https://github.com/openai/chatkit-js) on GitHub.

190 190 

191 chatkit.js191 For Go, run `go get github.com/openai/openai-go/v3@v3.70.0`. For Java, add the Maven dependency `com.openai:openai-java:4.75.1`.

192 

193 Create a ChatKit session token

192 194 

193```javascript195```javascript

194export default async function getChatKitSessionToken(deviceId) {196export default async function getChatKitSessionToken(deviceId) {

226}228}

227```229```

228 230 

231```go

232// Call after authenticating the request. Pass the user's stable ID from your

233// server-side authentication context, never a client-supplied device ID.

234func getChatKitSessionToken(ctx context.Context, client openai.Client, authenticatedUserID string) (string, error) {

235 // Replace this illustrative workflow ID with your published workflow.

236 session, err := client.Beta.ChatKit.Sessions.New(ctx, openai.BetaChatKitSessionNewParams{

237 User: authenticatedUserID,

238 Workflow: openai.ChatSessionWorkflowParam{

239 ID: "wf_68df4b13b3588190a09d19288d4610ec0df388c3983f58d1",

240 },

241 })

242 if err != nil {

243 return "", err

244 }

245 return session.ClientSecret, nil

246}

247```

248 

249```java

250import com.openai.client.OpenAIClient;

251import com.openai.client.okhttp.OpenAIOkHttpClient;

252import com.openai.models.beta.chatkit.sessions.*;

253import com.openai.models.beta.chatkit.threads.ChatSessionWorkflowParam;

254 

255// Call after authenticating the request. Pass the user's stable ID from your

256// server-side authentication context, never a client-supplied device ID.

257static String getChatKitSessionToken(OpenAIClient client, String authenticatedUserId) {

258 // Replace this illustrative workflow ID with your published workflow.

259 return client

260 .beta()

261 .chatkit()

262 .sessions()

263 .create(

264 SessionCreateParams.builder()

265 .user(authenticatedUserId)

266 .workflow(

267 ChatSessionWorkflowParam.builder()

268 .id("wf_68df4b13b3588190a09d19288d4610ec0df388c3983f58d1")

269 .build())

270 .build())

271 .clientSecret();

272}

273```

274 

229 275 

2303. In your project directory, install the ChatKit React bindings:2763. In your project directory, install the ChatKit React bindings:

231 277 

392 return clean_text392 return clean_text

393```393```

394 394 

395```go

396// Start and End are UTF-8 byte offsets, suitable for Go string slicing.

397type Citation struct {

398 Raw, Family string

399 SourceIDs []string

400 Locator string

401 Start, End int

402}

403 

404var sourceID = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)

405var lineLocator = regexp.MustCompile(`^L\d+(?:-L\d+)?$`)

406 

407func extractCitations(text string, families []string) []Citation {

408 citations := []Citation{}

409 if len(families) == 0 {

410 return citations

411 }

412 escaped := make([]string, len(families))

413 for i, family := range families {

414 escaped[i] = regexp.QuoteMeta(family)

415 }

416 token := regexp.MustCompile("(?s)\uE200(" + strings.Join(escaped, "|") + ")\uE202(.*?)\uE201")

417 for _, match := range token.FindAllStringSubmatchIndex(text, -1) {

418 parts := []string{}

419 for _, part := range strings.Split(text[match[4]:match[5]], "\uE202") {

420 if part = strings.TrimSpace(part); part != "" {

421 parts = append(parts, part)

422 }

423 }

424 locator := ""

425 if len(parts) > 0 && lineLocator.MatchString(parts[len(parts)-1]) {

426 locator = parts[len(parts)-1]

427 parts = parts[:len(parts)-1]

428 }

429 valid := len(parts) > 0

430 for _, part := range parts {

431 if !sourceID.MatchString(part) {

432 valid = false

433 break

434 }

435 }

436 if valid {

437 citations = append(citations, Citation{

438 text[match[0]:match[1]],

439 text[match[2]:match[3]],

440 parts,

441 locator,

442 match[0],

443 match[1],

444 })

445 }

446 }

447 return citations

448}

449func stripCitations(text string, citations []Citation) string {

450 sorted := append([]Citation(nil), citations...)

451 sort.Slice(sorted, func(i, j int) bool {

452 return sorted[i].Start > sorted[j].Start

453 })

454 for _, citation := range sorted {

455 text = text[:citation.Start] + text[citation.End:]

456 }

457 return text

458}

459```

460 

461```java

462import java.util.*;

463import java.util.regex.Pattern;

464 

465// Java string offsets are UTF-16 code units, matching substring().

466record Citation(

467 String raw, String family, List<String> sourceIds, String locator, int start, int end) {}

468 

469static final Pattern SOURCE_ID = Pattern.compile("^[A-Za-z0-9_-]+$");

470static final Pattern LINE_LOCATOR = Pattern.compile("^L\\d+(?:-L\\d+)?$");

471 

472static List<Citation> extractCitations(String text, List<String> families) {

473 var citations = new ArrayList<Citation>();

474 if (families.isEmpty()) return citations;

475 var familyPattern =

476 families.stream().map(Pattern::quote).collect(java.util.stream.Collectors.joining("|"));

477 var matcher =

478 Pattern.compile("\uE200(" + familyPattern + ")\uE202(.*?)\uE201", Pattern.DOTALL)

479 .matcher(text);

480 while (matcher.find()) {

481 var parts =

482 new ArrayList<>(

483 Arrays.stream(matcher.group(2).split("\uE202"))

484 .map(String::strip)

485 .filter(s -> !s.isEmpty())

486 .toList());

487 String locator = null;

488 if (!parts.isEmpty() && LINE_LOCATOR.matcher(parts.get(parts.size() - 1)).matches())

489 locator = parts.remove(parts.size() - 1);

490 if (parts.isEmpty() || parts.stream().anyMatch(s -> !SOURCE_ID.matcher(s).matches()))

491 continue;

492 citations.add(

493 new Citation(

494 matcher.group(),

495 matcher.group(1),

496 List.copyOf(parts),

497 locator,

498 matcher.start(),

499 matcher.end()));

500 }

501 return citations;

502}

503 

504static String stripCitations(String text, List<Citation> citations) {

505 var sorted = new ArrayList<>(citations);

506 sorted.sort(Comparator.comparingInt(Citation::start).reversed());

507 for (var citation : sorted)

508 text = text.substring(0, citation.start()) + text.substring(citation.end());

509 return text;

510}

511```

512 

395```ruby513```ruby

396CITATION_START = "\u{E200}"514CITATION_START = "\u{E200}"

397CITATION_DELIMITER = "\u{E202}"515CITATION_DELIMITER = "\u{E202}"

19| Mainline model with Daybreak Blue | `gpt-6-sol` | `daybreak_blue` | Approved defensive security work with a specific mainline model. |19| Mainline model with Daybreak Blue | `gpt-6-sol` | `daybreak_blue` | Approved defensive security work with a specific mainline model. |

20| GPT-6.1 Sol or GPT-6 Astra with Daybreak | `gpt-6.1-sol` or `gpt-6-astra` | `daybreak_blue` | Reduced refusals with either model. Requires Daybreak Red approval for your organization and access enabled for your project. |20| GPT-6.1 Sol or GPT-6 Astra with Daybreak | `gpt-6.1-sol` or `gpt-6-astra` | `daybreak_blue` | Reduced refusals with either model. Requires Daybreak Red approval for your organization and access enabled for your project. |

21| Cyber model with Daybreak Red | `gpt-5.6-cyber` | `daybreak_red` | Advanced, authorized security work with a specific cyber model. Requires Daybreak Red approval. |21| Cyber model with Daybreak Red | `gpt-5.6-cyber` | `daybreak_red` | Advanced, authorized security work with a specific cyber model. Requires Daybreak Red approval. |

22| Daybreak Blue alias | `gpt-daybreak-blue-latest` | `daybreak_blue` | Approved defensive security work that follows updates to the Blue alias's underlying model. |

23| Daybreak Red alias | `gpt-daybreak-red-latest` | `daybreak_red` | Advanced, authorized security work that follows updates to the Red alias's underlying model. Requires Daybreak Red approval. |

24 22 

25 23 

26 24 

27 25 

28Match the request value to the model, not your organization's approval level. For example, when using `gpt-6-sol` with Daybreak, send `daybreak_blue` even if your organization has Daybreak Red approval. Sending `daybreak_red` with this model returns `invalid_access_program`.26Match the request value to the model, not your organization's approval level. For example, when using `gpt-6-sol` with Daybreak, send `daybreak_blue` even if your organization has Daybreak Red approval. Sending `daybreak_red` with this model returns `invalid_access_program`.

29 27 

30Daybreak aliases accept only their matching program. For example, requesting `gpt-daybreak-blue-latest` with `daybreak_red` returns an error.

31 

32Reduced refusals on `gpt-6-astra` and `gpt-6.1-sol` require Daybreak Red28Reduced refusals on `gpt-6-astra` and `gpt-6.1-sol` require Daybreak Red

33 access, but the request value is `daybreak_blue`. Both models reject29 access, but the request value is `daybreak_blue`. Both models reject

34 `daybreak_red`. Daybreak Blue approval alone doesn't authorize reduced30 `daybreak_red`. Daybreak Blue approval alone doesn't authorize reduced

37 33 

38## Send a request34## Send a request

39 35 

40To get started with Daybreak Blue approval, explicitly select `daybreak_blue` with the `gpt-daybreak-blue-latest` alias:36To get started with Daybreak Blue approval, explicitly select `daybreak_blue` with a Daybreak-eligible model, such as `gpt-6-sol`:

41 37 

42```bash38```bash

43curl https://api.openai.com/v1/responses \39curl https://api.openai.com/v1/responses \

44 -H "Authorization: Bearer $OPENAI_API_KEY" \40 -H "Authorization: Bearer $OPENAI_API_KEY" \

45 -H "Content-Type: application/json" \41 -H "Content-Type: application/json" \

46 -d '{42 -d '{

47 "model": "gpt-daybreak-blue-latest",43 "model": "gpt-6-sol",

48 "input": "Explain how to validate a security patch in a test environment.",44 "input": "Explain how to validate a security patch in a test environment.",

49 "access_programs": {45 "access_programs": {

50 "cyber": "daybreak_blue"46 "cyber": "daybreak_blue"

76If you omit `access_programs.cyber`, the API selects a compatible program based on the model and your organization and project access:72If you omit `access_programs.cyber`, the API selects a compatible program based on the model and your organization and project access:

77 73 

78- **Mainline models such as `gpt-6-sol`:** Daybreak Blue treatment when your organization and project have the required access; otherwise, standard safeguards.74- **Mainline models such as `gpt-6-sol`:** Daybreak Blue treatment when your organization and project have the required access; otherwise, standard safeguards.

79- **Daybreak aliases and Red models:** The matching Daybreak program. For example, `gpt-daybreak-blue-latest` selects `daybreak_blue`. The request fails if the required access is missing.75- **Red models such as `gpt-5.6-cyber`:** The API selects `daybreak_red`. The request fails if the required access is missing.

80- **`gpt-6-astra` and `gpt-6.1-sol`:** Reduced refusals for eligible callers with Daybreak Red access enabled for their project; otherwise, standard safeguards.76- **`gpt-6-astra` and `gpt-6.1-sol`:** Reduced refusals for eligible callers with Daybreak Red access enabled for their project; otherwise, standard safeguards.

81 77 

82Model permissions still apply. To explicitly request standard safeguards on a compatible model, send `standard`. An explicit Daybreak selection fails if it's incompatible with the model or you don't have the required access.78Model permissions still apply. To explicitly request standard safeguards on a compatible model, send `standard`. An explicit Daybreak selection fails if it's incompatible with the model or you don't have the required access.

1# Decisions

2 

3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

4 

5The Decisions API evaluates text, images, or both and returns typed answers about 10x faster than the Responses API. Get the probability that a condition is true, a choice from a fixed set, or a score against a rubric. Use those answers to classify content, route requests, and prioritize work in your application.

6 

7Try the Decisions API in the [Playground](https://platform.openai.com/decisions) to experiment with questions and inputs before writing code.

8 

9The Decisions API is in public beta, and we expect to GA in the coming weeks.

10 `gpt-6-luna` is the only model currently available. Use the dedicated `POST

11 /v1/decisions` endpoint.

12 

13## How decisions work

14 

15A request has three parts:

16 

17| Field | Purpose |

18| ----------- | -------------------------------------------------------------------------------------------------------- |

19| `model` | The model that evaluates the request. Currently, only `gpt-6-luna` is supported. |

20| `input` | Shared evidence for the questions: a text string or user messages containing text and images. |

21| `questions` | What to evaluate, including each question's type, instructions, and any allowed choices or score levels. |

22 

23The response contains an `answers` array. Give each question a unique `name` to identify its answer; the API echoes that name in the response.

24 

25### Choose a question type

26 

27| Type | Use it to | Main result |

28| ----------- | --------------------------------------------------------------- | ------------------------------------------------------------------ |

29| `predicate` | Check a condition, such as visible damage or passage relevance. | `probability`: an estimate from 0 to 1 that the condition is true. |

30| `choice` | Select one option, such as a department or content category. | `choice`: one of your supplied values. |

31| `score` | Rate an input against ordered levels, such as issue severity. | `score`: the probability-weighted average of the level indices. |

32 

33Both `choice` and `score` return probabilities over discrete options. Use `choice` for categories without an order, such as departments. Use `score` for ordered levels, such as severity; it takes the probability-weighted average of their numeric indices to produce a score that can fall between levels.

34 

35Use Decisions when your application needs one of these answer types. Use [Structured Outputs](https://developers.openai.com/api/docs/guides/structured-outputs) with the Responses API when you need to generate an object that follows your own JSON schema, such as extracted fields or a written explanation, or [function calling](https://developers.openai.com/api/docs/guides/function-calling) when you need a model to request a tool call with arguments.

36 

37## Check an image for visible damage

38 

39Use a `predicate` question to check a product photo for visible damage. This request combines the image with instructions to look for a crack, tear, or dent.

40 

41 

42 

43```bash

44IMAGE_BASE64="$(base64 < product.png | tr -d '\r\n')"

45 

46curl https://api.openai.com/v1/decisions \

47 -H "Authorization: Bearer $OPENAI_API_KEY" \

48 -H "Content-Type: application/json" \

49 --data-binary @- <<JSON

50{

51 "model": "gpt-6-luna",

52 "input": [{

53 "role": "user",

54 "content": [

55 {"type": "input_text", "text": "Inspect the product in this photo."},

56 {"type": "input_image", "image_url": "data:image/png;base64,$IMAGE_BASE64"}

57 ]

58 }],

59 "questions": [{

60 "type": "predicate",

61 "name": "visible_damage",

62 "instructions": "Does the product have visible damage, such as a crack, tear, or dent? Ignore shadows and damage to the packaging."

63 }]

64}

65JSON

66```

67 

68An illustrative response excerpt:

69 

70```json

71{

72 "answers": [

73 {

74 "type": "predicate",

75 "name": "visible_damage",

76 "probability": 0.92

77 }

78 ]

79}

80```

81 

82The `probability` is the model's estimate that the condition is true. Use it to flag photos for review based on a threshold you choose.

83 

84Images must be inline base64 data URLs. Hosted HTTP or HTTPS image URLs and `file_id` inputs aren't supported by this endpoint. Combine `input_text` and `input_image` parts in a user message to evaluate images together with instructions or other context.

85 

86## Select from fixed options

87 

88A `choice` question selects one value from the options you provide. Use distinct values and descriptions that explain when each option applies.

89 

90 

91 

92This request routes a customer complaint:

93 

94```bash

95curl https://api.openai.com/v1/decisions \

96 -H "Authorization: Bearer $OPENAI_API_KEY" \

97 -H "Content-Type: application/json" \

98 -d '{

99 "model": "gpt-6-luna",

100 "input": "I was charged twice for my order.",

101 "questions": [{

102 "type": "choice",

103 "name": "department",

104 "instructions": "Which department should handle this complaint?",

105 "choices": [

106 {"value": "billing", "description": "Payments, invoices, and refunds."},

107 {"value": "technical", "description": "Problems using the product."},

108 {"value": "shipping", "description": "Delivery and tracking."},

109 {"value": "other", "description": "Requests outside these categories."}

110 ]

111 }]

112 }'

113```

114 

115An illustrative response excerpt:

116 

117```json

118{

119 "answers": [

120 {

121 "type": "choice",

122 "name": "department",

123 "choice": "billing",

124 "probabilities": [

125 { "value": "billing", "probability": 0.95 },

126 { "value": "technical", "probability": 0.02 },

127 { "value": "shipping", "probability": 0.01 },

128 { "value": "other", "probability": 0.02 }

129 ],

130 "confidence": 0.93

131 }

132 ]

133}

134```

135 

136The answer's `choice` field contains a supplied value, here `"billing"`. It also includes a `probabilities` array for the options and a `confidence` field. See [Interpret the answers](#interpret-the-answers) for guidance on setting thresholds.

137 

138Include a fallback option such as `"other"` when your categories don't cover every possible input. Your application can send that result to a general review queue.

139 

140## Score against a rubric

141 

142A `score` question evaluates an input against ordered `levels`. Define the criteria for each level and arrange them from lowest to highest.

143 

144 

145 

146```bash

147curl https://api.openai.com/v1/decisions \

148 -H "Authorization: Bearer $OPENAI_API_KEY" \

149 -H "Content-Type: application/json" \

150 -d '{

151 "model": "gpt-6-luna",

152 "input": "Export fails in Safari but works in Chrome.",

153 "questions": [{

154 "type": "score",

155 "name": "severity",

156 "instructions": "How severe is this issue?",

157 "levels": [

158 {"label": "Cosmetic", "description": "Appearance only; no lost functionality."},

159 {"label": "Workaround available", "description": "A task fails, but another way works."},

160 {"label": "Fully blocked", "description": "A task fails with no workaround."}

161 ]

162 }]

163 }'

164```

165 

166An illustrative response excerpt:

167 

168```json

169{

170 "answers": [

171 {

172 "type": "score",

173 "name": "severity",

174 "score": 1.1,

175 "probabilities": [

176 { "value": 0, "label": "Cosmetic", "probability": 0.1 },

177 { "value": 1, "label": "Workaround available", "probability": 0.7 },

178 { "value": 2, "label": "Fully blocked", "probability": 0.2 }

179 ],

180 "confidence": 0.55

181 }

182 ]

183}

184```

185 

186Level indices start at 0. Here, 0 means cosmetic, 1 means a workaround is available, and 2 means fully blocked. The returned `score` is a probability-weighted average, so it can fall between levels. In this example, probabilities of 0.1, 0.7, and 0.2 produce a score of 1.1.

187 

188The answer also includes `confidence` and the per-level `probabilities`. The score summarizes the distribution across levels. Use `choice` to select a single category.

189 

190## Ask multiple questions

191 

192Put independent questions in the same `questions` array to evaluate shared input. For a product photo, you could check for damage and classify the product category in one request. Each question can use a different type.

193 

194For decisions that depend on an earlier answer, send separate requests. For example, check for damage first, then use the result to decide whether to request a repair category.

195 

196Write questions around observable criteria. Separate different concerns into different questions, give choices distinct meanings, and define score levels so that adjacent levels have distinct criteria.

197 

198## Interpret the answers

199 

200Predicates return the estimated probability that a condition is true. Choice and score answers return a probability distribution and a separate `confidence` field.

201 

202Use labeled examples from your application to set thresholds for routing, filtering, or review. Choose thresholds based on the cost of false positives and false negatives.

203 

204## Pricing and availability

205 

206With `gpt-6-luna`, input costs **$0.10 per 1M tokens**. You pay only for input tokens: there are no cache-read, cache-write, or output-token charges.

207 

208Regional processing premiums and long-context input pricing multipliers apply. These rates apply to `/v1/decisions`; other requests using `gpt-6-luna` follow the applicable [model and processing-tier pricing](https://developers.openai.com/api/docs/pricing).

209 

210The Decisions API supports Zero Data Retention (ZDR) and HIPAA use for eligible customers. Data residency and regional processing are supported in the United States and Europe (EEA + Switzerland). See [data controls](https://developers.openai.com/api/docs/guides/your-data) for eligibility requirements, required agreements, and limitations.

211 

212## Add voice control

213 

214Use [client delegation with the Live API](https://developers.openai.com/api/docs/guides/decisions-voice) to choose actions from voice requests and report their results to the user.

1# Connect voice to Decisions

2 

3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

4 

5Use the [Live API](https://developers.openai.com/api/docs/guides/live) for voice conversations and the [Decisions API](https://developers.openai.com/api/docs/guides/decisions) to select actions from spoken requests. With [client delegation](https://developers.openai.com/api/docs/guides/live-delegation?delegation-mode=client#configure-client-delegation), GPT-Live continues speaking and listening while your app calls Decisions, runs the selected action, and returns the result.

6 

7## Control a browser by voice

8 

9This example shows how to add voice controls to a browser.

10 

11When a user says “Reload this page,” send the conversation and current browser state to Decisions with three choices: `back`, `reload`, and `noop`. Decisions selects `reload`. Your app reloads the page, updates its state, and tells GPT-Live what happened.

12 

13 

14 

15> Illustration: GPT-Live handles the voice conversation while the app sends transcripts and browser state to Decisions. Decisions selects reload. The app reloads the page, updates its state, and returns the result to GPT-Live.

16 

17 

18 

19### Connect a voice session

20 

21Create a [Live session](https://developers.openai.com/api/docs/guides/voice-webrtc?api=live#connect-a-browser-to-gpt-live) with `delegation: { type: "client" }` and tell GPT-Live which actions your app supports. When you receive [`session.delegation.created`](https://developers.openai.com/api/docs/guides/live-delegation?delegation-mode=client#receive-a-client-delegation), save `event.delegation.id` and start the Decisions request. Use this ID to return the result to GPT-Live.

22 

23### Build the Decisions prompt

24 

25Track the current app state and collect user and assistant transcripts from [`session.input_transcript.delta` and `session.output_transcript.delta`](https://developers.openai.com/api/docs/guides/live-delegation?delegation-mode=client#keep-the-conversation-context-in-your-application).

26 

27Combine those transcripts with the user's latest request and current app state:

28 

29```text

30User conversation:

31user: Which page is open?

32assistant: The documentation page.

33 

34Last user request:

35Reload this page.

36 

37Current state:

38Active tab: Documentation. Page loaded.

39Available actions: back, reload, noop.

40```

41 

42### Select and run an action

43 

44Send the prompt and available choices to the Decisions API from your server. Keep `OPENAI_API_KEY` on the server:

45 

46```bash

47curl https://api.openai.com/v1/decisions \

48 -H "Authorization: Bearer $OPENAI_API_KEY" \

49 -H "Content-Type: application/json" \

50 -d '{

51 "model": "gpt-6-luna",

52 "input": "User conversation:\nuser: Which page is open?\nassistant: The documentation page.\n\nLast user request:\nReload this page.\n\nCurrent state:\nActive tab: Documentation. Page loaded.\nAvailable actions: back, reload, noop.",

53 "questions": [{

54 "type": "choice",

55 "name": "browser_action",

56 "instructions": "Choose the requested, currently available action. Choose noop if no action fits.",

57 "choices": [

58 {"value": "back", "description": "Go back one page."},

59 {"value": "reload", "description": "Reload the current page."},

60 {"value": "noop", "description": "Take no action."}

61 ]

62 }]

63 }'

64```

65 

66Find the answer named `browser_action` in the response’s `answers` array and read its `choice`. Run the matching action: `reload` reloads the current page, `back` goes back one page, and `noop` does nothing. Skip the action if the request was canceled or it no longer fits the current app state.

67 

68### Return the result to GPT-Live

69 

70Update your app state with the current page, load status, and whether the action succeeded. Use this state in the next Decisions prompt.

71 

72Send the result to GPT-Live with [`session.commentary.append`](https://developers.openai.com/api/docs/guides/live-delegation#send-the-right-kind-of-update) and the saved delegation ID. This prompts GPT-Live to tell the user what happened. For a successful reload, send:

73 

74```json

75{

76 "type": "session.commentary.append",

77 "delegation_id": "<event.delegation.id>",

78 "content": "The documentation page reloaded successfully and is ready."

79}

80```

81 

82Use `session.thinking.append` to update GPT-Live’s context without prompting it to speak. Keep each append within 500 tokens.

83 

84## Route complex requests to a reasoning model

85 

86Use Decisions to select a supported action or route a more complex request to a reasoning model. In a slide presenter, “Go to the next slide” maps to `next_slide`, while “Compare these two plans and recommend one” maps to `reason`.

87 

88Include the conversation and current state in `input`, then send the request to `POST /v1/decisions`:

89 

90```json

91{

92 "model": "gpt-6-luna",

93 "input": "User: Compare these two plans and recommend one. Current state: slide 3 of 10 is open and both plans are available.",

94 "questions": [

95 {

96 "type": "choice",

97 "name": "route",

98 "instructions": "Choose a matching slide action that is available in the current state. Otherwise, choose reason.",

99 "choices": [

100 {

101 "value": "next_slide",

102 "description": "Go to the next slide."

103 },

104 {

105 "value": "previous_slide",

106 "description": "Go to the previous slide."

107 },

108 {

109 "value": "first_slide",

110 "description": "Go to the first slide."

111 },

112 {

113 "value": "reason",

114 "description": "Use a reasoning model for analysis, planning, or other requests."

115 }

116 ]

117 }

118 ]

119}

120```

121 

122Read the `route` answer's `choice`. For a slide action, validate it against the current state and run the matching handler. For `reason`, call the [Responses API with a reasoning model](https://developers.openai.com/api/docs/guides/reasoning#get-started-with-reasoning), passing the original request and relevant context, such as the plans' contents.

123 

124Keep the session in client-delegation mode for both routes. Your app manages continuation and cancellation and returns the result with the same delegation ID.

125 

126## Other uses

127 

128Use the same workflow with choices and state from your application:

129 

130- **Slide navigation:** Offer `next`, `previous`, `start`, and `end` based on the current slide.

131- **UI actions:** Map choices such as `click_search` to element IDs from the current UI state. Check that the element is still available before acting.

132- **Voice-guided games:** Use the spoken goal and current game state to choose an available button. Repeat until the app confirms success or the user cancels, and send progress updates to GPT-Live.

133- **Robot gestures:** Map requests such as “Wave hello” to `nod`, `shake_head`, or `wave`, then send the selected gesture to the robot controller.

134- **Media controls:** Offer `play`, `pause`, and `next_track` based on the player’s current state.

1800The JavaScript sample uses `npm install openai@^7.10.0 ws`.1800The JavaScript sample uses `npm install openai@^7.10.0 ws`.

1801The Ruby sample uses `gem install openai async-websocket`.1801The Ruby sample uses `gem install openai async-websocket`.

1802 1802 

1803For Go, run `go get github.com/openai/openai-go/v3@v3.70.0`.

1804For Java, add the Maven dependency `com.openai:openai-java:4.75.1`.

1805These Go and Java SDK versions provide native Responses WebSocket support.

1806 

1803Start a Responses API WebSocket session1807Start a Responses API WebSocket session

1804 1808 

1805```javascript1809```javascript

1879 print(first_event.type)1883 print(first_event.type)

1880```1884```

1881 1885 

1886```go

1887tools := []responses.ToolUnionParam{}

1888for _, name := range []string{

1889 "search_test_logs",

1890 "search_code",

1891} {

1892 tools = append(tools, responses.ToolUnionParam{

1893 OfFunction: &responses.FunctionToolParam{

1894 Name: name,

1895 Description: openai.String("Search for a query."),

1896 Parameters: map[string]any{

1897 "type": "object",

1898 "properties": map[string]any{

1899 "query": map[string]any{

1900 "type": "string",

1901 },

1902 },

1903 "required": []string{

1904 "query",

1905 },

1906 "additionalProperties": false,

1907 },

1908 Strict: openai.Bool(true),

1909 },

1910 })

1911}

1912ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)

1913defer cancel()

1914client := openai.NewClient()

1915conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})

1916if err != nil {

1917 log.Fatal(err)

1918}

1919defer conn.Close()

1920if err := conn.Create(ctx, responses.ResponsesClientEventResponseCreateParam{

1921 Model: "gpt-6-astra",

1922 Store: openai.Bool(false),

1923 Input: responses.ResponsesClientEventResponseCreateInputUnionParam{

1924 OfString: openai.String("Find the flaky test in this run, call the tools you need, and keep going until you can explain the root cause."),

1925 },

1926 Tools: tools,

1927}); err != nil {

1928 log.Fatal(err)

1929}

1930response, err := conn.FinalResponse(ctx)

1931if err != nil {

1932 log.Fatal(err)

1933}

1934if response.Status != responses.ResponseStatusCompleted {

1935 log.Fatalf("Response ended with status %s", response.Status)

1936}

1937output := make([]json.RawMessage, 0, len(response.Output))

1938for _, item := range response.Output {

1939 output = append(output, json.RawMessage(item.RawJSON()))

1940}

1941if err := json.NewEncoder(os.Stdout).Encode(output); err != nil {

1942 log.Fatal(err)

1943}

1944```

1945 

1946```java

1947import com.openai.client.okhttp.OpenAIOkHttpClient;

1948import com.openai.core.JsonValue;

1949import com.openai.models.responses.*;

1950import java.util.*;

1951 

1952var tools = new ArrayList<Tool>();

1953for (var name : List.of("search_test_logs", "search_code"))

1954 tools.add(

1955 Tool.ofFunction(

1956 FunctionTool.builder()

1957 .name(name)

1958 .description("Search for a query.")

1959 .strict(true)

1960 .parameters(

1961 FunctionTool.Parameters.builder()

1962 .putAdditionalProperty("type", JsonValue.from("object"))

1963 .putAdditionalProperty(

1964 "properties",

1965 JsonValue.from(Map.of("query", Map.of("type", "string"))))

1966 .putAdditionalProperty("required", JsonValue.from(List.of("query")))

1967 .putAdditionalProperty("additionalProperties", JsonValue.from(false))

1968 .build())

1969 .build()));

1970 

1971try (var conn = client.responses().connect()) {

1972 conn.send(

1973 ResponsesClientEvent.ofResponseCreate(

1974 ResponsesClientEvent.ResponseCreate.builder()

1975 .model("gpt-6-astra")

1976 .store(false)

1977 .input(

1978 "Find the flaky test in this run, call the tools you need, and keep going until you can explain the root cause.")

1979 .tools(tools)

1980 .build()));

1981 var response = conn.finalResponse();

1982 if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty())

1983 throw new IllegalStateException(

1984 "Response ended with status " + response.status().orElse(null));

1985 System.out.println(response.output());

1986}

1987```

1988 

1882```ruby1989```ruby

1883require "async"1990require "async"

1884require "openai"1991require "openai"

282print(eval_obj)282print(eval_obj)

283```283```

284 284 

285```java

286import com.openai.client.okhttp.OpenAIOkHttpClient;

287import com.openai.core.JsonValue;

288import com.openai.models.evals.EvalCreateParams;

289import com.openai.models.graders.gradermodels.StringCheckGrader;

290import java.util.List;

291import java.util.Map;

292 

293var eval =

294 client

295 .evals()

296 .create(

297 EvalCreateParams.builder()

298 .name("IT Ticket Categorization")

299 .dataSourceConfig(

300 EvalCreateParams.DataSourceConfig.Custom.builder()

301 .itemSchema(

302 EvalCreateParams.DataSourceConfig.Custom.ItemSchema.builder()

303 .additionalProperties(

304 Map.of(

305 "type", JsonValue.from("object"),

306 "properties",

307 JsonValue.from(

308 Map.of(

309 "ticket_text",

310 Map.of("type", "string"),

311 "correct_label",

312 Map.of("type", "string"))),

313 "required",

314 JsonValue.from(

315 List.of("ticket_text", "correct_label"))))

316 .build())

317 .includeSampleSchema(true)

318 .build())

319 .addTestingCriterion(

320 StringCheckGrader.builder()

321 .name("Match output to human label")

322 .input("{{ sample.output_text }}")

323 .operation(StringCheckGrader.Operation.EQ)

324 .reference("{{ item.correct_label }}")

325 .build())

326 .build());

327System.out.println(eval);

328```

329 

285```ruby330```ruby

286require "openai"331require "openai"

287 332 

617print(run)662print(run)

618```663```

619 664 

665```java

666import com.openai.client.okhttp.OpenAIOkHttpClient;

667import com.openai.models.evals.runs.*;

668 

669// Replace these illustrative IDs with your eval and uploaded dataset file.

670var run =

671 client

672 .evals()

673 .runs()

674 .create(

675 RunCreateParams.builder()

676 .evalId("YOUR_EVAL_ID")

677 .name("Categorization text run")

678 .dataSource(

679 RunCreateParams.DataSource.CreateEvalResponsesRunDataSource.builder()

680 .type(

681 RunCreateParams.DataSource.CreateEvalResponsesRunDataSource.Type

682 .RESPONSES)

683 .model("gpt-6-astra")

684 .inputMessages(

685 RunCreateParams.DataSource.CreateEvalResponsesRunDataSource

686 .InputMessages.Template.builder()

687 .addTemplate(

688 RunCreateParams.DataSource.CreateEvalResponsesRunDataSource

689 .InputMessages.Template.InnerTemplate.ChatMessage

690 .builder()

691 .role("developer")

692 .content(

693 "You are an expert in categorizing IT support tickets. Given the support ticket below, categorize the request into one of 'Hardware', 'Software', or 'Other'. Respond with only one of those words.")

694 .build())

695 .addTemplate(

696 RunCreateParams.DataSource.CreateEvalResponsesRunDataSource

697 .InputMessages.Template.InnerTemplate.ChatMessage

698 .builder()

699 .role("user")

700 .content("{{ item.ticket_text }}")

701 .build())

702 .build())

703 .source(

704 RunCreateParams.DataSource.CreateEvalResponsesRunDataSource.Source

705 .FileId.builder()

706 .id("YOUR_FILE_ID")

707 .build())

708 .build())

709 .build());

710System.out.println(run);

711```

712 

620```ruby713```ruby

621require "openai"714require "openai"

622 715 

758print(run)851print(run)

759```852```

760 853 

854```java

855import com.openai.client.okhttp.OpenAIOkHttpClient;

856import com.openai.models.evals.runs.RunRetrieveParams;

857 

858// Replace these illustrative IDs with your eval and run.

859var run =

860 client

861 .evals()

862 .runs()

863 .retrieve(

864 RunRetrieveParams.builder().evalId("YOUR_EVAL_ID").runId("YOUR_RUN_ID").build());

865System.out.println(run);

866```

867 

761```ruby868```ruby

762require "openai"869require "openai"

763 870 

17 17 

18In order to use third-party models, the following must be true:18In order to use third-party models, the following must be true:

19 19 

20- Your OpenAI organization must be in [usage tier 1](https://developers.openai.com/api/docs/guides/rate-limits#usage-tiers) or higher.20- Your OpenAI organization must be in [Build](https://developers.openai.com/api/docs/guides/rate-limits#usage-tiers) or higher.

21- An admin for your OpenAI organization must enable this feature via [Settings > Organization > General](https://platform.openai.com/settings/organization/general). To enable this feature, the admin must accept the usage disclaimer shown.21- An admin for your OpenAI organization must enable this feature via [Settings > Organization > General](https://platform.openai.com/settings/organization/general). To enable this feature, the admin must accept the usage disclaimer shown.

22 22 

23Calls made to external models pass data to third parties and are subject to23Calls made to external models pass data to third parties and are subject to

29 29 

30| Usage tier | Monthly spend limit (USD) |30| Usage tier | Monthly spend limit (USD) |

31| ---------- | ------------------------- |31| ---------- | ------------------------- |

32| Tier 1 | $5 |32| Build | $25 |

33| Tier 2 | $25 |33| Launch | $100 |

34| Tier 3 | $50 |34| Grow | $200 |

35| Tier 4 | $100 |

36| Tier 5 | $200 |

37 35 

38We serve these models via our partner, OpenRouter. In the future, third-party models will be charged as part of your regular OpenAI billing cycle, at [OpenRouter list prices](https://openrouter.ai/models).36We serve these models via our partner, OpenRouter. In the future, third-party models will be charged as part of your regular OpenAI billing cycle, at [OpenRouter list prices](https://openrouter.ai/models).

39 37 

605 return input_cost605 return input_cost

606```606```

607 607 

608```go

609func calculateInputCost(usage responses.ResponseUsage, pricePerMillion, cacheInputMultiplier, cacheWriteMultiplier float64) float64 {

610 ordinary := usage.InputTokens - usage.InputTokensDetails.CachedTokens - usage.InputTokensDetails.CacheWriteTokens

611 weighted := float64(ordinary) + float64(usage.InputTokensDetails.CachedTokens)*cacheInputMultiplier + float64(usage.InputTokensDetails.CacheWriteTokens)*cacheWriteMultiplier

612 return weighted * pricePerMillion / 1_000_000

613}

614```

615 

616```java

617import com.openai.models.responses.ResponseUsage;

618 

619static double calculateInputCost(

620 ResponseUsage usage,

621 double pricePerMillion,

622 double cacheInputMultiplier,

623 double cacheWriteMultiplier) {

624 long cached = usage.inputTokensDetails().cachedTokens();

625 long written = usage.inputTokensDetails().cacheWriteTokens();

626 long ordinary = usage.inputTokens() - cached - written;

627 return (ordinary + cached * cacheInputMultiplier + written * cacheWriteMultiplier)

628 * pricePerMillion

629 / 1_000_000;

630}

631```

632 

608```ruby633```ruby

609def calculate_input_cost(634def calculate_input_cost(

610 usage,635 usage,

35 35 

36## Usage tiers36## Usage tiers

37 37 

38You can view the rate and usage limits for your organization under the [limits](https://platform.openai.com/settings/organization/limits) section of your account settings. As your spend on our API goes up, we automatically graduate you to the next usage tier. This usually results in an increase in rate limits across most models.38The three paid usage tiers are **Build**, **Launch**, and **Grow**. Your organization's usage tier upgrades automatically as its total credit purchases reach each threshold. Higher tiers generally provide higher rate limits across models.

39 39 

40| Tier | Qualification | Usage limits |40| Tier | Qualification | Usage limits |

41| ----------- | --------------------------------------------------------------------- | ---------------- |41| ------ | --------------------------------------------------------------------- | ---------------- |

42| Free | User must be in an [allowed geography](https://developers.openai.com/api/docs/supported-countries) | $100 / month |42| Free | User must be in an [allowed geography](https://developers.openai.com/api/docs/supported-countries) | $100 / month |

43| Tier 1 | $5 paid | $100 / month |43| Build | $5 in total credit purchases | $500 / month |

44| Tier 2 | $50 paid | $500 / month |44| Launch | $100 in total credit purchases | $5,000 / month |

45| Tier 3 | $100 paid | $1,000 / month |45| Grow | $500 in total credit purchases | $200,000 / month |

46| Tier 4 | $250 paid | $5,000 / month |46 

47| Tier 5 | $1,000 paid | $200,000 / month |47### Standard rate limits

48 48 

49To view a high-level summary of rate limits per model, visit the [models page](https://developers.openai.com/api/docs/models).49To view the limits for each model at your usage tier, go to [Settings > Organization > Limits](https://platform.openai.com/settings/organization/limits) and review **Rate limits**. To upgrade your usage tier, select **Upgrade tier** in the **Usage Tiers** section.

50 

51These Standard rate limits differ from [Ultrafast rate limits](https://developers.openai.com/api/docs/guides/ultrafast-mode#availability).

52 

53<table className="[&_th]:border-b [&_th]:border-[var(--tw-prose-th-borders)] [&_th]:py-3 [&_th]:pl-0 [&_th]:pr-4 [&_th]:text-left [&_td]:border-b [&_td]:border-[var(--tw-prose-td-borders)] [&_td]:py-2 [&_td]:pl-0 [&_td]:pr-4 [&_td]:text-left [&_td]:align-top">

54 <thead>

55 <tr>

56 <th scope="col">Tier</th>

57 <th scope="col">Model</th>

58 <th scope="col">RPM</th>

59 <th scope="col">TPM</th>

60 </tr>

61 </thead>

62 <tbody>

63 <tr>

64 <td rowSpan="2">Build</td>

65 <td>Astra, Sol, Terra</td>

66 <td>5,000</td>

67 <td>1,000,000</td>

68 </tr>

69 <tr>

70 <td>Luna</td>

71 <td>5,000</td>

72 <td>2,000,000</td>

73 </tr>

74 <tr>

75 <td rowSpan="2">Launch</td>

76 <td>Astra, Sol, Terra</td>

77 <td>10,000</td>

78 <td>4,000,000</td>

79 </tr>

80 <tr>

81 <td>Luna</td>

82 <td>10,000</td>

83 <td>10,000,000</td>

84 </tr>

85 <tr>

86 <td rowSpan="2">Grow</td>

87 <td>Astra, Sol, Terra</td>

88 <td>15,000</td>

89 <td>40,000,000</td>

90 </tr>

91 <tr>

92 <td>Luna</td>

93 <td>30,000</td>

94 <td>180,000,000</td>

95 </tr>

96 </tbody>

97</table>

50 98 

51### Spend limits99### Spend limits

52 100 

120ws.send(json.dumps(event))120ws.send(json.dumps(event))

121```121```

122 122 

123```java

124import com.openai.client.okhttp.OkHttpClient;

125import com.openai.core.ClientOptions;

126import com.openai.core.JsonValue;

127import com.openai.helpers.RealtimeConnection;

128import com.openai.helpers.RealtimeWebSocketOptions;

129import com.openai.models.realtime.*;

130 

131// Replace pmpt_123 with your stored prompt ID.

132var pcm =

133 RealtimeAudioFormats.AudioPcm.builder()

134 .rate(RealtimeAudioFormats.AudioPcm.Rate._24000)

135 .build();

136connection.send(

137 RealtimeClientEvent.ofSessionUpdate(

138 SessionUpdateEvent.builder()

139 .session(

140 RealtimeSessionCreateRequest.builder()

141 .model("gpt-realtime-2.1")

142 .addOutputModality(RealtimeSessionCreateRequest.OutputModality.AUDIO)

143 .audio(

144 RealtimeAudioConfig.builder()

145 .input(

146 RealtimeAudioConfigInput.builder()

147 .format(pcm)

148 .turnDetection(

149 RealtimeAudioInputTurnDetection.SemanticVad.builder()

150 .build())

151 .build())

152 .output(

153 RealtimeAudioConfigOutput.builder()

154 .format(pcm)

155 .voice("marin")

156 .build())

157 .build())

158 .prompt(

159 com.openai.models.responses.ResponsePrompt.builder()

160 .id("pmpt_123")

161 .version("89")

162 .variables(

163 com.openai.models.responses.ResponsePrompt.Variables.builder()

164 .putAdditionalProperty("city", JsonValue.from("Paris"))

165 .build())

166 .build())

167 .instructions(

168 "Speak clearly and briefly. Confirm understanding before taking actions.")

169 .build())

170 .build()));

171```

172 

123```ruby173```ruby

124# Replace the illustrative IDs and URLs below with your own resource values.174# Replace the illustrative IDs and URLs below with your own resource values.

125connection.session.update(175connection.session.update(

216ws.send(json.dumps(event))266ws.send(json.dumps(event))

217```267```

218 268 

269```java

270import com.openai.client.okhttp.OkHttpClient;

271import com.openai.core.ClientOptions;

272import com.openai.helpers.RealtimeConnection;

273import com.openai.helpers.RealtimeWebSocketOptions;

274import com.openai.models.realtime.*;

275 

276connection.send(

277 RealtimeClientEvent.ofConversationItemCreate(

278 ConversationItemCreateEvent.builder()

279 .item(

280 RealtimeConversationItemUserMessage.builder()

281 .addContent(

282 RealtimeConversationItemUserMessage.Content.builder()

283 .type(RealtimeConversationItemUserMessage.Content.Type.INPUT_TEXT)

284 .text("What Prince album sold the most copies?")

285 .build())

286 .build())

287 .build()));

288```

289 

290```csharp

291using OpenAI.Realtime;

292 

293#pragma warning disable OPENAI002

294 

295RealtimeMessageItem item = RealtimeItem.CreateUserMessageItem("What Prince album sold the most copies?");

296item.Id = Guid.NewGuid().ToString("N");

297await session.SendCommandAsync(new RealtimeClientCommandConversationItemCreate(item), timeout.Token);

298```

299 

219```ruby300```ruby

220connection.conversation.items.create(301connection.conversation.items.create(

221 type: :message,302 type: :message,

251ws.send(json.dumps(event))332ws.send(json.dumps(event))

252```333```

253 334 

335```java

336import com.openai.client.okhttp.OkHttpClient;

337import com.openai.core.ClientOptions;

338import com.openai.helpers.RealtimeConnection;

339import com.openai.helpers.RealtimeWebSocketOptions;

340import com.openai.models.realtime.*;

341 

342connection.send(

343 RealtimeClientEvent.ofResponseCreate(

344 ResponseCreateEvent.builder()

345 .response(

346 RealtimeResponseCreateParams.builder()

347 .addOutputModality(RealtimeResponseCreateParams.OutputModality.TEXT)

348 .build())

349 .build()));

350```

351 

352```csharp

353using OpenAI.Realtime;

354 

355#pragma warning disable OPENAI002

356 

357await session.SendCommandAsync(new RealtimeClientCommandResponseCreate

358{

359 ResponseOptions = new()

360 {

361 OutputModalities =

362 {

363 RealtimeOutputModality.Text

364 }

365 }

366}, timeout.Token);

367```

368 

254```ruby369```ruby

255connection.response.create(370connection.response.create(

256 output_modalities: [:text],371 output_modalities: [:text],

286 print(server_event["response"]["output"][0])401 print(server_event["response"]["output"][0])

287```402```

288 403 

404```java

405import com.openai.client.okhttp.OkHttpClient;

406import com.openai.core.ClientOptions;

407import com.openai.helpers.RealtimeConnection;

408import com.openai.helpers.RealtimeWebSocketOptions;

409import com.openai.models.realtime.*;

410 

411static void handleEvent(RealtimeServerEvent event) {

412 event

413 .responseDone()

414 .ifPresent(

415 done -> {

416 if (!done.response()

417 .status()

418 .filter(RealtimeResponse.Status.COMPLETED::equals)

419 .isPresent())

420 throw new IllegalStateException(

421 "Response ended with status "

422 + done.response().status()

423 + ": "

424 + done.response().statusDetails());

425 System.out.println(done.response().output());

426 });

427}

428```

429 

430```csharp

431using OpenAI.Realtime;

432 

433#pragma warning disable OPENAI002

434 

435internal static void HandleEvent(RealtimeServerUpdate update)

436{

437 if (update is RealtimeServerUpdateResponseDone completion && completion.Response.Status != RealtimeResponseStatus.Completed)

438 throw new InvalidOperationException($"Response ended with status {completion.Response.Status}: {System.ClientModel.Primitives.ModelReaderWriter.Write(completion.Response)}");

439 if (update is RealtimeServerUpdateResponseDone done)

440 {

441 foreach (RealtimeItem item in done.Response.OutputItems)

442 Console.WriteLine(System.ClientModel.Primitives.ModelReaderWriter.Write(item));

443 }

444}

445```

446 

289```ruby447```ruby

290connection.each do |event|448connection.each do |event|

291 next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)449 next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)

616 ws.send(json.dumps(event))774 ws.send(json.dumps(event))

617```775```

618 776 

777```java

778import com.openai.client.okhttp.OkHttpClient;

779import com.openai.core.ClientOptions;

780import com.openai.helpers.RealtimeConnection;

781import com.openai.helpers.RealtimeWebSocketOptions;

782import com.openai.models.realtime.*;

783import java.util.Base64;

784 

785// Call for each PCM16, 24 kHz, mono chunk supplied by your audio source.

786static void appendAudio(RealtimeConnection connection, byte[] pcmAudio) throws Exception {

787 String base64Audio = Base64.getEncoder().encodeToString(pcmAudio);

788 send(

789 connection,

790 RealtimeClientEvent.ofInputAudioBufferAppend(

791 InputAudioBufferAppendEvent.builder().audio(base64Audio).build()));

792}

793 

794// Retry only explicit admission rejections; these guarantee nothing was sent.

795private static void send(RealtimeConnection connection, RealtimeClientEvent event)

796 throws Exception {

797 long deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(5);

798 while (true) {

799 try {

800 connection.send(event);

801 return;

802 } catch (com.openai.core.http.WebSocketWriteNotAttempted.Busy busy) {

803 if (System.nanoTime() >= deadline) throw busy;

804 Thread.sleep(10);

805 }

806 }

807}

808```

809 

810```csharp

811using OpenAI.Realtime;

812 

813#pragma warning disable OPENAI002

814 

815// Call for each PCM16, 24 kHz, mono chunk supplied by your audio source.

816internal static async Task AppendAudioAsync(RealtimeSessionClient session, BinaryData pcmAudio, CancellationToken cancellationToken)

817{

818 await session.SendCommandAsync(new RealtimeClientCommandInputAudioBufferAppend(pcmAudio), cancellationToken);

819}

820```

821 

619```ruby822```ruby

620File.open("speech.pcm", "rb") do |audio|823File.open("speech.pcm", "rb") do |audio|

621 while (chunk = audio.read(9_600))824 while (chunk = audio.read(9_600))

672ws.send(json.dumps(event))875ws.send(json.dumps(event))

673```876```

674 877 

878```java

879import com.openai.client.okhttp.OkHttpClient;

880import com.openai.core.ClientOptions;

881import com.openai.helpers.RealtimeConnection;

882import com.openai.helpers.RealtimeWebSocketOptions;

883import com.openai.models.realtime.*;

884import java.util.Base64;

885 

886// Pass the complete PCM16, 24 kHz, mono recording from your application.

887static void sendAudioItem(RealtimeConnection connection, byte[] pcmAudio) throws Exception {

888 String fullAudio = Base64.getEncoder().encodeToString(pcmAudio);

889 connection.send(

890 RealtimeClientEvent.ofConversationItemCreate(

891 ConversationItemCreateEvent.builder()

892 .item(

893 RealtimeConversationItemUserMessage.builder()

894 .addContent(

895 RealtimeConversationItemUserMessage.Content.builder()

896 .type(RealtimeConversationItemUserMessage.Content.Type.INPUT_AUDIO)

897 .audio(fullAudio)

898 .build())

899 .build())

900 .build()));

901}

902```

903 

904```csharp

905using OpenAI.Realtime;

906 

907#pragma warning disable OPENAI002

908 

909// Pass the complete PCM16, 24 kHz, mono recording from your application.

910internal static async Task<string> SendAudioItemAsync(RealtimeSessionClient session, BinaryData pcmAudio, CancellationToken cancellationToken)

911{

912 RealtimeMessageItem item = RealtimeItem.CreateUserMessageItem([new RealtimeInputAudioMessageContentPart(pcmAudio)]);

913 string itemId = Guid.NewGuid().ToString("N");

914 item.Id = itemId;

915 await session.SendCommandAsync(new RealtimeClientCommandConversationItemCreate(item), cancellationToken);

916 return itemId;

917}

918```

919 

675```ruby920```ruby

676audio = Base64.strict_encode64(File.binread("speech.pcm"))921audio = Base64.strict_encode64(File.binread("speech.pcm"))

677 922 

724 print(server_event["delta"])969 print(server_event["delta"])

725```970```

726 971 

972```java

973import com.openai.client.okhttp.OkHttpClient;

974import com.openai.core.ClientOptions;

975import com.openai.helpers.RealtimeConnection;

976import com.openai.helpers.RealtimeWebSocketOptions;

977import com.openai.models.realtime.*;

978 

979static void handleEvent(RealtimeServerEvent event) {

980 event.responseOutputAudioDelta().ifPresent(delta -> System.out.println(delta.delta()));

981}

982```

983 

984```csharp

985using OpenAI.Realtime;

986 

987#pragma warning disable OPENAI002

988 

989internal static void HandleEvent(RealtimeServerUpdate update)

990{

991 if (update is RealtimeServerUpdateResponseOutputAudioDelta delta)

992 Console.WriteLine(Convert.ToBase64String(delta.Delta.ToArray()));

993}

994```

995 

727```ruby996```ruby

728connection.each do |event|997connection.each do |event|

729 case event998 case event

866ws.send(json.dumps(event))1135ws.send(json.dumps(event))

867```1136```

868 1137 

1138```java

1139import com.openai.client.okhttp.OkHttpClient;

1140import com.openai.core.ClientOptions;

1141import com.openai.core.JsonValue;

1142import com.openai.helpers.RealtimeConnection;

1143import com.openai.helpers.RealtimeWebSocketOptions;

1144import com.openai.models.realtime.*;

1145 

1146connection.send(

1147 RealtimeClientEvent.ofResponseCreate(

1148 ResponseCreateEvent.builder()

1149 .response(

1150 RealtimeResponseCreateParams.builder()

1151 .conversation("none")

1152 .metadata(

1153 RealtimeResponseCreateParams.Metadata.builder()

1154 .putAdditionalProperty("topic", JsonValue.from("classification"))

1155 .build())

1156 .addOutputModality(RealtimeResponseCreateParams.OutputModality.TEXT)

1157 .instructions(

1158 "Analyze the conversation so far. If it is related to support, output \"support\". If it is related to sales, output \"sales\".")

1159 .build())

1160 .build()));

1161```

1162 

1163```csharp

1164using OpenAI.Realtime;

1165 

1166#pragma warning disable OPENAI002

1167 

1168await session.SendCommandAsync(new RealtimeClientCommandResponseCreate

1169{

1170 ResponseOptions = new()

1171 {

1172 DefaultConversationConfiguration = RealtimeResponseDefaultConversationConfiguration.None,

1173 Metadata = new Dictionary<string, BinaryData>

1174 {

1175 ["topic"] = BinaryData.FromObjectAsJson("classification")

1176 },

1177 OutputModalities =

1178 {

1179 RealtimeOutputModality.Text

1180 },

1181 Instructions = "Analyze the conversation so far. If it is related to support, output \"support\". If it is related to sales, output \"sales\"."

1182 }

1183}, timeout.Token);

1184```

1185 

869```ruby1186```ruby

870connection.response.create(1187connection.response.create(

871 conversation: :none,1188 conversation: :none,

916 print(server_event["response"]["output"][0])1233 print(server_event["response"]["output"][0])

917```1234```

918 1235 

1236```java

1237import com.openai.client.okhttp.OkHttpClient;

1238import com.openai.core.ClientOptions;

1239import com.openai.core.JsonValue;

1240import com.openai.helpers.RealtimeConnection;

1241import com.openai.helpers.RealtimeWebSocketOptions;

1242import com.openai.models.realtime.*;

1243 

1244static boolean handleEvent(RealtimeServerEvent event) {

1245 if (event.responseDone().isEmpty()) return false;

1246 var response = event.responseDone().orElseThrow().response();

1247 if (!response

1248 .metadata()

1249 .map(m -> m._additionalProperties().get("topic"))

1250 .flatMap(JsonValue::asString)

1251 .filter("classification"::equals)

1252 .isPresent()) return false;

1253 if (!response.status().filter(RealtimeResponse.Status.COMPLETED::equals).isPresent())

1254 throw new IllegalStateException(

1255 "Response ended with status " + response.status() + ": " + response.statusDetails());

1256 System.out.println(response.output());

1257 return true;

1258}

1259```

1260 

1261```csharp

1262using OpenAI.Realtime;

1263 

1264#pragma warning disable OPENAI002

1265 

1266internal static bool HandleEvent(RealtimeServerUpdate update)

1267{

1268 if (update is not RealtimeServerUpdateResponseDone done ||

1269 !done.Response.Metadata.TryGetValue("topic", out BinaryData? topic) ||

1270 topic.ToObjectFromJson<string>() != "classification")

1271 return false;

1272 if (done.Response.Status != RealtimeResponseStatus.Completed)

1273 throw new InvalidOperationException($"Response ended with status {done.Response.Status}: {System.ClientModel.Primitives.ModelReaderWriter.Write(done.Response)}");

1274 foreach (RealtimeItem item in done.Response.OutputItems)

1275 Console.WriteLine(System.ClientModel.Primitives.ModelReaderWriter.Write(item));

1276 return true;

1277}

1278```

1279 

919```ruby1280```ruby

920connection.each do |event|1281connection.each do |event|

921 next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)1282 next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)

1074ws.send(json.dumps(event))1435ws.send(json.dumps(event))

1075```1436```

1076 1437 

1438```java

1439import com.openai.client.okhttp.OkHttpClient;

1440import com.openai.core.ClientOptions;

1441import com.openai.helpers.RealtimeConnection;

1442import com.openai.helpers.RealtimeWebSocketOptions;

1443import com.openai.models.realtime.*;

1444import java.util.List;

1445 

1446connection.send(

1447 RealtimeClientEvent.ofResponseCreate(

1448 ResponseCreateEvent.builder()

1449 .response(

1450 RealtimeResponseCreateParams.builder()

1451 .input(List.of())

1452 .instructions(

1453 "Say exactly the following: I'm a little teapot, short and stout! This is my handle, this is my spout!")

1454 .build())

1455 .build()));

1456```

1457 

1458```csharp

1459using OpenAI.Realtime;

1460 

1461#pragma warning disable OPENAI002

1462 

1463RealtimeResponseOptions options = new()

1464 

1465{

1466 Instructions = "Say exactly the following: I'm a little teapot, short and stout! This is my handle, this is my spout!"

1467 

1468};

1469options.InputItems.Clear();

1470// An explicitly empty list excludes conversation context.

1471await session.SendCommandAsync(new RealtimeClientCommandResponseCreate

1472{

1473 ResponseOptions = options

1474}, timeout.Token);

1475```

1476 

1077```ruby1477```ruby

1078connection.response.create(1478connection.response.create(

1079 input: [],1479 input: [],

85ws.send(json.dumps(event))85ws.send(json.dumps(event))

86```86```

87 87 

88```java

89import com.openai.client.okhttp.OkHttpClient;

90import com.openai.core.ClientOptions;

91import com.openai.core.JsonValue;

92import com.openai.helpers.RealtimeConnection;

93import com.openai.helpers.RealtimeWebSocketOptions;

94import com.openai.models.realtime.*;

95import java.util.List;

96import java.util.Map;

97 

98connection.send(

99 RealtimeClientEvent.ofSessionUpdate(

100 SessionUpdateEvent.builder()

101 .session(

102 RealtimeSessionCreateRequest.builder()

103 .model("gpt-realtime-2.1")

104 .addTool(

105 RealtimeFunctionTool.builder()

106 .type(RealtimeFunctionTool.Type.FUNCTION)

107 .name("lookup_order")

108 .description("Look up an order by its order number.")

109 .parameters(

110 JsonValue.from(

111 Map.of(

112 "type",

113 "object",

114 "properties",

115 Map.of(

116 "order_number",

117 Map.of(

118 "type",

119 "string",

120 "description",

121 "The customer-facing order number.")),

122 "required",

123 List.of("order_number"))))

124 .build())

125 .toolChoice(com.openai.models.responses.ToolChoiceOptions.AUTO)

126 .build())

127 .build()));

128```

129 

130```csharp

131using OpenAI.Realtime;

132 

133#pragma warning disable OPENAI002

134 

135await session.SendCommandAsync(new RealtimeClientCommandSessionUpdate(new RealtimeConversationSessionOptions

136{

137 Model = "gpt-realtime-2.1",

138 Tools =

139 {

140 new RealtimeFunctionTool("lookup_order")

141 {

142 FunctionDescription = "Look up an order by its order number.",

143 FunctionParameters = BinaryData.FromObjectAsJson(new { type = "object", properties = new { order_number = new { type = "string", description = "The customer-facing order number." } }, required = (string[])["order_number"] })

144 }

145 },

146 ToolChoice = RealtimeDefaultToolChoice.Auto

147}), timeout.Token);

148```

149 

88```ruby150```ruby

89connection.session.update(151connection.session.update(

90 type: :realtime,152 type: :realtime,

151ws.send(json.dumps({"type": "response.create"}))213ws.send(json.dumps({"type": "response.create"}))

152```214```

153 215 

216```java

217import com.openai.client.okhttp.OkHttpClient;

218import com.openai.core.ClientOptions;

219import com.openai.core.JsonValue;

220import com.openai.helpers.RealtimeConnection;

221import com.openai.helpers.RealtimeWebSocketOptions;

222import com.openai.models.realtime.*;

223import com.openai.models.responses.ToolChoiceFunction;

224import com.openai.models.responses.ToolChoiceOptions;

225import java.util.Map;

226 

227static void sendFunctionCallOutput(RealtimeConnection connection, String callId)

228 throws Exception {