Documentation 2026-07-31 21:03 UTC to 2026-08-03 18:01 UTC

59```javascript59```javascript

60const assistant = await openai.beta.assistants.create({60const assistant = await openai.beta.assistants.create({

61 name: "Data visualizer",61 name: "Data visualizer",

62 description: "You are great at creating beautiful data visualizations. You analyze data present in .csv files, understand trends, and come up with data visualizations relevant to those trends. You also share a brief text summary of the trends observed.",62 description:

63 "You are great at creating beautiful data visualizations. You analyze data present in .csv files, understand trends, and come up with data visualizations relevant to those trends. You also share a brief text summary of the trends observed.",

63 model: "gpt-4o",64 model: "gpt-4o",

64 tools: [{"type": "code_interpreter"}],65 tools: [{ type: "code_interpreter" }],

65 tool_resources: {66 tool_resources: {

66 "code_interpreter": {67 code_interpreter: {

67 "file_ids": [file.id]68 file_ids: [file.id],

68 }69 },

69 }70 },

70});71});

71```72```

72 73 

117const thread = await openai.beta.threads.create({118const thread = await openai.beta.threads.create({

118 messages: [119 messages: [

119 {120 {

120 "role": "user",121 role: "user",

121 "content": "Create 3 data visualizations based on the trends in this file.",122 content: "Create 3 data visualizations based on the trends in this file.",

122 "attachments": [123 attachments: [

123 {124 {

124 file_id: file.id,125 file_id: file.id,

125 tools: [{type: "code_interpreter"}]126 tools: [{ type: "code_interpreter" }],

126 }127 },

127 ]128 ],

128 }129 },

129 ]130 ],

130});131});

131```132```

132 133 

194const thread = await openai.beta.threads.create({195const thread = await openai.beta.threads.create({

195 messages: [196 messages: [

196 {197 {

197 "role": "user",198 role: "user",

198 "content": [199 content: [

199 {200 {

200 "type": "text",201 type: "text",

201 "text": "What is the difference between these images?"202 text: "What is the difference between these images?",

202 },203 },

203 {204 {

204 "type": "image_url",205 type: "image_url",

205 "image_url": {"url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"}206 image_url: {

207 url: "https://openai-documentation.vercel.app/images/cat_and_otter.png",

208 },

206 },209 },

207 {210 {

208 "type": "image_file",211 type: "image_file",

209 "image_file": {"file_id": file.id}212 image_file: { file_id: file.id },

210 },213 },

211 ]214 ],

212 }215 },

213 ]216 ],

214});217});

215```218```

216 219 

282const thread = await openai.beta.threads.create({285const thread = await openai.beta.threads.create({

283 messages: [286 messages: [

284 {287 {

285 "role": "user",288 role: "user",

286 "content": [289 content: [

287 {290 {

288 "type": "text",291 type: "text",

289 "text": "What is this an image of?"292 text: "What is this an image of?",

290 },293 },

291 {294 {

292 "type": "image_url",295 type: "image_url",

293 "image_url": {296 image_url: {

294 "url": "https://openai-documentation.vercel.app/images/cat_and_otter.png",297 url: "https://openai-documentation.vercel.app/images/cat_and_otter.png",

295 "detail": "high"298 detail: "high",

296 }

297 },299 },

298 ]300 },

299 }301 ],

300 ]302 },

303 ],

301});304});

302```305```

303 306 

420```423```

421 424 

422```javascript425```javascript

423const run = await openai.beta.threads.runs.create(426const run = await openai.beta.threads.runs.create(thread.id, {

424 thread.id,427 assistant_id: assistant.id,

425 { assistant_id: assistant.id }428});

426);

427```429```

428 430 

429```bash431```bash

450```452```

451 453 

452```javascript454```javascript

453const run = await openai.beta.threads.runs.create(455const run = await openai.beta.threads.runs.create(thread.id, {

454 thread.id,

455 {

456 assistant_id: assistant.id,456 assistant_id: assistant.id,

457 model: "gpt-4o",457 model: "gpt-4o",

458 instructions: "New instructions that override the Assistant instructions",458 instructions: "New instructions that override the Assistant instructions",

459 tools: [{"type": "code_interpreter"}, {"type": "file_search"}]459 tools: [{ type: "code_interpreter" }, { type: "file_search" }],

460 }460});

461);

462```461```

463 462 

464```bash463```bash

28 28 

29```javascript29```javascript

30const assistant = await openai.beta.assistants.create({30const assistant = await openai.beta.assistants.create({

31 instructions: "You are a personal math tutor. When asked a math question, write and run code to answer the question.",31 instructions:

32 "You are a personal math tutor. When asked a math question, write and run code to answer the question.",

32 model: "gpt-4o",33 model: "gpt-4o",

33 tools: [{"type": "code_interpreter"}]34 tools: [{ type: "code_interpreter" }],

34});35});

35```36```

36 37 

77 78 

78// Create an assistant using the file ID79// Create an assistant using the file ID

79const assistant = await openai.beta.assistants.create({80const assistant = await openai.beta.assistants.create({

80 instructions: "You are a personal math tutor. When asked a math question, write and run code to answer the question.",81 instructions:

82 "You are a personal math tutor. When asked a math question, write and run code to answer the question.",

81 model: "gpt-4o",83 model: "gpt-4o",

82 tools: [{"type": "code_interpreter"}],84 tools: [{ type: "code_interpreter" }],

83 tool_resources: {85 tool_resources: {

84 "code_interpreter": {86 code_interpreter: {

85 "file_ids": [file.id]87 file_ids: [file.id],

86 }88 },

87 }89 },

88});90});

89```91```

90 92 

133const thread = await openai.beta.threads.create({135const thread = await openai.beta.threads.create({

134 messages: [136 messages: [

135 {137 {

136 "role": "user",138 role: "user",

137 "content": "I need to solve the equation `3x + 11 = 14`. Can you help me?",139 content: "I need to solve the equation `3x + 11 = 14`. Can you help me?",

138 "attachments": [140 attachments: [

139 {141 {

140 file_id: file.id,142 file_id: file.id,

141 tools: [{type: "code_interpreter"}]143 tools: [{ type: "code_interpreter" }],

142 }144 },

143 ]145 ],

144 }146 },

145 ]147 ],

146});148});

147```149```

148 150 

284```286```

285 287 

286```javascript288```javascript

287const runSteps = await openai.beta.threads.runs.steps.list(289const runSteps = await openai.beta.threads.runs.steps.list(run.id, {

288 thread.id,290 thread_id: thread.id,

289 run.id291});

290);

