Documentation 2026-07-14 21:58 UTC to 2026-07-15 02:58 UTC

166print(response.output_text)166print(response.output_text)

167```167```

168 168 

169```ruby

170require "openai"

171 

172openai = OpenAI::Client.new

173 

174response = openai.responses.create(

175 model: "gpt-5.6",

176 input: [

177 {

178 role: "user",

179 content: [

180 {

181 type: "input_text",

182 text: "Analyze the letter and provide a summary of the key points."

183 },

184 {

185 type: "input_file",

186 file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf"

187 }

188 ]

189 }

190 ]

191)

192 

193puts(response.output_text)

194```

195 

169```csharp196```csharp

170using OpenAI.Files;197using OpenAI.Files;

171using OpenAI.Responses;198using OpenAI.Responses;

293print(response.output_text)320print(response.output_text)

294```321```

295 322 

323```ruby

324require "openai"

325 

326openai = OpenAI::Client.new

327 

328file = openai.files.create(

329 file: File.open("draconomicon.pdf", "rb"),

330 purpose: "user_data"

331)

332 

333response = openai.responses.create(

334 model: "gpt-5.6",

335 input: [

336 {

337 role: "user",

338 content: [

339 {type: "input_file", file_id: file.id},

340 {type: "input_text", text: "What is the first dragon in the book?"}

341 ]

342 }

343 ]

344)

345 

346puts(response.output_text)

347```

348 

296```csharp349```csharp

297using OpenAI.Files;350using OpenAI.Files;

298using OpenAI.Responses;351using OpenAI.Responses;

69 69 

70 70 

71 71 

72 Note that for reasoning models like GPT-5 or o4-mini, any reasoning items72 Complete tool calling example

73 

74```python

75from openai import OpenAI

76import json

77 

78client = OpenAI()

79 

80# 1. Define a list of callable tools for the model

81tools = [

82 {

83 "type": "function",

84 "name": "get_horoscope",

85 "description": "Get today's horoscope for an astrological sign.",

86 "parameters": {

87 "type": "object",

88 "properties": {

89 "sign": {

90 "type": "string",

91 "description": "An astrological sign like Taurus or Aquarius",

92 },

93 },

94 "required": ["sign"],

95 },

96 },

97]

98 

99def get_horoscope(sign):

100 return f"{sign}: Next Tuesday you will befriend a baby otter."

101 

102# Create a running input list we will add to over time

103input_list = [

104 {"role": "user", "content": "What is my horoscope? I am an Aquarius."}

105]

106 

107# 2. Prompt the model with tools defined

108response = client.responses.create(

109 model="gpt-5.6",

110 tools=tools,

111 input=input_list,

112)

113 

114# Save function call outputs for subsequent requests

115input_list += response.output

116 

117for item in response.output:

118 if item.type == "function_call":

119 if item.name == "get_horoscope":

120 # 3. Execute the function logic for get_horoscope

121 sign = json.loads(item.arguments)["sign"]

122 horoscope = get_horoscope(sign)

123

124 # 4. Provide function call results to the model

125 input_list.append({

126 "type": "function_call_output",

127 "call_id": item.call_id,

128 "output": horoscope,

129 })

130 

131print("Final input:")

132print(input_list)

133 

134response = client.responses.create(

135 model="gpt-5.6",

136 instructions="Respond only with a horoscope generated by a tool.",

137 tools=tools,

138 input=input_list,

139)

140 

141# 5. The model should be able to give a response!

142print("Final output:")

143print(response.model_dump_json(indent=2))

144print("\n" + response.output_text)

145```

146 

147```javascript

148import OpenAI from "openai";

149 

150const openai = new OpenAI();

151 

152// 1. Define a list of callable tools for the model

153const tools = [

154 {

155 type: "function",

156 name: "get_horoscope",

157 description: "Get today's horoscope for an astrological sign.",

158 parameters: {

159 type: "object",

160 properties: {

161 sign: {

162 type: "string",

163 description: "An astrological sign like Taurus or Aquarius",

164 },

165 },

166 required: ["sign"],

167 additionalProperties: false,

168 },

169 strict: true,

170 },

171];

172 

173function getHoroscope(sign) {

174 return `${sign}: Next Tuesday you will befriend a baby otter.`;

175}

176 

177// Create a running input list we will add to over time

178let input = [

179 { role: "user", content: "What is my horoscope? I am an Aquarius." },

180];

181 

182// 2. Prompt the model with tools defined

183let response = await openai.responses.create({

184 model: "gpt-5.6",

185 tools,

186 input,

187});

188 

189// Preserve model output for the next turn

190input.push(...response.output);

191 

192for (const item of response.output) {

193 if (item.type !== "function_call") continue;

194 

195 if (item.name === "get_horoscope") {

196 // 3. Execute the function logic for get_horoscope

197 const { sign } = JSON.parse(item.arguments);

198 const horoscope = getHoroscope(sign);

199 

200 // 4. Provide function call results to the model

201 input.push({

202 type: "function_call_output",

203 call_id: item.call_id,

204 output: horoscope,

205 });

206 }

207}

208 

209console.log("Final input:");

210console.log(JSON.stringify(input, null, 2));

211 

212response = await openai.responses.create({

213 model: "gpt-5.6",

214 instructions: "Respond only with a horoscope generated by a tool.",

215 tools,

216 input,

217});

218 

219// 5. The model should be able to give a response!

220console.log("Final output:");

221console.log(response.output_text);

222```

223 

224 

225 

226Note that for reasoning models like GPT-5 or o4-mini, any reasoning items

73 returned in model responses with tool calls must also be passed back with tool227 returned in model responses with tool calls must also be passed back with tool

74 call outputs.228 call outputs.

75 229 

201 355 

202The response `output` array contains an entry with the `type` having a value of `function_call`. Each entry with a `call_id` (used later to submit the function result), `name`, and JSON-encoded `arguments`.356The response `output` array contains an entry with the `type` having a value of `function_call`. Each entry with a `call_id` (used later to submit the function result), `name`, and JSON-encoded `arguments`.

203 357 

358Sample response with multiple function calls

359 

360```json

361[

362 {

363 "id": "fc_12345xyz",

364 "call_id": "call_12345xyz",

365 "type": "function_call",

366 "name": "get_weather",

367 "arguments": "{\"location\":\"Paris, France\"}"

368 },

369 {

370 "id": "fc_67890abc",

371 "call_id": "call_67890abc",

372 "type": "function_call",

373 "name": "get_weather",

374 "arguments": "{\"location\":\"Bogotá, Colombia\"}"

375 },

376 {

377 "id": "fc_99999def",

378 "call_id": "call_99999def",

379 "type": "function_call",

380 "name": "send_email",

381 "arguments": "{\"to\":\"bob@email.com\",\"body\":\"Hi bob\"}"

382 }

383]

384```

385 

386 

