Reference 2026-10-01 22:59 UTC to 2026-10-02 23:58 UTC

1146 1146 

1147 A customer-safe error. Non-null only for a failed turn.1147 A customer-safe error. Non-null only for a failed turn.

1148 1148 

1149 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 16 more`1149 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 19 more`

1150 1150 

1151 A stable, machine-readable failure category.1151 A stable, machine-readable failure category.

1152 1152 

1162 1162 

1163 The organization has reached a usage, plan, or billing limit.1163 The organization has reached a usage, plan, or billing limit.

1164 1164 

1165 - `"project_spend_limit_exceeded"`

1166 

1167 The project has reached its enforced spend limit.

1168 

1169 - `"organization_spend_limit_exceeded"`

1170 

1171 The organization has reached its enforced spend limit.

1172 

1173 - `"organization_usage_limit_exceeded"`

1174 

1175 The organization has reached its OpenAI-assigned usage limit.

1176 

1165 - `"credit_balance_exhausted"`1177 - `"credit_balance_exhausted"`

1166 1178 

1167 The organization has no API credits remaining.1179 The organization has no API credits remaining.

1397 1409 

1398 A customer-safe error. Non-null only for a failed turn.1410 A customer-safe error. Non-null only for a failed turn.

1399 1411 

1400 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 16 more`1412 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 19 more`

1401 1413 

1402 A stable, machine-readable failure category.1414 A stable, machine-readable failure category.

1403 1415 

1413 1425 

1414 The organization has reached a usage, plan, or billing limit.1426 The organization has reached a usage, plan, or billing limit.

1415 1427 

1428 - `"project_spend_limit_exceeded"`

1429 

1430 The project has reached its enforced spend limit.

1431 

1432 - `"organization_spend_limit_exceeded"`

1433 

1434 The organization has reached its enforced spend limit.

1435 

1436 - `"organization_usage_limit_exceeded"`

1437 

1438 The organization has reached its OpenAI-assigned usage limit.

1439 

1416 - `"credit_balance_exhausted"`1440 - `"credit_balance_exhausted"`

1417 1441 

1418 The organization has no API credits remaining.1442 The organization has no API credits remaining.

1648 1672 

1649 A customer-safe error. Non-null only for a failed turn.1673 A customer-safe error. Non-null only for a failed turn.

1650 1674 

1651 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 16 more`1675 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 19 more`

1652 1676 

1653 A stable, machine-readable failure category.1677 A stable, machine-readable failure category.

1654 1678 

1664 1688 

1665 The organization has reached a usage, plan, or billing limit.1689 The organization has reached a usage, plan, or billing limit.

1666 1690 

1691 - `"project_spend_limit_exceeded"`

1692 

1693 The project has reached its enforced spend limit.

1694 

1695 - `"organization_spend_limit_exceeded"`

1696 

1697 The organization has reached its enforced spend limit.

1698 

1699 - `"organization_usage_limit_exceeded"`

1700 

1701 The organization has reached its OpenAI-assigned usage limit.

1702 

1667 - `"credit_balance_exhausted"`1703 - `"credit_balance_exhausted"`

1668 1704 

1669 The organization has no API credits remaining.1705 The organization has no API credits remaining.

1914 1950 

1915 A customer-safe error. Non-null only for a failed turn.1951 A customer-safe error. Non-null only for a failed turn.

1916 1952 

1917 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 16 more`1953 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 19 more`

1918 1954 

1919 A stable, machine-readable failure category.1955 A stable, machine-readable failure category.

1920 1956 

1930 1966 

1931 The organization has reached a usage, plan, or billing limit.1967 The organization has reached a usage, plan, or billing limit.

1932 1968 

1969 - `"project_spend_limit_exceeded"`

1970 

1971 The project has reached its enforced spend limit.

1972 

1973 - `"organization_spend_limit_exceeded"`

1974 

1975 The organization has reached its enforced spend limit.

1976 

1977 - `"organization_usage_limit_exceeded"`

1978 

1979 The organization has reached its OpenAI-assigned usage limit.

1980 

1933 - `"credit_balance_exhausted"`1981 - `"credit_balance_exhausted"`

1934 1982 

1935 The organization has no API credits remaining.1983 The organization has no API credits remaining.

2180 2228 

2181 A customer-safe error. Non-null only for a failed turn.2229 A customer-safe error. Non-null only for a failed turn.

2182 2230 

2183 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 16 more`2231 - `code: "context_length_exceeded" or "session_budget_exceeded" or "usage_limit_exceeded" or 19 more`

2184 2232 

2185 A stable, machine-readable failure category.2233 A stable, machine-readable failure category.

2186 2234 

2196 2244 

2197 The organization has reached a usage, plan, or billing limit.2245 The organization has reached a usage, plan, or billing limit.

2198 2246 

2247 - `"project_spend_limit_exceeded"`

2248 

2249 The project has reached its enforced spend limit.

2250 

2251 - `"organization_spend_limit_exceeded"`

2252 

2253 The organization has reached its enforced spend limit.

2254 

2255 - `"organization_usage_limit_exceeded"`

2256 

2257 The organization has reached its OpenAI-assigned usage limit.

2258 

2199 - `"credit_balance_exhausted"`2259 - `"credit_balance_exhausted"`

2200 2260 

2201 The organization has no API credits remaining.2261 The organization has no API credits remaining.

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163 

164#### Conversation object (JavaScript)

165 

166```javascript