291```292```

292 293 

293```bash294```bash

34const openai = new OpenAI();34const openai = new OpenAI();

35 35 

36async function main() {36async function main() {

37const assistant = await openai.beta.assistants.create({37 const assistant = await openai.beta.assistants.create({

38name: "Financial Analyst Assistant",38 name: "Financial Analyst Assistant",

39instructions: "You are an expert financial analyst. Use you knowledge base to answer questions about audited financial statements.",39 instructions:

40model: "gpt-4o",40 "You are an expert financial analyst. Use you knowledge base to answer questions about audited financial statements.",

41tools: [{ type: "file_search" }],41 model: "gpt-4o",

42});42 tools: [{ type: "file_search" }],

43 });

43}44}

44 45 

45main();46main();

92```93```

93 94 

94```javascript95```javascript

95const fileStreams = ["edgar/goog-10k.pdf", "edgar/brka-10k.txt"].map((path) =>96const fileStreams = [

96fs.createReadStream(path),97 fs.createReadStream("edgar/goog-10k.pdf"),

97);98 fs.createReadStream("edgar/brka-10k.txt"),

99];

98 100 

99// Create a vector store including our two files.101// Create a vector store including our two files.

100let vectorStore = await openai.vectorStores.create({102let vectorStore = await openai.vectorStores.create({

101name: "Financial Statement",103 name: "Financial Statement",

102});104});

103 105 

104await openai.vectorStores.fileBatches.uploadAndPoll(vectorStore.id, fileStreams)106await openai.vectorStores.fileBatches.uploadAndPoll(vectorStore.id, {

107 files: fileStreams,

108});

105```109```

106 110 

107 111 

157```javascript161```javascript

158// A user wants to attach a file to a specific message, let's upload it.162// A user wants to attach a file to a specific message, let's upload it.

159const aapl10k = await openai.files.create({163const aapl10k = await openai.files.create({

160file: fs.createReadStream("edgar/aapl-10k.pdf"),164 file: fs.createReadStream("edgar/aapl-10k.pdf"),

161purpose: "assistants",165 purpose: "assistants",

162});166});

163 167 

164const thread = await openai.beta.threads.create({168const thread = await openai.beta.threads.create({

165messages: [169 messages: [

166{170 {

167role: "user",171 role: "user",

168content:172 content:

169"How many shares of AAPL were outstanding at the end of of October 2023?",173 "How many shares of AAPL were outstanding at the end of October 2023?",

170// Attach the new file to the message.174 // Attach the new file to the message.

171attachments: [{ file_id: aapl10k.id, tools: [{ type: "file_search" }] }],175 attachments: [{ file_id: aapl10k.id, tools: [{ type: "file_search" }] }],

172},176 },

173],177 ],

174});178});

175 179 

176// The thread now has a vector store in its tool resources.180// The thread now has a vector store in its tool resources.

235 stream.until_done()239 stream.until_done()

236```240```

237 241 

238```javascript242```typescript

239const stream = openai.beta.threads.runs243const stream = openai.beta.threads.runs

240.stream(thread.id, {244 .stream(thread.id, {

241assistant_id: assistant.id,245 assistant_id: assistant.id,

242})246 })

243.on("textCreated", () => console.log("assistant >"))247 .on("textCreated", () => console.log("assistant >"))

244.on("toolCallCreated", (event) => console.log("assistant " + event.type))248 .on("toolCallCreated", (event) => console.log("assistant " + event.type))

245.on("messageDone", async (event) => {249 .on("messageDone", async (event) => {

246if (event.content[0].type === "text") {250 if (event.content[0].type === "text") {

247const { text } = event.content[0];251 const { text } = event.content[0];

248const { annotations } = text;252 const { annotations } = text;

249const citations: string[] = [];253 const citations: string[] = [];

250 254 

251 let index = 0;255 let index = 0;

252 for (let annotation of annotations) {256 for (const annotation of annotations) {

253 text.value = text.value.replace(annotation.text, "[" + index + "]");257 text.value = text.value.replace(annotation.text, `[${index}]`);

254 const { file_citation } = annotation;258 if (annotation.type === "file_citation") {

255 if (file_citation) {259 const citedFile = await openai.files.retrieve(

256 const citedFile = await openai.files.retrieve(file_citation.file_id);260 annotation.file_citation.file_id

257 citations.push("[" + index + "]" + citedFile.filename);261 );

262 citations.push(`[${index}]${citedFile.filename}`);

258 }263 }

259 index++;264 index++;

260 }265 }

262 console.log(text.value);267 console.log(text.value);

263 console.log(citations.join("\n"));268 console.log(citations.join("\n"));

264 }269 }

270 });

265```271```

266 272 

267 273

299print("\n".join(citations))305print("\n".join(citations))

300```306```

301 307 

302```javascript308```typescript

303const run = await openai.beta.threads.runs.createAndPoll(thread.id, {309const run = await openai.beta.threads.runs.createAndPoll(thread.id, {

304assistant_id: assistant.id,310 assistant_id: assistant.id,

305});311});

306 312 

307const messages = await openai.beta.threads.messages.list(thread.id, {313const messages = await openai.beta.threads.messages.list(thread.id, {

308run_id: run.id,314 run_id: run.id,

309});315});

310 316 

311const message = messages.data.pop()!;317const message = messages.data.pop()!;

312if (message.content[0].type === "text") {318if (message.content[0].type === "text") {

313const { text } = message.content[0];319 const { text } = message.content[0];

314const { annotations } = text;320 const { annotations } = text;

315const citations: string[] = [];321 const citations: string[] = [];

316 322 

317let index = 0;323 let index = 0;

318for (let annotation of annotations) {324 for (const annotation of annotations) {

319text.value = text.value.replace(annotation.text, "[" + index + "]");325 text.value = text.value.replace(annotation.text, `[${index}]`);

320const { file_citation } = annotation;326 if (annotation.type === "file_citation") {

321if (file_citation) {327 const citedFile = await openai.files.retrieve(

322const citedFile = await openai.files.retrieve(file_citation.file_id);328 annotation.file_citation.file_id

323citations.push("[" + index + "]" + citedFile.filename);329 );

324}330 citations.push(`[${index}]${citedFile.filename}`);

325index++;331 }

326}332 index++;

333 }

327 334 

328console.log(text.value);335 console.log(text.value);

329console.log(citations.join("\n"));336 console.log(citations.join("\n"));

330}337}

331```338```

332 339 

389```javascript396```javascript

390const vectorStore = await openai.vectorStores.create({397const vectorStore = await openai.vectorStores.create({

391 name: "Product Documentation",398 name: "Product Documentation",

392 file_ids: ['file_1', 'file_2', 'file_3', 'file_4', 'file_5']399 file_ids: [

400 "file_1",

401 "file_2",

402 "file_3",

403 "file_4",

404 "file_5",

405 ],

393});406});

394```407```

395 408 

409```javascript422```javascript

410const file = await openai.vectorStores.files.createAndPoll(423const file = await openai.vectorStores.files.createAndPoll(

411 "vs_abc123",424 "vs_abc123",

412 { file_id: "file-abc123" }425 {

426 file_id: "file-abc123",

427 }

413);428);

414```429```

415 430 

450 file_id: "file_2",465 file_id: "file_2",

451 chunking_strategy: {466 chunking_strategy: {

452 type: "static",467 type: "static",

468 static: {

453 max_chunk_size_tokens: 1000,469 max_chunk_size_tokens: 1000,

454 chunk_overlap_tokens: 200,470 chunk_overlap_tokens: 200,

455 },471 },

456 },472 },

457 ],