204If you are using [tool search](https://developers.openai.com/api/docs/guides/tools-tool-search), you may also see `tool_search_call` and `tool_search_output` items before a `function_call`. Once the function is loaded, handle the function call in the same way shown here.387If you are using [tool search](https://developers.openai.com/api/docs/guides/tools-tool-search), you may also see `tool_search_call` and `tool_search_output` items before a `function_call`. Once the function is loaded, handle the function call in the same way shown here.

205 388 

389Execute function calls and append results

390 

391```python

392for tool_call in response.output:

393 if tool_call.type != "function_call":

394 continue

395 

396 name = tool_call.name

397 args = json.loads(tool_call.arguments)

398 

399 result = call_function(name, args)

400 input_messages.append({

401 "type": "function_call_output",

402 "call_id": tool_call.call_id,

403 "output": str(result)

404 })

405```

406 

407```javascript

408for (const toolCall of response.output) {

409 if (toolCall.type !== "function_call") {

410 continue;

411 }

412 

413 const name = toolCall.name;

414 const args = JSON.parse(toolCall.arguments);

415 

416 const result = callFunction(name, args);

417 input.push({

418 type: "function_call_output",

419 call_id: toolCall.call_id,

420 output: result.toString()

421 });

422}

423```

424 

425 

426 

206In the example above, we have a hypothetical `call_function` to route each call. Here’s a possible implementation:427In the example above, we have a hypothetical `call_function` to route each call. Here’s a possible implementation:

207 428 

429Execute function calls and append results

430 

431```python

432def call_function(name, args):

433 if name == "get_weather":

434 return get_weather(**args)

435 if name == "send_email":

436 return send_email(**args)

437```

438 

439```javascript

440const callFunction = async (name, args) => {

441 if (name === "get_weather") {

442 return getWeather(args.latitude, args.longitude);

443 }

444 if (name === "send_email") {

445 return sendEmail(args.to, args.body);

446 }

447};

448```

449 

450 

208### Formatting results451### Formatting results

209 452 

210The result you pass in the `function_call_output` message should typically be a string, where the format is up to you (JSON, error codes, plain text, etc.). The model will interpret that string as needed.453The result you pass in the `function_call_output` message should typically be a string, where the format is up to you (JSON, error codes, plain text, etc.). The model will interpret that string as needed.

219 462 

220After appending the results to your `input`, you can send them back to the model to get a final response.463After appending the results to your `input`, you can send them back to the model to get a final response.

221 464 

465Send results back to model

466 

467```python

468response = client.responses.create(

469 model="gpt-5.6",

470 input=input_messages,

471 tools=tools,

472)

473```

474 

475```javascript

476const response = await openai.responses.create({

477 model: "gpt-5.6",

478 input,

479 tools,

480});

481```

482 

483 

484 

485Final response

486 

487```json

488"It's about 15°C in Paris, 18°C in Bogotá, and I've sent that email to Bob."

489```

490 

491 

222## Additional configurations492## Additional configurations

223 493 

224### Tool choice494### Tool choice

292 562 

293<div data-content-switcher-pane data-value="enabled">563<div data-content-switcher-pane data-value="enabled">

294 <div class="hidden">Strict mode enabled</div>564 <div class="hidden">Strict mode enabled</div>

565 ```json

566{

567 "type": "function",

568 "name": "get_weather",

569 "description": "Retrieves current weather for the given location.",

570 //highlight-start

571 "strict": true,

572 //highlight-end

573 "parameters": {

574 "type": "object",

575 "properties": {

576 "location": {

577 "type": "string",

578 "description": "City and country e.g. Bogotá, Colombia"

579 },

580 "units": {

581 //highlight-start

582 "type": ["string", "null"],

583 //highlight-end

584 "enum": ["celsius", "fahrenheit"],

585 "description": "Units the temperature will be returned in."

586 }

587 },

588 //highlight-start

589 "required": ["location", "units"],

590 "additionalProperties": false

591 //highlight-end

592 }

593}

594```

595 

295 </div>596 </div>

296 <div data-content-switcher-pane data-value="disabled" hidden>597 <div data-content-switcher-pane data-value="disabled" hidden>

297 <div class="hidden">Strict mode disabled</div>598 <div class="hidden">Strict mode disabled</div>

599 ```json

600{

601 "type": "function",

602 "name": "get_weather",

603 "description": "Retrieves current weather for the given location.",

604 "parameters": {

605 "type": "object",

606 "properties": {

607 "location": {

608 "type": "string",

609 "description": "City and country e.g. Bogotá, Colombia"

610 },

611 "units": {

612 //highlight-start

613 "type": "string",

614 //highlight-end

615 "enum": ["celsius", "fahrenheit"],

616 "description": "Units the temperature will be returned in."

617 }

618 },

619 //highlight-start

620 "required": ["location"],

621 //highlight-end

622 }

623}

624```

625 

298 </div>626 </div>

299 627 

300 628 

321 649 

322Streaming function calls is very similar to streaming regular responses: you set `stream` to `true` and get different `event` objects.650Streaming function calls is very similar to streaming regular responses: you set `stream` to `true` and get different `event` objects.

323 651 

652Streaming function calls

653 

654```python

655from openai import OpenAI

656 

657client = OpenAI()

658 

659tools = [{

660 "type": "function",

661 "name": "get_weather",

662 "description": "Get current temperature for a given location.",

663 "parameters": {

664 "type": "object",

665 "properties": {

666 "location": {

667 "type": "string",

668 "description": "City and country e.g. Bogotá, Colombia"

669 }

670 },

671 "required": [

672 "location"

673 ],

674 "additionalProperties": False

675 }

676}]

677 

678stream = client.responses.create(

679 model="gpt-5.6",

680 input=[{"role": "user", "content": "What's the weather like in Paris today?"}],

681 tools=tools,

682 stream=True

683)

684 

685for event in stream:

686 print(event)

687```

688 

689```javascript

690import { OpenAI } from "openai";

691 

692const openai = new OpenAI();

693 

694const tools = [{

695 type: "function",

696 name: "get_weather",

697 description: "Get current temperature for provided coordinates in celsius.",

698 parameters: {

699 type: "object",

700 properties: {

701 latitude: { type: "number" },

702 longitude: { type: "number" }

703 },

704 required: ["latitude", "longitude"],

705 additionalProperties: false

706 },

707 strict: true

708}];

709 

710const stream = await openai.responses.create({

711 model: "gpt-5.6",

712 input: [{ role: "user", content: "What's the weather like in Paris today?" }],

713 tools,

714 stream: true,

715 store: true,

716});

717 

718for await (const event of stream) {

719 console.log(event)

720}

721```

722 

723 

724Output events

725 

726```json

727{"type":"response.output_item.added","response_id":"resp_1234xyz","output_index":0,"item":{"type":"function_call","id":"fc_1234xyz","call_id":"call_1234xyz","name":"get_weather","arguments":""}}

728{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":"{\""}

729{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":"location"}

730{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":"\":\""}

731{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":"Paris"}

732{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":","}

733{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":" France"}

734{"type":"response.function_call_arguments.delta","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"delta":"\"}"}

735{"type":"response.function_call_arguments.done","response_id":"resp_1234xyz","item_id":"fc_1234xyz","output_index":0,"arguments":"{\"location\":\"Paris, France\"}"}

736{"type":"response.output_item.done","response_id":"resp_1234xyz","output_index":0,"item":{"type":"function_call","id":"fc_1234xyz","call_id":"call_1234xyz","name":"get_weather","arguments":"{\"location\":\"Paris, France\"}"}}

737```

738 

739 

324Instead of aggregating chunks into a single `content` string, however, you're aggregating chunks into an encoded `arguments` JSON object.740Instead of aggregating chunks into a single `content` string, however, you're aggregating chunks into an encoded `arguments` JSON object.

325 741 

326When the model calls one or more functions an event of type `response.output_item.added` will be emitted for each function call that contains the following fields:742When the model calls one or more functions an event of type `response.output_item.added` will be emitted for each function call that contains the following fields:

342 758 

343Below is a code snippet demonstrating how to aggregate the `delta`s into a final `tool_call` object.759Below is a code snippet demonstrating how to aggregate the `delta`s into a final `tool_call` object.

344 760 

761Accumulating tool_call deltas

762 

763```python

764final_tool_calls = {}

765 

766for event in stream:

767 if event.type === 'response.output_item.added':

768 final_tool_calls[event.output_index] = event.item;

769 elif event.type === 'response.function_call_arguments.delta':

770 index = event.output_index

771 

772 if final_tool_calls[index]:

773 final_tool_calls[index].arguments += event.delta

774```

775 

776```javascript

777const finalToolCalls = {};

778 

779for await (const event of stream) {

780 if (event.type === 'response.output_item.added') {

781 finalToolCalls[event.output_index] = event.item;

782 } else if (event.type === 'response.function_call_arguments.delta') {

783 const index = event.output_index;

784 

785 if (finalToolCalls[index]) {

786 finalToolCalls[index].arguments += event.delta;

787 }

788 }

789}

790```

791 

792 

793Accumulated final_tool_calls[0]

794 

795```json

796{

797 "type": "function_call",

798 "id": "fc_1234xyz",

799 "call_id": "call_2345abc",

800 "name": "get_weather",

801 "arguments": "{\"location\":\"Paris, France\"}"

802}

803```

804 

805 

345When the model has finished calling the functions an event of type `response.function_call_arguments.done` will be emitted. This event contains the entire function call including the following fields:806When the model has finished calling the functions an event of type `response.function_call_arguments.done` will be emitted. This event contains the entire function call including the following fields:

346 807 

347| Field | Description |808| Field | Description |

358 819 

359The following code sample shows creating a custom tool that expects to receive a string of text containing Python code as a response.820The following code sample shows creating a custom tool that expects to receive a string of text containing Python code as a response.

360 821 

822Custom tool calling example

823 

824```python

825from openai import OpenAI

826 

827client = OpenAI()

828 

829response = client.responses.create(

830 model="gpt-5.6",

831 input="Use the code_exec tool to print hello world to the console.",

832 tools=[

833 {

834 "type": "custom",

835 "name": "code_exec",

836 "description": "Executes arbitrary Python code.",

837 }

838 ]

839)

840print(response.output)

841```

842 

843```javascript

844import OpenAI from "openai";

845const client = new OpenAI();

846 

847const response = await client.responses.create({

848 model: "gpt-5.6",

849 input: "Use the code_exec tool to print hello world to the console.",

850 tools: [

851 {

852 type: "custom",

853 name: "code_exec",

854 description: "Executes arbitrary Python code.",

855 },

856 ],

857});

858 

859console.log(response.output);

860```

861 

862 

361Just as before, the `output` array will contain a tool call generated by the model. Except this time, the tool call input is given as plain text.863Just as before, the `output` array will contain a tool call generated by the model. Except this time, the tool call input is given as plain text.

362 864 

363```json865```json

387 889 

388#### Lark CFG890#### Lark CFG

389 891 

892Lark context free grammar example

893 

894```python

895from openai import OpenAI

896 

897client = OpenAI()

898 

899grammar = """

900start: expr

901expr: term (SP ADD SP term)* -> add

902| term

903term: factor (SP MUL SP factor)* -> mul

904| factor

905factor: INT

906SP: " "

907ADD: "+"

908MUL: "*"

909%import common.INT

910"""

911 

912response = client.responses.create(

913 model="gpt-5.6",

914 input="Use the math_exp tool to add four plus four.",

915 tools=[

916 {

917 "type": "custom",

918 "name": "math_exp",

919 "description": "Creates valid mathematical expressions",

920 "format": {

921 "type": "grammar",

922 "syntax": "lark",

923 "definition": grammar,

924 },

925 }

926 ]

927)

928print(response.output)

929```

930 

931```javascript

932import OpenAI from "openai";

933const client = new OpenAI();

934 

935const grammar = `

936start: expr

937expr: term (SP ADD SP term)* -> add

938| term

939term: factor (SP MUL SP factor)* -> mul

940| factor

941factor: INT

942SP: " "

943ADD: "+"

944MUL: "*"

945%import common.INT

946`;

947 

948const response = await client.responses.create({

949 model: "gpt-5.6",

950 input: "Use the math_exp tool to add four plus four.",

951 tools: [

952 {

953 type: "custom",

954 name: "math_exp",

955 description: "Creates valid mathematical expressions",

956 format: {

957 type: "grammar",

958 syntax: "lark",

959 definition: grammar,

960 },

961 },

962 ],

963});

964 

965console.log(response.output);

966```

967 

968 

390The output from the tool should then conform to the Lark CFG that you defined:969The output from the tool should then conform to the Lark CFG that you defined:

391 970 

392```json971```json

495 1074 

496#### Regex CFG1075#### Regex CFG

497 1076 

1077Regex context free grammar example

1078 

1079```python

1080from openai import OpenAI

1081 

1082client = OpenAI()

1083 

1084grammar = r"^(?P<month>January|February|March|April|May|June|July|August|September|October|November|December)\s+(?P<day>\d{1,2})(?:st|nd|rd|th)?\s+(?P<year>\d{4})\s+at\s+(?P<hour>0?[1-9]|1[0-2])(?P<ampm>AM|PM)$"

1085 

1086response = client.responses.create(

1087 model="gpt-5.6",

1088 input="Use the timestamp tool to save a timestamp for August 7th 2025 at 10AM.",

1089 tools=[

1090 {

1091 "type": "custom",

1092 "name": "timestamp",

1093 "description": "Saves a timestamp in date + time in 24-hr format.",

1094 "format": {

1095 "type": "grammar",

1096 "syntax": "regex",

1097 "definition": grammar,

1098 },

1099 }

1100 ]

1101)

1102print(response.output)

1103```

1104 

1105```javascript

1106import OpenAI from "openai";

1107const client = new OpenAI();

1108 

1109const grammar = "^(?P<month>January|February|March|April|May|June|July|August|September|October|November|December)\s+(?P<day>\d{1,2})(?:st|nd|rd|th)?\s+(?P<year>\d{4})\s+at\s+(?P<hour>0?[1-9]|1[0-2])(?P<ampm>AM|PM)$";

1110 

1111const response = await client.responses.create({

1112 model: "gpt-5.6",

1113 input: "Use the timestamp tool to save a timestamp for August 7th 2025 at 10AM.",

1114 tools: [

1115 {

1116 type: "custom",

1117 name: "timestamp",

1118 description: "Saves a timestamp in date + time in 24-hr format.",

1119 format: {

1120 type: "grammar",

1121 syntax: "regex",

1122 definition: grammar,

1123 },

1124 },

1125 ],

1126});

1127 

1128console.log(response.output);

1129```

1130 

1131 

498The output from the tool should then conform to the Regex CFG that you defined:1132The output from the tool should then conform to the Regex CFG that you defined:

499 1133 

500```json1134```json

6 6 

7Here's a simple example using the [Responses API](https://developers.openai.com/api/docs/api-reference/responses).7Here's a simple example using the [Responses API](https://developers.openai.com/api/docs/api-reference/responses).

8 8 

9Generate text from a simple prompt

10 

11```javascript

12import OpenAI from "openai";

13const client = new OpenAI();

14 

15const response = await client.responses.create({

16 model: "gpt-5.6",

17 input: "Write a one-sentence bedtime story about a unicorn."

18});

19 

20console.log(response.output_text);

21```

22 

23```python

24from openai import OpenAI

25client = OpenAI()

26 

27response = client.responses.create(

28 model="gpt-5.6",

29 input="Write a one-sentence bedtime story about a unicorn."

30)

31 

32print(response.output_text)

33```

34 

35```cli

36openai responses create \

37 --model "gpt-5.6" \

38 --input "Write a one-sentence bedtime story about a unicorn." \

39 --raw-output \

40 --transform 'output.#(type=="message").content.0.text'

41```

42 

43```csharp

44using System;

45using System.Threading.Tasks;

46using OpenAI;

47 

48class Program

49{

50 static async Task Main()

51 {

52 var client = new OpenAIClient(

53 Environment.GetEnvironmentVariable("OPENAI_API_KEY")

54 );

55 

56 var response = await client.Responses.CreateAsync(new ResponseCreateRequest

57 {

58 Model = "gpt-5.6",

59 Input = "Say 'this is a test.'"

60 });

61 

62 Console.WriteLine($"[ASSISTANT]: {response.OutputText()}");

63 }

64}

65```

66 

67```java

68import com.openai.client.OpenAIClient;

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

70import com.openai.models.responses.Response;

71import com.openai.models.responses.ResponseCreateParams;

72 

73public class Main {

74 public static void main(String[] args) {

75 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

76 

77 ResponseCreateParams params = ResponseCreateParams.builder()

78 .input("Say this is a test")

79 .model("gpt-5.6")

80 .build();

81 

82 Response response = client.responses().create(params);

83 System.out.println(response.outputText());

84 }

85}

86```

87 

88```go

89package main

90 

91import (

92 "context"

93 "fmt"

94 

95 "github.com/openai/openai-go/v3"

96 "github.com/openai/openai-go/v3/option"

97 "github.com/openai/openai-go/v3/responses"

98)

99 

100func main() {

101 client := openai.NewClient(

102 option.WithAPIKey("My API Key"), // or set OPENAI_API_KEY in your env

103 )

104 

105 resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{

106 Model: "gpt-5.6",

107 Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say this is a test")},

108 })

109 if err != nil {

110 panic(err.Error())

111 }

112 

113 fmt.Println(resp.OutputText())

114}

115```

116 

117```ruby

118require "openai"

119 

120openai = OpenAI::Client.new

121 

122response = openai.responses.create(

123 model: "gpt-5.6",

124 input: "Write a one-sentence bedtime story about a unicorn."

125)

126 

127puts(response.output_text)

128```

129 

130```bash

131curl "https://api.openai.com/v1/responses" \

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

133 -H "Authorization: Bearer $OPENAI_API_KEY" \

134 -d '{

135 "model": "gpt-5.6",

136 "input": "Write a one-sentence bedtime story about a unicorn."

137 }'

138```

139 

140 

9An array of content generated by the model is in the `output` property of the response. In this simple example, we have just one output which looks like this:141An array of content generated by the model is in the `output` property of the response. In this simple example, we have just one output which looks like this:

10 142 

11```json143```json

23 23 

24<div data-content-switcher-pane data-value="text-out">24<div data-content-switcher-pane data-value="text-out">

25 <div class="hidden">Text-out</div>25 <div class="hidden">Text-out</div>

26 Text meta-prompt

27 

28```python

29from openai import OpenAI

30 

31client = OpenAI()

32 

33META_PROMPT = """

34Given a task description or existing prompt, produce a detailed system prompt to guide a language model in completing the task effectively.

35 

36# Guidelines

37 

38- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.

39- Minimal Changes: If an existing prompt is provided, improve it only if it's simple. For complex prompts, enhance clarity and add missing elements without altering the original structure.

40- Reasoning Before Conclusions**: Encourage reasoning steps before any conclusions are reached. ATTENTION! If the user provides examples where the reasoning happens afterward, REVERSE the order! NEVER START EXAMPLES WITH CONCLUSIONS!

41 - Reasoning Order: Call out reasoning portions of the prompt and conclusion parts (specific fields by name). For each, determine the ORDER in which this is done, and whether it needs to be reversed.

42 - Conclusion, classifications, or results should ALWAYS appear last.

43- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.

44 - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.

45- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.

46- Formatting: Use markdown features for readability. DO NOT USE ``` CODE BLOCKS UNLESS SPECIFICALLY REQUESTED.

47- Preserve User Content: If the input task or prompt includes extensive guidelines or examples, preserve them entirely, or as closely as possible. If they are vague, consider breaking down into sub-steps. Keep any details, guidelines, examples, variables, or placeholders provided by the user.

48- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.

49- Output Format: Explicitly the most appropriate output format, in detail. This should include length and syntax (e.g. short sentence, paragraph, JSON, etc.)

50 - For tasks outputting well-defined or structured data (classification, JSON, etc.) bias toward outputting a JSON.

51 - JSON should never be wrapped in code blocks (```) unless explicitly requested.

52 

53The final prompt you output should adhere to the following structure below. Do not include any additional commentary, only output the completed system prompt. SPECIFICALLY, do not include any additional messages at the start or end of the prompt. (e.g. no "---")

54 

55[Concise instruction describing the task - this should be the first line in the prompt, no section header]

56 

57[Additional details as needed.]

58 

59[Optional sections with headings or bullet points for detailed steps.]

60 

61# Steps [optional]

62 

63[optional: a detailed breakdown of the steps necessary to accomplish the task]

64 

65# Output Format

66 

67[Specifically call out how the output should be formatted, be it response length, structure e.g. JSON, markdown, etc]

68 

69# Examples [optional]

70 

71[Optional: 1-3 well-defined examples with placeholders if necessary. Clearly mark where examples start and end, and what the input and output are. User placeholders as necessary.]

72[If the examples are shorter than what a realistic example is expected to be, make a reference with () explaining how real examples should be longer / shorter / different. AND USE PLACEHOLDERS! ]

73 

74# Notes [optional]

75 

76[optional: edge cases, details, and an area to call or repeat out specific important considerations]

77""".strip()

78 

79def generate_prompt(task_or_prompt: str):

80 completion = client.chat.completions.create(

81 model="gpt-5.6",

82 messages=[

83 {

84 "role": "system",

85 "content": META_PROMPT,

86 },

87 {

88 "role": "user",

89 "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt,

90 },

91 ],

92 )

93 

94 return completion.choices[0].message.content

95```

96 

26 </div>97 </div>

27 <div data-content-switcher-pane data-value="audio-out" hidden>98 <div data-content-switcher-pane data-value="audio-out" hidden>

28 <div class="hidden">Audio-out</div>99 <div class="hidden">Audio-out</div>

100 Audio meta-prompt

101 

102```python

103from openai import OpenAI

104 

105client = OpenAI()

106 

107META_PROMPT = """

108Given a task description or existing prompt, produce a detailed system prompt to guide a realtime audio output language model in completing the task effectively.

109 

110# Guidelines

111 

112- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.

113- Tone: Make sure to specifically call out the tone. By default it should be emotive and friendly, and speak quickly to avoid keeping the user just waiting.

114- Audio Output Constraints: Because the model is outputting audio, the responses should be short and conversational.

115- Minimal Changes: If an existing prompt is provided, improve it only if it's simple. For complex prompts, enhance clarity and add missing elements without altering the original structure.

116- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.

117 - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.

118 - It is very important that any examples included reflect the short, conversational output responses of the model.

119Keep the sentences very short by default. Instead of 3 sentences in a row by the assistant, it should be split up with a back and forth with the user instead.

120 - By default each sentence should be a few words only (5-20ish words). However, if the user specifically asks for "short" responses, then the examples should truly have 1-10 word responses max.

121 - Make sure the examples are multi-turn (at least 4 back-forth-back-forth per example), not just one questions an response. They should reflect an organic conversation.

122- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.

123- Preserve User Content: If the input task or prompt includes extensive guidelines or examples, preserve them entirely, or as closely as possible. If they are vague, consider breaking down into sub-steps. Keep any details, guidelines, examples, variables, or placeholders provided by the user.

124- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.

125 

126The final prompt you output should adhere to the following structure below. Do not include any additional commentary, only output the completed system prompt. SPECIFICALLY, do not include any additional messages at the start or end of the prompt. (e.g. no "---")

127 

128[Concise instruction describing the task - this should be the first line in the prompt, no section header]

129 

130[Additional details as needed.]

131 

132[Optional sections with headings or bullet points for detailed steps.]

133 

134# Examples [optional]

135 

136[Optional: 1-3 well-defined examples with placeholders if necessary. Clearly mark where examples start and end, and what the input and output are. User placeholders as necessary.]

137[If the examples are shorter than what a realistic example is expected to be, make a reference with () explaining how real examples should be longer / shorter / different. AND USE PLACEHOLDERS! ]

138 

139# Notes [optional]

140 

141[optional: edge cases, details, and an area to call or repeat out specific important considerations]

142""".strip()

143 

144def generate_prompt(task_or_prompt: str):

145 completion = client.chat.completions.create(

146 model="gpt-5.6",

147 messages=[

148 {

149 "role": "system",

150 "content": META_PROMPT,

151 },

152 {

153 "role": "user",

154 "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt,

155 },

156 ],

157 )

158 

159 return completion.choices[0].message.content

160```

161 

29 </div>162 </div>

30 163 

31 164 

38 171 

39<div data-content-switcher-pane data-value="text-out">172<div data-content-switcher-pane data-value="text-out">

40 <div class="hidden">Text-out</div>173 <div class="hidden">Text-out</div>

174 Text meta-prompt for edits

175 

176```python

177from openai import OpenAI

178 

179client = OpenAI()

180 

181META_PROMPT = """

182Given a current prompt and a change description, produce a detailed system prompt to guide a language model in completing the task effectively.

183 

184Your final output will be the full corrected prompt verbatim. However, before that, at the very beginning of your response, use <reasoning> tags to analyze the prompt and determine the following, explicitly:

185<reasoning>

186- Simple Change: (yes/no) Is the change description explicit and simple? (If so, skip the rest of these questions.)

187- Reasoning: (yes/no) Does the current prompt use reasoning, analysis, or chain of thought?

188 - Identify: (max 10 words) if so, which section(s) utilize reasoning?

189 - Conclusion: (yes/no) is the chain of thought used to determine a conclusion?

190 - Ordering: (before/after) is the chain of though located before or after

191- Structure: (yes/no) does the input prompt have a well defined structure

192- Examples: (yes/no) does the input prompt have few-shot examples

193 - Representative: (1-5) if present, how representative are the examples?

194- Complexity: (1-5) how complex is the input prompt?

195 - Task: (1-5) how complex is the implied task?

196 - Necessity: ()

197- Specificity: (1-5) how detailed and specific is the prompt? (not to be confused with length)

198- Prioritization: (list) what 1-3 categories are the MOST important to address.

199- Conclusion: (max 30 words) given the previous assessment, give a very concise, imperative description of what should be changed and how. this does not have to adhere strictly to only the categories listed

200</reasoning>

201

202# Guidelines

203 

204- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.

205- Minimal Changes: If an existing prompt is provided, improve it only if it's simple. For complex prompts, enhance clarity and add missing elements without altering the original structure.

206- Reasoning Before Conclusions**: Encourage reasoning steps before any conclusions are reached. ATTENTION! If the user provides examples where the reasoning happens afterward, REVERSE the order! NEVER START EXAMPLES WITH CONCLUSIONS!

207 - Reasoning Order: Call out reasoning portions of the prompt and conclusion parts (specific fields by name). For each, determine the ORDER in which this is done, and whether it needs to be reversed.

208 - Conclusion, classifications, or results should ALWAYS appear last.

209- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.

210 - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.

211- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.

212- Formatting: Use markdown features for readability. DO NOT USE ``` CODE BLOCKS UNLESS SPECIFICALLY REQUESTED.

213- Preserve User Content: If the input task or prompt includes extensive guidelines or examples, preserve them entirely, or as closely as possible. If they are vague, consider breaking down into sub-steps. Keep any details, guidelines, examples, variables, or placeholders provided by the user.

214- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.

215- Output Format: Explicitly the most appropriate output format, in detail. This should include length and syntax (e.g. short sentence, paragraph, JSON, etc.)

216 - For tasks outputting well-defined or structured data (classification, JSON, etc.) bias toward outputting a JSON.

217 - JSON should never be wrapped in code blocks (```) unless explicitly requested.

218 

219The final prompt you output should adhere to the following structure below. Do not include any additional commentary, only output the completed system prompt. SPECIFICALLY, do not include any additional messages at the start or end of the prompt. (e.g. no "---")

220 

221[Concise instruction describing the task - this should be the first line in the prompt, no section header]

222 

223[Additional details as needed.]

224 

225[Optional sections with headings or bullet points for detailed steps.]

226 

227# Steps [optional]

228 

229[optional: a detailed breakdown of the steps necessary to accomplish the task]

230 

231# Output Format

232 

233[Specifically call out how the output should be formatted, be it response length, structure e.g. JSON, markdown, etc]

234 

235# Examples [optional]

236 

237[Optional: 1-3 well-defined examples with placeholders if necessary. Clearly mark where examples start and end, and what the input and output are. User placeholders as necessary.]

238[If the examples are shorter than what a realistic example is expected to be, make a reference with () explaining how real examples should be longer / shorter / different. AND USE PLACEHOLDERS! ]

239 

240# Notes [optional]

241 

242[optional: edge cases, details, and an area to call or repeat out specific important considerations]

243[NOTE: you must start with a <reasoning> section. the immediate next token you produce should be <reasoning>]

244""".strip()

245 

246def generate_prompt(task_or_prompt: str):

247 completion = client.chat.completions.create(

248 model="gpt-5.6",

249 messages=[

250 {

251 "role": "system",

252 "content": META_PROMPT,

253 },

254 {

255 "role": "user",

256 "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt,

257 },

258 ],

259 )

260 

261 return completion.choices[0].message.content

262```

263 

41 </div>264 </div>

42 <div data-content-switcher-pane data-value="audio-out" hidden>265 <div data-content-switcher-pane data-value="audio-out" hidden>

43 <div class="hidden">Audio-out</div>266 <div class="hidden">Audio-out</div>

267 Audio meta-prompt for edits

268 

269```python

270from openai import OpenAI

271 

272client = OpenAI()

273 

274META_PROMPT = """

275Given a current prompt and a change description, produce a detailed system prompt to guide a realtime audio output language model in completing the task effectively.

276 

277Your final output will be the full corrected prompt verbatim. However, before that, at the very beginning of your response, use <reasoning> tags to analyze the prompt and determine the following, explicitly:

278<reasoning>

279- Simple Change: (yes/no) Is the change description explicit and simple? (If so, skip the rest of these questions.)

280- Reasoning: (yes/no) Does the current prompt use reasoning, analysis, or chain of thought?

281 - Identify: (max 10 words) if so, which section(s) utilize reasoning?

282 - Conclusion: (yes/no) is the chain of thought used to determine a conclusion?

283 - Ordering: (before/after) is the chain of though located before or after

284- Structure: (yes/no) does the input prompt have a well defined structure

285- Examples: (yes/no) does the input prompt have few-shot examples

286 - Representative: (1-5) if present, how representative are the examples?

287- Complexity: (1-5) how complex is the input prompt?

288 - Task: (1-5) how complex is the implied task?

289 - Necessity: ()

290- Specificity: (1-5) how detailed and specific is the prompt? (not to be confused with length)

291- Prioritization: (list) what 1-3 categories are the MOST important to address.

292- Conclusion: (max 30 words) given the previous assessment, give a very concise, imperative description of what should be changed and how. this does not have to adhere strictly to only the categories listed

293</reasoning>

294 

295# Guidelines

296 

297- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.

298- Tone: Make sure to specifically call out the tone. By default it should be emotive and friendly, and speak quickly to avoid keeping the user just waiting.

299- Audio Output Constraints: Because the model is outputting audio, the responses should be short and conversational.

300- Minimal Changes: If an existing prompt is provided, improve it only if it's simple. For complex prompts, enhance clarity and add missing elements without altering the original structure.

301- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.

302 - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.

303 - It is very important that any examples included reflect the short, conversational output responses of the model.

304Keep the sentences very short by default. Instead of 3 sentences in a row by the assistant, it should be split up with a back and forth with the user instead.

305 - By default each sentence should be a few words only (5-20ish words). However, if the user specifically asks for "short" responses, then the examples should truly have 1-10 word responses max.

306 - Make sure the examples are multi-turn (at least 4 back-forth-back-forth per example), not just one questions an response. They should reflect an organic conversation.

307- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.

308- Preserve User Content: If the input task or prompt includes extensive guidelines or examples, preserve them entirely, or as closely as possible. If they are vague, consider breaking down into sub-steps. Keep any details, guidelines, examples, variables, or placeholders provided by the user.

309- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.

310 

311The final prompt you output should adhere to the following structure below. Do not include any additional commentary, only output the completed system prompt. SPECIFICALLY, do not include any additional messages at the start or end of the prompt. (e.g. no "---")

312 

313[Concise instruction describing the task - this should be the first line in the prompt, no section header]

314 

315[Additional details as needed.]

316 

317[Optional sections with headings or bullet points for detailed steps.]

318 

319# Examples [optional]

320 

321[Optional: 1-3 well-defined examples with placeholders if necessary. Clearly mark where examples start and end, and what the input and output are. User placeholders as necessary.]

322[If the examples are shorter than what a realistic example is expected to be, make a reference with () explaining how real examples should be longer / shorter / different. AND USE PLACEHOLDERS! ]

323 

324# Notes [optional]

325 

326[optional: edge cases, details, and an area to call or repeat out specific important considerations]

327[NOTE: you must start with a <reasoning> section. the immediate next token you produce should be <reasoning>]

328""".strip()

329 

330def generate_prompt(task_or_prompt: str):

331 completion = client.chat.completions.create(

332 model="gpt-5.6",

333 messages=[

334 {

335 "role": "system",

336 "content": META_PROMPT,

337 },

338 {

339 "role": "user",

340 "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt,

341 },

342 ],

343 )

344 

345 return completion.choices[0].message.content

346```

347 

44 </div>348 </div>

45 349 

46 350 

101 405 

102<div data-content-switcher-pane data-value="structured-output">406<div data-content-switcher-pane data-value="structured-output">

103 <div class="hidden">Structured output schema</div>407 <div class="hidden">Structured output schema</div>

408 Structured output meta-schema

409 

410```python

411from openai import OpenAI

412import json

413 

414client = OpenAI()

415 

416META_SCHEMA = {

417 "name": "metaschema",

418 "schema": {

419 "type": "object",

420 "properties": {

421 "name": {

422 "type": "string",

423 "description": "The name of the schema"

424 },

425 "type": {

426 "type": "string",

427 "enum": [

428 "object",

429 "array",

430 "string",

431 "number",

432 "boolean",

433 "null"

434 ]

435 },

436 "properties": {

437 "type": "object",

438 "additionalProperties": {

439 "$ref": "#/$defs/schema_definition"

440 }

441 },

442 "items": {

443 "anyOf": [

444 {

445 "$ref": "#/$defs/schema_definition"

446 },

447 {

448 "type": "array",

449 "items": {

450 "$ref": "#/$defs/schema_definition"

451 }

452 }

453 ]

454 },

455 "required": {

456 "type": "array",

457 "items": {

458 "type": "string"

459 }

460 },

461 "additionalProperties": {

462 "type": "boolean"

463 }

464 },

465 "required": [

466 "type"

467 ],

468 "additionalProperties": False,

469 "if": {

470 "properties": {

471 "type": {

472 "const": "object"

473 }

474 }

475 },

476 "then": {

477 "required": [

478 "properties"

479 ]

480 },

481 "$defs": {

482 "schema_definition": {

483 "type": "object",

484 "properties": {

485 "type": {

486 "type": "string",

487 "enum": [

488 "object",

489 "array",

490 "string",

491 "number",

492 "boolean",

493 "null"

494 ]

495 },

496 "properties": {

497 "type": "object",

498 "additionalProperties": {

499 "$ref": "#/$defs/schema_definition"

500 }

501 },

502 "items": {

503 "anyOf": [

504 {

505 "$ref": "#/$defs/schema_definition"

506 },

507 {

508 "type": "array",

509 "items": {

510 "$ref": "#/$defs/schema_definition"

511 }

512 }

513 ]

514 },

515 "required": {

516 "type": "array",

517 "items": {

518 "type": "string"

519 }

520 },

521 "additionalProperties": {

522 "type": "boolean"

523 }

524 },

525 "required": [

526 "type"

527 ],

528 "additionalProperties": False,

529 "if": {

530 "properties": {

531 "type": {

532 "const": "object"

533 }

534 }

535 },

536 "then": {

537 "required": [

538 "properties"

539 ]

540 }

541 }

542 }

543 }

544}

545 

546META_PROMPT = """

547# Instructions

548Return a valid schema for the described JSON.

549 

550You must also make sure:

551- all fields in an object are set as required

552- I REPEAT, ALL FIELDS MUST BE MARKED AS REQUIRED

553- all objects must have additionalProperties set to false

554 - because of this, some cases like "attributes" or "metadata" properties that would normally allow additional properties should instead have a fixed set of properties

555- all objects must have properties defined

556- field order matters. any form of "thinking" or "explanation" should come before the conclusion

557- $defs must be defined under the schema param

558 

559Notable keywords NOT supported include:

560- For objects: unevaluatedProperties, propertyNames, minProperties, maxProperties

561- For arrays: unevaluatedItems, contains, minContains, maxContains, uniqueItems

562 

563Other notes:

564- definitions and recursion are supported

565- only if necessary to include references e.g. "$defs", it must be inside the "schema" object

566 

567# Examples

568Input: Generate a math reasoning schema with steps and a final answer.

569Output: {

570 "name": "math_reasoning",

571 "type": "object",

572 "properties": {

573 "steps": {

574 "type": "array",

575 "description": "A sequence of steps involved in solving the math problem.",

576 "items": {

577 "type": "object",

578 "properties": {

579 "explanation": {

580 "type": "string",

581 "description": "Description of the reasoning or method used in this step."

582 },

583 "output": {

584 "type": "string",

585 "description": "Result or outcome of this specific step."

586 }

587 },

588 "required": [

589 "explanation",

590 "output"

591 ],

592 "additionalProperties": false

593 }

594 },

595 "final_answer": {

596 "type": "string",

597 "description": "The final solution or answer to the math problem."

598 }

599 },

600 "required": [

601 "steps",

602 "final_answer"

603 ],

604 "additionalProperties": false

605}

606 

607Input: Give me a linked list

608Output: {

609 "name": "linked_list",

610 "type": "object",

611 "properties": {

612 "linked_list": {

613 "$ref": "#/$defs/linked_list_node",

614 "description": "The head node of the linked list."

615 }

616 },

617 "$defs": {

618 "linked_list_node": {

619 "type": "object",

620 "description": "Defines a node in a singly linked list.",

621 "properties": {

622 "value": {

623 "type": "number",

624 "description": "The value stored in this node."

625 },

626 "next": {

627 "anyOf": [

628 {

629 "$ref": "#/$defs/linked_list_node"

630 },

631 {

632 "type": "null"

633 }

634 ],

635 "description": "Reference to the next node; null if it is the last node."

636 }

637 },

638 "required": [

639 "value",

640 "next"

641 ],

642 "additionalProperties": false

643 }

644 },

645 "required": [

646 "linked_list"

647 ],

648 "additionalProperties": false

649}

650 

651Input: Dynamically generated UI

652Output: {

653 "name": "ui",

654 "type": "object",

655 "properties": {

656 "type": {

657 "type": "string",

658 "description": "The type of the UI component",

659 "enum": [

660 "div",

661 "button",

662 "header",

663 "section",

664 "field",

665 "form"

666 ]

667 },

668 "label": {

669 "type": "string",

670 "description": "The label of the UI component, used for buttons or form fields"

671 },

672 "children": {

673 "type": "array",

674 "description": "Nested UI components",

675 "items": {

676 "$ref": "#"

677 }

678 },

679 "attributes": {

680 "type": "array",

681 "description": "Arbitrary attributes for the UI component, suitable for any element",

682 "items": {

683 "type": "object",

684 "properties": {

685 "name": {

686 "type": "string",

687 "description": "The name of the attribute, for example onClick or className"

688 },

689 "value": {

690 "type": "string",

691 "description": "The value of the attribute"

692 }

693 },

694 "required": [

695 "name",

696 "value"

697 ],

698 "additionalProperties": false

699 }

700 }

701 },

702 "required": [

703 "type",

704 "label",

705 "children",

706 "attributes"

707 ],

708 "additionalProperties": false

709}

710""".strip()

711 

712def generate_schema(description: str):

713 completion = client.chat.completions.create(

714 model="gpt-5.6-terra",

715 response_format={"type": "json_schema", "json_schema": META_SCHEMA},

716 messages=[

717 {

718 "role": "system",

719 "content": META_PROMPT,

720 },

721 {

722 "role": "user",

723 "content": "Description:\n" + description,

724 },

725 ],

726 )

727 

728 return json.loads(completion.choices[0].message.content)

729```

730 

104 </div>731 </div>

105 <div data-content-switcher-pane data-value="function" hidden>732 <div data-content-switcher-pane data-value="function" hidden>

106 <div class="hidden">Function schema</div>733 <div class="hidden">Function schema</div>

734 Structured output meta-schema

735 

736```python

737from openai import OpenAI

738import json

739 

740client = OpenAI()

741 

742META_SCHEMA = {

743 "name": "function-metaschema",

744 "schema": {

745 "type": "object",

746 "properties": {

747 "name": {

748 "type": "string",

749 "description": "The name of the function"

750 },

751 "description": {

752 "type": "string",

753 "description": "A description of what the function does"

754 },

755 "parameters": {

756 "$ref": "#/$defs/schema_definition",

757 "description": "A JSON schema that defines the function's parameters"

758 }

759 },

760 "required": [

761 "name",

762 "description",

763 "parameters"

764 ],

765 "additionalProperties": False,

766 "$defs": {

767 "schema_definition": {

768 "type": "object",

769 "properties": {

770 "type": {

771 "type": "string",

772 "enum": [

773 "object",

774 "array",

775 "string",

776 "number",

777 "boolean",

778 "null"

779 ]

780 },

781 "properties": {

782 "type": "object",

783 "additionalProperties": {

784 "$ref": "#/$defs/schema_definition"

785 }

786 },

787 "items": {

788 "anyOf": [

789 {

790 "$ref": "#/$defs/schema_definition"

791 },

792 {

793 "type": "array",

794 "items": {

795 "$ref": "#/$defs/schema_definition"

796 }

797 }

798 ]

799 },

800 "required": {

801 "type": "array",

802 "items": {

803 "type": "string"

804 }

805 },

806 "additionalProperties": {

807 "type": "boolean"

808 }

809 },

810 "required": [

811 "type"

812 ],

813 "additionalProperties": False,

814 "if": {

815 "properties": {

816 "type": {

817 "const": "object"

818 }

819 }

820 },

821 "then": {

822 "required": [

823 "properties"

824 ]

825 }

826 }

827 }

828 }

829}

830 

831META_PROMPT = """

832# Instructions

833Return a valid schema for the described function.

834 

835Pay special attention to making sure that "required" and "type" are always at the correct level of nesting. For example, "required" should be at the same level as "properties", not inside it.

836Make sure that every property, no matter how short, has a type and description correctly nested inside it.

837 

838# Examples

839Input: Assign values to NN hyperparameters

840Output: {

841 "name": "set_hyperparameters",

842 "description": "Assign values to NN hyperparameters",

843 "parameters": {

844 "type": "object",

845 "required": [

846 "learning_rate",

847 "epochs"

848 ],

849 "properties": {

850 "epochs": {

851 "type": "number",

852 "description": "Number of complete passes through dataset"

853 },

854 "learning_rate": {

855 "type": "number",

856 "description": "Speed of model learning"

857 }

858 }

859 }

860}

861 

862Input: Plans a motion path for the robot

863Output: {

864 "name": "plan_motion",

865 "description": "Plans a motion path for the robot",

866 "parameters": {

867 "type": "object",

868 "required": [

869 "start_position",

870 "end_position"

871 ],

872 "properties": {

873 "end_position": {

874 "type": "object",

875 "properties": {

876 "x": {

877 "type": "number",

878 "description": "End X coordinate"

879 },

880 "y": {

881 "type": "number",

882 "description": "End Y coordinate"

883 }

884 }

885 },

886 "obstacles": {

887 "type": "array",

888 "description": "Array of obstacle coordinates",

889 "items": {

890 "type": "object",

891 "properties": {

892 "x": {

893 "type": "number",

894 "description": "Obstacle X coordinate"

895 },

896 "y": {

897 "type": "number",

898 "description": "Obstacle Y coordinate"

899 }

900 }

901 }

902 },

903 "start_position": {

904 "type": "object",

905 "properties": {

906 "x": {

907 "type": "number",

908 "description": "Start X coordinate"

909 },

910 "y": {

911 "type": "number",

912 "description": "Start Y coordinate"

913 }

914 }

915 }

916 }

917 }

918}

919 

920Input: Calculates various technical indicators

921Output: {

922 "name": "technical_indicator",

923 "description": "Calculates various technical indicators",

924 "parameters": {

925 "type": "object",

926 "required": [

927 "ticker",

928 "indicators"

929 ],

930 "properties": {

931 "indicators": {

932 "type": "array",

933 "description": "List of technical indicators to calculate",

934 "items": {

935 "type": "string",

936 "description": "Technical indicator",

937 "enum": [

938 "RSI",

939 "MACD",

940 "Bollinger_Bands",

941 "Stochastic_Oscillator"

942 ]

943 }

944 },

945 "period": {

946 "type": "number",

947 "description": "Time period for the analysis"

948 },

949 "ticker": {

950 "type": "string",

951 "description": "Stock ticker symbol"

952 }

953 }

954 }

955}

956""".strip()

957 

958def generate_function_schema(description: str):

959 completion = client.chat.completions.create(

960 model="gpt-5.6-terra",

961 response_format={"type": "json_schema", "json_schema": META_SCHEMA},

962 messages=[

963 {

964 "role": "system",

965 "content": META_PROMPT,

966 },

967 {

968 "role": "user",

969 "content": "Description:\n" + description,

970 },

971 ],

972 )

973 

974 return json.loads(completion.choices[0].message.content)

975```

976 

107 </div>977 </div>

70 70 

71The fine-tuning rate limits for your organization can be [found in the dashboard as well](https://platform.openai.com/settings/organization/limits), and can also be retrieved via API:71The fine-tuning rate limits for your organization can be [found in the dashboard as well](https://platform.openai.com/settings/organization/limits), and can also be retrieved via API:

72 72 

73```bash

74curl https://api.openai.com/v1/fine_tuning/model_limits \

75 -H "Authorization: Bearer $OPENAI_API_KEY"

76```

77 

78 

73## Error mitigation79## Error mitigation

74 80 

75### What are some steps I can take to mitigate this?81### What are some steps I can take to mitigate this?

98Tenacity is an Apache 2.0 licensed general-purpose retrying library, written in Python, to simplify the task of adding retry behavior to just about anything.104Tenacity is an Apache 2.0 licensed general-purpose retrying library, written in Python, to simplify the task of adding retry behavior to just about anything.

99To add exponential backoff to your requests, you can use the `tenacity.retry` decorator. The below example uses the `tenacity.wait_random_exponential` function to add random exponential backoff to a request.105To add exponential backoff to your requests, you can use the `tenacity.retry` decorator. The below example uses the `tenacity.wait_random_exponential` function to add random exponential backoff to a request.

100 106 

107Using the Tenacity library

108 

109```python

110from openai import OpenAI

111client = OpenAI()

112 

113from tenacity import (

114retry,

115stop_after_attempt,

116wait_random_exponential,

117) # for exponential backoff

118 

119@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))

120def completion_with_backoff(**kwargs):

121return client.completions.create(**kwargs)

122 

123completion_with_backoff(model="gpt-3.5-turbo-instruct", prompt="Once upon a time,")

124```

125 

126 

101Note that the Tenacity library is a third-party tool, and OpenAI makes no guarantees about127Note that the Tenacity library is a third-party tool, and OpenAI makes no guarantees about

102its reliability or security.128its reliability or security.

103 129 

105 131 

106Another python library that provides function decorators for backoff and retry is [backoff](https://pypi.org/project/backoff/):132Another python library that provides function decorators for backoff and retry is [backoff](https://pypi.org/project/backoff/):

107 133 

134Using the Tenacity library

135 

136```python

137import backoff

138import openai

139from openai import OpenAI

140client = OpenAI()

141 

142@backoff.on_exception(backoff.expo, openai.RateLimitError)

143def completions_with_backoff(**kwargs):

144return client.completions.create(**kwargs)

145 

146completions_with_backoff(model="gpt-3.5-turbo-instruct", prompt="Once upon a time,")

147```

148 

149 

108Like Tenacity, the backoff library is a third-party tool, and OpenAI makes no guarantees about its reliability or security.150Like Tenacity, the backoff library is a third-party tool, and OpenAI makes no guarantees about its reliability or security.

109 151 

110Example 3: Manual backoff implementation152Example 3: Manual backoff implementation

111 153 

112If you don't want to use third-party libraries, you can implement your own backoff logic following this example:154If you don't want to use third-party libraries, you can implement your own backoff logic following this example:

155Using manual backoff implementation

156 

157```python

158# imports

159import random

160import time

161 

162import openai

163from openai import OpenAI

164client = OpenAI()

165 

166# define a retry decorator

167 

168def retry_with_exponential_backoff(

169func,

170initial_delay: float = 1,

171exponential_base: float = 2,

172jitter: bool = True,

173max_retries: int = 10,

174errors: tuple = (openai.RateLimitError,),

175):

176"""Retry a function with exponential backoff."""

177 

178 def wrapper(*args, **kwargs):

179 # Initialize variables

180 num_retries = 0

181 delay = initial_delay

182 

183 # Loop until a successful response or max_retries is hit or an exception is raised

184 while True:

185 try:

186 return func(*args, **kwargs)

187