167import OpenAI from "openai";

168 

169const client = new OpenAI();

170 

171const conversation = await client.conversations.create({

172 items: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

173 metadata: { user_id: "peter_le_fleur" },

174});

175 

176console.log(conversation.id);

177```

178 

179 

180 

90### Response example181### Response example

91 182 

92 183 

132 223 

133#### Python224#### Python

134 225 

226 

227 

228#### Run object

229 

230```python

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

232import time

233 

234from openai import OpenAI

235 

236openai = OpenAI()

237thread_id = "thread_123"

238assistant_id = "asst_123"

239 

240run = openai.beta.threads.runs.create(

241 thread_id=thread_id,

242 assistant_id=assistant_id,

243)

244 

245while run.status in ("queued", "in_progress"):

246 time.sleep(1)

247 run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)

248```

249 

250#### Response object

251 

252```python

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

254 

255from openai import OpenAI

256 

257openai = OpenAI()

258conversation_id = "conv_123"

259 

260response = openai.responses.create(

261 model="gpt-6-astra",

262 input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],

263 conversation=conversation_id,

264)

265```

266 

267 

268 

135#### Go269#### Go

136 270 

271 

272 

273#### Run object (Go)

274 

275```go

276run, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

277 AssistantID: "asst_abc123",

278})

279if err != nil {

280 panic(err)

281}

282for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

283 time.Sleep(time.Second)

284 run, err = client.Beta.Threads.Runs.Get(context.Background(), "thread_abc123", run.ID)

285 if err != nil {

286 panic(err)

287 }

288}

289```

290 

291#### Response object (Go)

292 

293```go

294_, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

295 Model: "gpt-6-astra",

296 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{

297 responses.ResponseInputItemParamOfMessage("What are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

298 }},

299 Conversation: responses.ResponseNewParamsConversationUnion{OfString: openai.String("conv_abc123")},

300})

301if err != nil {

302 panic(err)

303}

304```

305 

306 

307 

308#### JavaScript

309 

310 

311 

312#### Run object (JavaScript)

313 

314```javascript

315import { setTimeout } from "node:timers/promises";

316import OpenAI from "openai";

317 

318const client = new OpenAI();

319// Replace these illustrative IDs with your own resources.

320const threadId = "thread_123";

321const assistantId = "asst_123";

322let run = await client.beta.threads.runs.create(threadId, {

323 assistant_id: assistantId,

324});

325while (run.status === "queued" || run.status === "in_progress") {

326 await setTimeout(1000);

327 run = await client.beta.threads.runs.retrieve(run.id, {

328 thread_id: threadId,

329 });

330}

331console.log(run.status);

332```

333 

334#### Response object (JavaScript)

335 

336```javascript

337// Replace the illustrative IDs and URLs below with your own resource values.

338import OpenAI from "openai";

339 

340const client = new OpenAI();

341const conversationId = "conv_123";

342 

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

344 model: "gpt-6-astra",

345 input: [{ role: "user", content: "What are the five Ds of dodgeball?" }],

346 conversation: conversationId,

347});

348 

349console.log(response.output_text);

350```

351 

352 

353 

137### Response example354### Response example

138 355 

139 356 

85 85 

86#### Python86#### Python

87 87 

88 

89 

90#### Thread object

91 

92```python

93thread = openai.beta.threads.create(

94 messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

95 metadata={"user_id": "peter_le_fleur"},

96)

97```

98 

99#### Conversation object

100 

101```python

102conversation = openai.conversations.create(

103 items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],

104 metadata={"user_id": "peter_le_fleur"},

105)

106```

107 

108 

109 

88#### Go110#### Go

89 111 

112 

113 

114#### Thread object (Go)

115 

116```go

117thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

118 Messages: []openai.BetaThreadNewParamsMessage{{

119 Role: "user",

120 Content: openai.BetaThreadNewParamsMessageContentUnion{

121 OfString: openai.String("what are the 5 Ds of dodgeball?"),

122 },

123 }},

124 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

125})

126if err != nil {

127 panic(err)

128}

129```

130 

131#### Conversation object (Go)

132 

133```go

134conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{

135 Items: []responses.ResponseInputItemUnionParam{

136 responses.ResponseInputItemParamOfMessage("what are the 5 Ds of dodgeball?", responses.EasyInputMessageRoleUser),

137 },

138 Metadata: shared.Metadata{"user_id": "peter_le_fleur"},

139})

140if err != nil {

141 panic(err)

142}

143```

144 

145 

146 

147#### JavaScript

148 

149 

150 

151#### Thread object (JavaScript)

152 

153```javascript

154import OpenAI from "openai";

155 

156const client = new OpenAI();

157const thread = await client.beta.threads.create({

158 messages: [{ role: "user", content: "what are the 5 Ds of dodgeball?" }],

159 metadata: { user_id: "peter_le_fleur" },

160});

161console.log(thread.id);

162```

163