458 },473 },

474 ],

475 }

459);476);

460```477```

461 478 

489 506 

490```javascript507```javascript

491const assistant = await openai.beta.assistants.create({508const assistant = await openai.beta.assistants.create({

492instructions: "You are a helpful product support assistant and you answer questions based on the files provided to you.",509 instructions:

493model: "gpt-4o",510 "You are a helpful product support assistant and you answer questions based on the files provided to you.",

494tools: [{"type": "file_search"}],511 model: "gpt-4o",

495tool_resources: {512 tools: [{ type: "file_search" }],

496"file_search": {513 tool_resources: {

497"vector_store_ids": ["vs_1"]514 file_search: {

498}515 vector_store_ids: ["vs_1"],

499}516 },

517 },

500});518});

501 519 

502const thread = await openai.beta.threads.create({520const thread = await openai.beta.threads.create({

503messages: [ { role: "user", content: "How do I cancel my subscription?"} ],521 messages: [{ role: "user", content: "How do I cancel my subscription?" }],

504tool_resources: {522 tool_resources: {

505"file_search": {523 file_search: {

506"vector_store_ids": ["vs_2"]524 vector_store_ids: ["vs_2"],

507}525 },

508}526 },

509});527});

510```528```

511 529 

573 591 

574const openai = new OpenAI();592const openai = new OpenAI();

575 593 

576const runStep = await openai.beta.threads.runs.steps.retrieve(594const runStep = await openai.beta.threads.runs.steps.retrieve("step_abc123", {

577"thread_abc123",595 thread_id: "thread_abc123",

578"run_abc123",596 run_id: "run_abc123",

579"step_abc123",597 include: ["step_details.tool_calls[*].file_search.results[*].content"],

580{598});

581include: ["step_details.tool_calls[*].file_search.results[*].content"]

582}

583);

584 599 

585console.log(runStep);600console.log(runStep);

586```601```

633```javascript648```javascript

634let vectorStore = await openai.vectorStores.create({649let vectorStore = await openai.vectorStores.create({

635 name: "rag-store",650 name: "rag-store",

636 file_ids: ['file_1', 'file_2', 'file_3', 'file_4', 'file_5'],651 file_ids: [

652 "file_1",

653 "file_2",

654 "file_3",

655 "file_4",

656 "file_5",

657 ],

637 expires_after: {658 expires_after: {

638 anchor: "last_active_at",659 anchor: "last_active_at",

639 days: 7660 days: 7,

640 }661 },

641});662});

642```663```

643 664 

667```javascript688```javascript

668const fileIds = [];689const fileIds = [];

669for await (const file of openai.vectorStores.files.list(690for await (const file of openai.vectorStores.files.list(

670"vs_expired",691 "vs_expired"

671)) {692)) {

672fileIds.push(file.id);693 fileIds.push(file.id);

673}694}

674 695 

675const vectorStore = await openai.vectorStores.create({696const vectorStore = await openai.vectorStores.create({

676name: "rag-store",697 name: "rag-store",

677});698});

678await openai.beta.threads.update("thread_abc123", {699await openai.beta.threads.update("thread_abc123", {

679tool_resources: { file_search: { vector_store_ids: [vectorStore.id] } },700 tool_resources: { file_search: { vector_store_ids: [vectorStore.id] } },

680});701});

681 702 

682for (const fileBatch of _.chunk(fileIds, 100)) {703for (const fileBatch of _.chunk(fileIds, 100)) {

683await openai.vectorStores.fileBatches.create(vectorStore.id, {704 await openai.vectorStores.fileBatches.create(vectorStore.id, {

684file_ids: fileBatch,705 file_ids: fileBatch,

685});706 });

686}707}

687```708```

688 709 

82 82 

83```javascript83```javascript

84const assistant = await client.beta.assistants.create({84const assistant = await client.beta.assistants.create({

85model: "gpt-4o",85 model: "gpt-4o",

86instructions:86 instructions:

87"You are a weather bot. Use the provided functions to answer questions.",87 "You are a weather bot. Use the provided functions to answer questions.",

88tools: [88 tools: [

89{89 {

90type: "function",90 type: "function",

91function: {91 function: {

92name: "getCurrentTemperature",92 name: "getCurrentTemperature",

93description: "Get the current temperature for a specific location",93 description: "Get the current temperature for a specific location",

94parameters: {94 parameters: {

95type: "object",95 type: "object",

96properties: {96 properties: {

97location: {97 location: {

98type: "string",98 type: "string",

99description: "The city and state, e.g., San Francisco, CA",99 description: "The city and state, e.g., San Francisco, CA",

100},100 },

101unit: {101 unit: {

102type: "string",102 type: "string",

103enum: ["Celsius", "Fahrenheit"],103 enum: ["Celsius", "Fahrenheit"],

104description:104 description:

105"The temperature unit to use. Infer this from the user's location.",105 "The temperature unit to use. Infer this from the user's location.",

106},106 },

107},107 },

108required: ["location", "unit"],108 required: ["location", "unit"],

109},109 },

110},110 },

111},111 },

112{112 {

113type: "function",113 type: "function",

114function: {114 function: {

115name: "getRainProbability",115 name: "getRainProbability",

116description: "Get the probability of rain for a specific location",116 description: "Get the probability of rain for a specific location",

117parameters: {117 parameters: {

118type: "object",118 type: "object",

119properties: {119 properties: {

120location: {120 location: {

121type: "string",121 type: "string",

122description: "The city and state, e.g., San Francisco, CA",122 description: "The city and state, e.g., San Francisco, CA",

123},123 },

124},124 },

125required: ["location"],125 required: ["location"],

126},126 },

127},127 },

128},128 },

129],129 ],

130});130});

131```131```

132 132 

148const thread = await client.beta.threads.create();148const thread = await client.beta.threads.create();

149const message = client.beta.threads.messages.create(thread.id, {149const message = client.beta.threads.messages.create(thread.id, {

150 role: "user",150 role: "user",

151 content: "What's the weather in San Francisco today and the likelihood it'll rain?",151 content:

152 "What's the weather in San Francisco today and the likelihood it'll rain?",

152});153});

153```154```

154 155 

267 this.client = client;268 this.client = client;

268 }269 }

269 270 

270async onEvent(event) {271 async onEvent(event) {

271try {272 try {

272console.log(event);273 console.log(event);

273// Retrieve events that are denoted with 'requires_action'274 // Retrieve events that are denoted with 'requires_action'

274// since these will have our tool_calls275 // since these will have our tool_calls

275if (event.event === "thread.run.requires_action") {276 if (event.event === "thread.run.requires_action") {

276await this.handleRequiresAction(277 await this.handleRequiresAction(

277event.data,278 event.data,

278event.data.id,279 event.data.id,

279event.data.thread_id,280 event.data.thread_id

280);281 );

281}282 }

282} catch (error) {283 } catch (error) {

283console.error("Error handling event:", error);284 console.error("Error handling event:", error);

284}285 }

285}286 }

286 287 

287async handleRequiresAction(data, runId, threadId) {288 async handleRequiresAction(data, runId, threadId) {

288try {289 try {

289const toolOutputs =290 const toolOutputs =

290data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {291 data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {

291if (toolCall.function.name === "getCurrentTemperature") {292 if (toolCall.function.name === "getCurrentTemperature") {

292return {293 return {

293tool_call_id: toolCall.id,294 tool_call_id: toolCall.id,

294output: "57",295 output: "57",

295};296 };

296} else if (toolCall.function.name === "getRainProbability") {297 } else if (toolCall.function.name === "getRainProbability") {

297return {298 return {

298tool_call_id: toolCall.id,299 tool_call_id: toolCall.id,

299output: "0.06",300 output: "0.06",

300};301 };

301}302 }

302});303 });

303// Submit all the tool outputs at the same time304 // Submit all the tool outputs at the same time

304await this.submitToolOutputs(toolOutputs, runId, threadId);305 await this.submitToolOutputs(toolOutputs, runId, threadId);

305} catch (error) {306 } catch (error) {

306console.error("Error processing required action:", error);307 console.error("Error processing required action:", error);

307}308 }

308}309 }

309 310 

310async submitToolOutputs(toolOutputs, runId, threadId) {311 async submitToolOutputs(toolOutputs, runId, threadId) {

311try {312 try {

312// Use the submitToolOutputsStream helper313 // Use the submitToolOutputsStream helper

313const stream = this.client.beta.threads.runs.submitToolOutputsStream(314 const stream = this.client.beta.threads.runs.submitToolOutputsStream(

314threadId,315 runId,

315runId,316 { thread_id: threadId, tool_outputs: toolOutputs }

316{ tool_outputs: toolOutputs },317 );

317);318 for await (const event of stream) {

318for await (const event of stream) {319 this.emit("event", event);

319this.emit("event", event);320 }

320}321 } catch (error) {

321} catch (error) {322 console.error("Error submitting tool outputs:", error);

322console.error("Error submitting tool outputs:", error);323 }

323}324 }

324}

325}325}

326 326 

327const eventHandler = new EventHandler(client);327const eventHandler = new EventHandler(client);

328eventHandler.on("event", eventHandler.onEvent.bind(eventHandler));328eventHandler.on("event", eventHandler.onEvent.bind(eventHandler));

329 329 

330const stream = await client.beta.threads.runs.stream(330const stream = await client.beta.threads.runs.stream(threadId, {

331threadId,331 assistant_id: assistantId,

332{ assistant_id: assistantId },332});

333eventHandler,

334);

335 333 

336for await (const event of stream) {334for await (const event of stream) {

337eventHandler.emit("event", event);335 eventHandler.emit("event", event);

338}336}

339```337```

340 338 

418 output: "0.06",416 output: "0.06",

419 };417 };

420 }418 }

421 },419 }

422 );420 );

423 421 

424 // Submit all tool outputs at once after collecting them in a list422 // Submit all tool outputs at once after collecting them in a list

425 if (toolOutputs.length > 0) {423 if (toolOutputs.length > 0) {

426 run = await client.beta.threads.runs.submitToolOutputsAndPoll(424 run = await client.beta.threads.runs.submitToolOutputsAndPoll(run.id, {

427 thread.id,425 thread_id: thread.id,

428 run.id,426 tool_outputs: toolOutputs,

429 { tool_outputs: toolOutputs },427 });

430 );

431 console.log("Tool outputs submitted successfully.");428 console.log("Tool outputs submitted successfully.");

432 } else {429 } else {

433 console.log("No tool outputs to submit.");430 console.log("No tool outputs to submit.");

435 432 

436 // Check status after submitting tool outputs433 // Check status after submitting tool outputs

437 return handleRunStatus(run);434 return handleRunStatus(run);

438 435 }

439}

440};436};

441 437 

442const handleRunStatus = async (run) => {438const handleRunStatus = async (run) => {

443// Check if the run is completed439 // Check if the run is completed

444if (run.status === "completed") {440 if (run.status === "completed") {

445let messages = await client.beta.threads.messages.list(thread.id);441 let messages = await client.beta.threads.messages.list(thread.id);

446console.log(messages.data);442 console.log(messages.data);

447return messages.data;443 return messages.data;

448} else if (run.status === "requires_action") {444 } else if (run.status === "requires_action") {

449console.log(run.status);445 console.log(run.status);

450return await handleRequiresAction(run);446 return await handleRequiresAction(run);

451} else {447 } else {

452console.error("Run did not complete:", run);448 console.error("Run did not complete:", run);

453}449 }

454};450};

455 451 

456// Create and poll run452// Create and poll run

457let run = await client.beta.threads.runs.createAndPoll(thread.id, {453let run = await client.beta.threads.runs.createAndPoll(thread.id, {

458assistant_id: assistant.id,454 assistant_id: assistant.id,

459});455});

460 456 

461handleRunStatus(run);457handleRunStatus(run);

533 529 

534```javascript530```javascript

535const assistant = await client.beta.assistants.create({531const assistant = await client.beta.assistants.create({

536model: "gpt-4o-2024-08-06",532 model: "gpt-4o-2024-08-06",

537instructions:533 instructions:

538"You are a weather bot. Use the provided functions to answer questions.",534 "You are a weather bot. Use the provided functions to answer questions.",

539tools: [535 tools: [

540{536 {

541type: "function",537 type: "function",

542function: {538 function: {

543name: "getCurrentTemperature",539 name: "getCurrentTemperature",

544description: "Get the current temperature for a specific location",540 description: "Get the current temperature for a specific location",

545parameters: {541 parameters: {

546type: "object",542 type: "object",

547properties: {543 properties: {

548location: {544 location: {

549type: "string",545 type: "string",

550description: "The city and state, e.g., San Francisco, CA",546 description: "The city and state, e.g., San Francisco, CA",

551},547 },

552unit: {548 unit: {

553type: "string",549 type: "string",

554enum: ["Celsius", "Fahrenheit"],550 enum: ["Celsius", "Fahrenheit"],

555description:551 description:

556"The temperature unit to use. Infer this from the user's location.",552 "The temperature unit to use. Infer this from the user's location.",

557},553 },

558},554 },

559required: ["location", "unit"],555 required: ["location", "unit"],

560// highlight-start556 // highlight-start

561additionalProperties: false557 additionalProperties: false,

562// highlight-end558 // highlight-end

563},559 },

564// highlight-start560 // highlight-start

565strict: true561 strict: true,

566// highlight-end562 // highlight-end

567},563 },

568},564 },

569{565 {

570type: "function",566 type: "function",

571function: {567 function: {

572name: "getRainProbability",568 name: "getRainProbability",

573description: "Get the probability of rain for a specific location",569 description: "Get the probability of rain for a specific location",

574parameters: {570 parameters: {

575type: "object",571 type: "object",

576properties: {572 properties: {

577location: {573 location: {

578type: "string",574 type: "string",

579description: "The city and state, e.g., San Francisco, CA",575 description: "The city and state, e.g., San Francisco, CA",

580},576 },

581},577 },

582required: ["location"],578 required: ["location"],

583// highlight-start579 // highlight-start

584additionalProperties: false580 additionalProperties: false,

585// highlight-end581 // highlight-end

586},582 },

587// highlight-start583 // highlight-start

588strict: true584 strict: true,

589// highlight-end585 // highlight-end

590},586 },

591},587 },

592],588 ],

593});589});

594```590```

47 47 

48Models such as [`gpt-realtime-2.1`](https://developers.openai.com/api/docs/models/gpt-realtime-2.1) and [`gpt-audio-1.5`](https://developers.openai.com/api/docs/models/gpt-audio-1.5) are natively multimodal, meaning they can understand and generate audio and text as input and output.48Models such as [`gpt-realtime-2.1`](https://developers.openai.com/api/docs/models/gpt-realtime-2.1) and [`gpt-audio-1.5`](https://developers.openai.com/api/docs/models/gpt-audio-1.5) are natively multimodal, meaning they can understand and generate audio and text as input and output.

49 49 

50For live browser speech-to-speech interactions, start with a realtime session in the JavaScript SDK:50For live browser speech-to-speech interactions, start with a realtime session in the TypeScript Agents SDK:

51 51 

52Start a realtime voice session52Start a realtime voice session

53 53 

54```javascript54```typescript

55import { RealtimeAgent, RealtimeSession } from "@openai/agents/realtime";55import { RealtimeAgent, RealtimeSession } from "@openai/agents/realtime";

56 56 

57const agent = new RealtimeAgent({57const agent = new RealtimeAgent({

69```69```

70 70 

71 71 

72This example uses JavaScript because browser voice agents connect with WebRTC from the client. For Python voice workflows, use the [Voice agents guide](https://developers.openai.com/api/docs/guides/voice-agents), which covers chained voice pipelines.72This TypeScript example uses the Agents SDK to connect browser voice agents with WebRTC from the client. For Python voice workflows, use the [Voice agents guide](https://developers.openai.com/api/docs/guides/voice-agents), which covers chained voice pipelines.

73 73 

74If you already have a text-based LLM application with the [Chat Completions endpoint](https://developers.openai.com/api/reference/resources/chat), you may want to add audio capabilities. For example, if your chat application supports text input, you can add audio input and output: include `audio` in the `modalities` array and use an audio model, like [`gpt-audio-1.5`](https://developers.openai.com/api/docs/models/gpt-audio-1.5).74If you already have a text-based LLM application with the [Chat Completions endpoint](https://developers.openai.com/api/reference/resources/chat), you may want to add audio capabilities. For example, if your chat application supports text input, you can add audio input and output: include `audio` in the `modalities` array and use an audio model, like [`gpt-audio-1.5`](https://developers.openai.com/api/docs/models/gpt-audio-1.5).

75 75 

137 -F file="@batchinput.jsonl"137 -F file="@batchinput.jsonl"

138```138```

139 139 

140```cli140```bash

141openai files create \141openai files create \

142 --file batchinput.jsonl \142 --file batchinput.jsonl \

143 --purpose batch143 --purpose batch

184 }'184 }'

185```185```

186 186 

187```cli187```bash

188openai batches create \188openai batches create \

189 --input-file-id file-abc123 \189 --input-file-id file-abc123 \

190 --endpoint /v1/chat/completions \190 --endpoint /v1/chat/completions \

245 -H "Content-Type: application/json"245 -H "Content-Type: application/json"

246```246```

247 247 

248```cli248```bash

249openai batches retrieve \249openai batches retrieve \

250 --batch-id batch_abc123250 --batch-id batch_abc123

251```251```

297 -H "Authorization: Bearer $OPENAI_API_KEY" > batch_output.jsonl297 -H "Authorization: Bearer $OPENAI_API_KEY" > batch_output.jsonl

298```298```

299 299 

300```cli300```bash

301openai files content \301openai files content \

302 --file-id file-xyz123 \302 --file-id file-xyz123 \

303 --output batch_output.jsonl303 --output batch_output.jsonl

352 -X POST352 -X POST

353```353```

354 354 

355```cli355```bash

356openai batches cancel \356openai batches cancel \

357 --batch-id batch_abc123357 --batch-id batch_abc123

358```358```

389 -H "Content-Type: application/json"389 -H "Content-Type: application/json"

390```390```

391 391 

392```cli392```bash

393openai batches list \393openai batches list \

394 --limit 10394 --limit 10

395```395```

23 23 

24Actions can also be sent imperatively by your frontend with `sendAction()`. This is probably most useful when you need ChatKit to respond to interaction happening outside ChatKit, but it can also be used to chain actions when you need to respond on both the client and the server (more on that below).24Actions can also be sent imperatively by your frontend with `sendAction()`. This is probably most useful when you need ChatKit to respond to interaction happening outside ChatKit, but it can also be used to chain actions when you need to respond on both the client and the server (more on that below).

25 25 

26```tsx26```typescript

27await chatKit.sendAction({27await chatKit.sendAction({

28 type: "example",28 type: "example",

29 payload: { id: 123 },29 payload: { id: 123 },

83 84 

84Then, when the action is triggered, it will then be passed to a callback that you provide when instantiating ChatKit.85Then, when the action is triggered, it will then be passed to a callback that you provide when instantiating ChatKit.

85 86 

86```ts87```typescript

87async function handleWidgetAction(action: {type: string, Record<string, unknown>}) {88async function handleWidgetAction(action: WidgetAction) {

88 if (action.type === "example") {89 if (action.type === "example") {

89 const res = await doSomething(action)90 const res = await doSomething(action);

90 91 

91 // You can fire off actions to your server from here as well.92 // You can fire off actions to your server from here as well.

92 // e.g. if you want to stream new thread items or update a widget.93 // For example, stream new thread items or update a widget.

93 await chatKit.sendAction({94 await chatKit.sendAction({

94 type: "example_complete",95 type: "example_complete",

95 payload: res96 payload: res,

96 })97 });

97 }98 }

98}99}

99 100 

100chatKit.setOptions({101chatKit.setOptions({

101 // other options...102 // Other options...

102 widgets: { onAction: handleWidgetAction }103 widgets: { onAction: handleWidgetAction },

103})104});

104```105```

105 106 

107 

106## Strongly typed actions108## Strongly typed actions

107 109 

108By default `Action` and `ActionConfig` are not strongly typed. However, we do expose a `create` helper on `Action` that generates `ActionConfig`s from a set of strongly-typed actions.110By default `Action` and `ActionConfig` are not strongly typed. However, we do expose a `create` helper on `Action` that generates `ActionConfig`s from a set of strongly-typed actions.

57 57 

58For all theming options, see the [API reference](https://openai.github.io/chatkit-js/api/openai/chatkit/type-aliases/themeoption/).58For all theming options, see the [API reference](https://openai.github.io/chatkit-js/api/openai/chatkit/type-aliases/themeoption/).

59 59 

60```jsx60```typescript

61const options: Partial<ChatKitOptions> = {61const options: Partial<ChatKitOptions> = {

62 theme: {62 theme: {

63 colorScheme: "dark",63 colorScheme: "dark",

64 color: {64 color: {

65 accent: {65 accent: {

66 primary: "#2D8CFF",66 primary: "#2D8CFF",

67 level: 267 level: 2,

68 }68 },

69 },69 },

70 radius: "round",70 radius: "round",

71 density: "compact",71 density: "compact",

78 79 

79Let users know what to ask or guide their first input by changing the composer’s placeholder text.80Let users know what to ask or guide their first input by changing the composer’s placeholder text.

80 81 

81```jsx82```typescript

82const options: Partial<ChatKitOptions> = {83const options: Partial<ChatKitOptions> = {

83 composer: {84 composer: {

84 placeholder: "Ask anything about your data…",85 placeholder: "Ask anything about your data…",

93 95 

94Guide users on what to ask or do by suggesting prompt ideas when starting a conversation.96Guide users on what to ask or do by suggesting prompt ideas when starting a conversation.

95 97 

96```js98```typescript

97const options: Partial<ChatKitOptions> = {99const options: Partial<ChatKitOptions> = {

98 startScreen: {100 startScreen: {

99 greeting: "What can I help you build today?",101 greeting: "What can I help you build today?",

101 {103 {

102 name: "Check on the status of a ticket",104 name: "Check on the status of a ticket",

103 prompt: "Can you help me check on the status of a ticket?",105 prompt: "Can you help me check on the status of a ticket?",

104 icon: "search"106 icon: "search",

105 },107 },

106 {108 {

107 name: "Create Ticket",109 name: "Create Ticket",

108 prompt: "Can you help me create a new support ticket?",110 prompt: "Can you help me create a new support ticket?",

109 icon: "write"111 icon: "write",

110 },112 },

111 ],113 ],

112 },114 },

117 120 

118Custom header buttons help you add navigation, context, or actions relevant to your integration.121Custom header buttons help you add navigation, context, or actions relevant to your integration.

119 122 

120```jsx123```typescript

121const options: Partial<ChatKitOptions> = {124const options: Partial<ChatKitOptions> = {

122 header: {125 header: {

123 customButtonLeft: {126 customButtonLeft: {

140 144 

141You can also control the number, size, and types of files that users can attach to messages.145You can also control the number, size, and types of files that users can attach to messages.

142 146 

143```jsx147```typescript

144const options: Partial<ChatKitOptions> = {148const options: Partial<ChatKitOptions> = {

145 composer: {149 composer: {

146 attachments: {150 attachments: {

147 uploadStrategy: { type: 'hosted' },151 uploadStrategy: { type: "hosted" },

148 maxSize: 20 * 1024 * 1024, // 20MB per file152 maxSize: 20 * 1024 * 1024, // 20 MB per file

149 maxCount: 3,153 maxCount: 3,

150 accept: { "application/pdf": [".pdf"], "image/*": [".png", ".jpg"] },154 accept: { "application/pdf": [".pdf"], "image/*": [".png", ".jpg"] },

151 },155 },

152 },156 },

153}157};

154```158```

155 159 

160 

156## Enable @mentions in the composer with entity tags161## Enable @mentions in the composer with entity tags

157 162 

158Let users tag custom “entities” with @-mentions. This enables richer conversation context and interactivity.163Let users tag custom “entities” with @-mentions. This enables richer conversation context and interactivity.

160- Use `onTagSearch` to return a list of entities based on the input query.165- Use `onTagSearch` to return a list of entities based on the input query.

161- Use `onClick` to handle the click event of an entity.166- Use `onClick` to handle the click event of an entity.

162 167 

163```jsx168```typescript

164const options: Partial<ChatKitOptions> = {169const options: Partial<ChatKitOptions> = {

165 entities: {170 entities: {

166 async onTagSearch(query) {171 async onTagSearch(query: string) {

172 void query;

167 return [173 return [

168 {174 {

169 id: "user_123",175 id: "user_123",

177 group: "Documents",183 group: "Documents",

178 interactive: true,184 interactive: true,

179 },185 },

180 ]186 ];

181 },187 },

182 onClick: (entity) => {188 onClick: (entity: { id: string }) => {

183 navigateToEntity(entity.id);189 navigateToEntity(entity.id);

184 },190 },

185 },191 },

196 203 

197 Browse available widgets.](https://widgets.chatkit.studio)204 Browse available widgets.](https://widgets.chatkit.studio)

198 205 

199```jsx206```typescript

200const options: Partial<ChatKitOptions> = {207const options: Partial<ChatKitOptions> = {

201 entities: {208 entities: {

202 async onTagSearch() { /* ... */ },209 async onTagSearch() {

203 onRequestPreview: async (entity) => ({210 return [];

211 },

212 onRequestPreview: async (entity: { title: string }) => ({

204 preview: {213 preview: {

205 type: "Card",214 type: "Card",

206 children: [215 children: [

218Enhance productivity by letting users trigger app-specific actions from the composer bar. The selected tool228Enhance productivity by letting users trigger app-specific actions from the composer bar. The selected tool

219will be sent to the model as a tool preference.229will be sent to the model as a tool preference.

220 230 

221```jsx231```typescript

222const options: Partial<ChatKitOptions> = {232const options: Partial<ChatKitOptions> = {

223 composer: {233 composer: {

224 tools: [234 tools: [

225 {235 {

226 id: 'add-note',236 id: "add-note",

227 label: 'Add Note',237 label: "Add Note",

228 icon: 'write',238 icon: "write",

229 pinned: true,239 pinned: true,

230 },240 },

231 ],241 ],

237 248 

238Disable major UI regions and features if you need more customization over the options available in the header and want to implement your own instead. Disabling history can be useful when the concept of threads and history doesn't make sense for your use case—e.g., in a support chatbot.249Disable major UI regions and features if you need more customization over the options available in the header and want to implement your own instead. Disabling history can be useful when the concept of threads and history doesn't make sense for your use case—e.g., in a support chatbot.

239 250 

240```jsx251```typescript

241const options: Partial<ChatKitOptions> = {252const options: Partial<ChatKitOptions> = {

242 history: { enabled: false },253 history: { enabled: false },

243 header: { enabled: false },254 header: { enabled: false },

248 260 

249Override the default locale if you have an app-wide language setting. By default, the locale is set to the browser's locale.261Override the default locale if you have an app-wide language setting. By default, the locale is set to the browser's locale.

250 262 

251```jsx263```typescript

252const options: Partial<ChatKitOptions> = {264const options: Partial<ChatKitOptions> = {

253 locale: 'de-DE',265 locale: "de-DE",

254};266};

255```267```

22 22 

23Capture widget events with the `onAction` callback from `WidgetsOption` or equivalent React hook. Forward the action payload to your backend to handle actions.23Capture widget events with the `onAction` callback from `WidgetsOption` or equivalent React hook. Forward the action payload to your backend to handle actions.

24 24 

25```ts25```typescript

26chatkit.setOptions({26chatkit.setOptions({

27 widgets: {27 widgets: {

28 async onAction(action, item) {28 async onAction(action, item) {

325 .join("|");325 .join("|");

326 326 

327 const tokenRe = new RegExp(327 const tokenRe = new RegExp(

328 `\uE200(?<family>${familyPattern})\uE202(?<body>[\\s\\S]*?)\uE201`,328 `${CITATION_START}(?<family>${familyPattern})${CITATION_DELIMITER}(?<body>[\\s\\S]*?)${CITATION_STOP}`,

329 "g"329 "g"

330 );330 );

331 331 

378 );378 );

379 379 

380 for (const citation of sortedCitations) {380 for (const citation of sortedCitations) {

381 cleanText = cleanText.slice(0, citation.start) + cleanText.slice(citation.end);381 cleanText =

382 cleanText.slice(0, citation.start) + cleanText.slice(citation.end);

382 }383 }

383 384 

384 return cleanText;385 return cleanText;

18 18 

19```javascript19```javascript

20const completion = await openai.completions.create({20const completion = await openai.completions.create({

21model: 'gpt-3.5-turbo-instruct',21 model: "gpt-3.5-turbo-instruct",

22prompt: 'Write a tagline for an ice cream shop.'22 prompt: "Write a tagline for an ice cream shop.",

23});23});

24```24```

25 25 

206 206 

207ChatKit emits `CustomEvent` instances from the Web Component. The payload shapes are:207ChatKit emits `CustomEvent` instances from the Web Component. The payload shapes are:

208 208 

209```ts209```typescript

210type Events = {210type Events = {

211 "chatkit.error": CustomEvent<{ error: Error }>;211 "chatkit.error": CustomEvent<{ error: Error }>;

212 "chatkit.response.start": CustomEvent<void>;212 "chatkit.response.start": CustomEvent<void>;

120 }' | jq -r '.data[0].b64_json' | base64 --decode > otter.png120 }' | jq -r '.data[0].b64_json' | base64 --decode > otter.png

121```121```

122 122 

123```cli123```bash

124openai images generate \124openai images generate \

125 --model gpt-image-2 \125 --model gpt-image-2 \

126 --prompt "A children's book drawing of a veterinarian using a stethoscope to listen to the heartbeat of a baby otter." \126 --prompt "A children's book drawing of a veterinarian using a stethoscope to listen to the heartbeat of a baby otter." \

1002 -F 'prompt=Generate a photorealistic image of a gift basket on a white background labeled "Relax & Unwind" with a ribbon and handwriting-like font, containing all the items in the reference pictures'1002 -F 'prompt=Generate a photorealistic image of a gift basket on a white background labeled "Relax & Unwind" with a ribbon and handwriting-like font, containing all the items in the reference pictures'

1003```1003```

1004 1004 

1005```cli1005```bash

1006openai images edit \1006openai images edit \

1007 --model gpt-image-2 \1007 --model gpt-image-2 \

1008 --image body-lotion.png \1008 --image body-lotion.png \

1209 -F 'prompt=A sunlit indoor lounge area with a pool containing a flamingo'1209 -F 'prompt=A sunlit indoor lounge area with a pool containing a flamingo'

1210```1210```

1211 1211 

1212```cli1212```bash

1213openai images edit \1213openai images edit \

1214 --model gpt-image-2 \1214 --model gpt-image-2 \

1215 --image sunlit_lounge.png \1215 --image sunlit_lounge.png \

86 f.write(base64.b64decode(image_base64))86 f.write(base64.b64decode(image_base64))

87```87```

88 88 

89```cli89```bash

90openai responses create \90openai responses create \

91 --model gpt-5.6 \91 --model gpt-5.6 \

92 --raw-output \92 --raw-output \

230 }'230 }'

231```231```

232 232 

233```cli233```bash

234openai responses create \234openai responses create \

235 --model gpt-5.6 \235 --model gpt-5.6 \

236 --raw-output \236 --raw-output \

236 236 

237**What changed?** Before, we had one prompt to re-write the query and one to determine whether this requires doing a retrieval lookup. Now, this combined prompt does both. Specifically, notice the updated instruction in the first line of the prompt, and the updated output JSON:237**What changed?** Before, we had one prompt to re-write the query and one to determine whether this requires doing a retrieval lookup. Now, this combined prompt does both. Specifically, notice the updated instruction in the first line of the prompt, and the updated output JSON:

238 238 

239```jsx239```javascript

240{240{

241 query:"[contextualized query]",241 query: "[contextualized query]",

242 retrieval:"[true/false - whether retrieval is required]"242 retrieval: "[true/false - whether retrieval is required]",

243}243}

244```244```

245 245 

289 290 

290**Could we use a fine-tuned GPT-3.5 instead of GPT-4?** Maybe – but in general, open-ended responses from assistants are best left to GPT-4 so it can better handle a greater range of cases. That being said, looking at the reasoning steps themselves, they may not all require GPT-4 level reasoning to produce. The well defined, limited scope nature makes them and **good potential candidates for fine-tuning**.291**Could we use a fine-tuned GPT-3.5 instead of GPT-4?** Maybe – but in general, open-ended responses from assistants are best left to GPT-4 so it can better handle a greater range of cases. That being said, looking at the reasoning steps themselves, they may not all require GPT-4 level reasoning to produce. The well defined, limited scope nature makes them and **good potential candidates for fine-tuning**.

291 292 

292```jsx293```javascript

293{294{

294 "message_is_conversation_continuation": "True", // <-295 message_is_conversation_continuation: "True", // <-

295 "number_of_messages_in_conversation_so_far": "1", // <-296 number_of_messages_in_conversation_so_far: "1", // <-

296 "user_sentiment": "Aggravated", // <-297 user_sentiment: "Aggravated", // <-

297 "query_type": "Hardware Issue", // <-298 query_type: "Hardware Issue", // <-

298 "response_tone": "Validating and solution-oriented", // <-299 response_tone: "Validating and solution-oriented", // <-

299 "response_requirements": "Propose options for repair or replacement.", // <-300 response_requirements: "Propose options for repair or replacement.", // <-

300 "user_requesting_to_talk_to_human": "False", // <-301 user_requesting_to_talk_to_human: "False", // <-

301 "enough_information_in_context": "True", // <-302 enough_information_in_context: "True", // <-

302 "response": "..." // X -- benefits from GPT-4303 response: "...", // X -- benefits from GPT-4

303}304}

304```305```

305 306 

392 394 

393Taking a closer look at the reasoning JSON you may notice the field names themselves are quite long.395Taking a closer look at the reasoning JSON you may notice the field names themselves are quite long.

394 396 

395```jsx397```javascript

396{398{

397 "message_is_conversation_continuation": "True", // <-399 message_is_conversation_continuation: "True", // <-

398 "number_of_messages_in_conversation_so_far": "1", // <-400 number_of_messages_in_conversation_so_far: "1", // <-

399 "user_sentiment": "Aggravated", // <-401 user_sentiment: "Aggravated", // <-

400 "query_type": "Hardware Issue", // <-402 query_type: "Hardware Issue", // <-

401 "response_tone": "Validating and solution-oriented", // <-403 response_tone: "Validating and solution-oriented", // <-

402 "response_requirements": "Propose options for repair or replacement.", // <-404 response_requirements: "Propose options for repair or replacement.", // <-

403 "user_requesting_to_talk_to_human": "False", // <-405 user_requesting_to_talk_to_human: "False", // <-

404}406}

405```407```

406 408 

409 

407By making them shorter and moving explanations to the comments we can [generate fewer tokens](#generate-fewer-tokens).410By making them shorter and moving explanations to the comments we can [generate fewer tokens](#generate-fewer-tokens).

408 411 

409```jsx412```javascript

410{413{

411 "cont": "True", // whether last message is a continuation414 cont: "True", // whether last message is a continuation

412 "n_msg": "1", // number of messages in the continued conversation415 n_msg: "1", // number of messages in the continued conversation

413 "tone_in": "Aggravated", // sentiment of user query416 tone_in: "Aggravated", // sentiment of user query

414 "type": "Hardware Issue", // type of the user query417 type: "Hardware Issue", // type of the user query

415 "tone_out": "Validating and solution-oriented", // desired tone for response418 tone_out: "Validating and solution-oriented", // desired tone for response

416 "reqs": "Propose options for repair or replacement.", // response requirements419 reqs: "Propose options for repair or replacement.", // response requirements

417 "human": "False", // whether user is expressing want to talk to human420 human: "False", // whether user is expressing want to talk to human

418}421}

419```422```

420 423 

483 483 

484#### Chat Completions API484#### Chat Completions API

485 485 

486```javascript486```json

487{487{

488 "type": "function",488 "type": "function",

489 "function": {489 "function": {

494 "type": "object",494 "type": "object",

495 "properties": {495 "properties": {

496 "location": {496 "location": {

497 "type": "string",497 "type": "string"

498 },498 }

499 },499 },

500 "additionalProperties": false,500 "additionalProperties": false,

501 "required": [501 "required": [

508 508 

509#### Responses API509#### Responses API

510 510 

511```javascript511```json

512{512{

513 "type": "function",513 "type": "function",

514 "name": "get_weather",514 "name": "get_weather",

517 "type": "object",517 "type": "object",

518 "properties": {518 "properties": {

519 "location": {519 "location": {

520 "type": "string",520 "type": "string"

521 },521 }

522 },522 },

523 "additionalProperties": false,523 "additionalProperties": false,

524 "required": [524 "required": [

127```128```

128 129 

129 130 

130In addition to the refactored code, the model response will contain data that looks something like this:131In addition to the refactored code, an abridged model response without the `choices` field contains usage data like this:

131 132 

132```javascript133```json

133{134{

134 id: 'chatcmpl-xxx',135 "id": "chatcmpl-xxx",

135 object: 'chat.completion',136 "object": "chat.completion",

136 created: 1730918466,137 "created": 1730918466,

137 model: 'gpt-4o-2024-08-06',138 "model": "gpt-4o-2024-08-06",

138 choices: [ /* ...actual text response here... */],139 "usage": {

139 usage: {140 "prompt_tokens": 81,