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

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 

34 34 

35Upcoming deprecations are listed below, with the most recent announcements at the top.35Upcoming deprecations are listed below, with the most recent announcements at the top.

36 36 

37### 2026-10-01: GPT-5.3-Codex, GPT-5.1, GPT-5.4-Nano

38 

39The following models are deprecated and will be removed from the API on April 1, 2027, with six months' notice. Migrate to the recommended replacements before the shutdown date.

40 

41| Shutdown date | Model / system | Recommended replacement |

42| ------------- | --------------- | ----------------------- |

43| Apr 1, 2027 | `gpt-5.3-codex` | `gpt-6-sol` |

44| Apr 1, 2027 | `gpt-5.4-nano` | `gpt-6-luna` |

45| Apr 1, 2027 | `gpt-5.1` | `gpt-6-sol` |

46 

47### 2026-10-01: Text-to-speech models

48 

49The following text-to-speech models are deprecated and will be removed from the API on January 6, 2027, with at least three months' notice. Migrate to `gpt-realtime-2.1-mini` before the shutdown date. See the [Realtime API guide](https://developers.openai.com/api/docs/guides/realtime) to plan your migration.

50 

51| Shutdown date | Model / system | Recommended replacement |

52| ------------- | ---------------------------- | ----------------------- |

53| Jan 6, 2027 | `tts-1` | `gpt-realtime-2.1-mini` |

54| Jan 6, 2027 | `tts-1-hd` | `gpt-realtime-2.1-mini` |

55| Jan 6, 2027 | `gpt-4o-mini-tts-2025-03-20` | `gpt-realtime-2.1-mini` |

56| Jan 6, 2027 | `gpt-4o-mini-tts-2025-12-15` | `gpt-realtime-2.1-mini` |

57 

37### 2026-09-11: GPT-5.4-Cyber58### 2026-09-11: GPT-5.4-Cyber

38 59 

39The `gpt-5.4-cyber` model is deprecated and will be removed from the API on October 1, 2026. Migrate to the most capable cyber model available to you before the shutdown date.60The `gpt-5.4-cyber` model is deprecated and will be removed from the API on October 1, 2026. Migrate to the most capable cyber model available to you before the shutdown date.

113 113 

114```javascript114```javascript

115import OpenAI from "openai";115import OpenAI from "openai";

116import { agentFileDestination } from "openai/helpers/beta/agents/filesystem";

116 117 

117const client = new OpenAI();118const client = new OpenAI();

118const stream = await client.beta.agents.sessions.create({119const stream = await client.beta.agents.sessions.create({

133 stream: true,134 stream: true,

134});135});

135 136 

136for await (const event of stream) {137stream.withResultCollection();

138try {

139 for await (const event of stream) {

137 console.log(event);140 console.log(event);

141 }

142 const result = await stream.finalResult();

143 await client.beta.agents.sessions.artifacts.forResult(result).download({

144 path: "/workspace/outputs/summary.json",

145 to: agentFileDestination("summary.json"),

146 });

147} finally {

148 stream.controller.abort();

138}149}

139```150```

140 151 

159 stream=True,170 stream=True,

160)171)

161 172 

162with stream:173with stream.with_result_collection():

163 for event in stream:174 for event in stream:

164 print(event.model_dump_json())175 print(event.model_dump_json())

176 result = stream.get_final_result()

177 

178client.beta.agents.sessions.artifacts.for_result(result).download(

179 "/workspace/outputs/summary.json", to="summary.json"

180)

165```181```

166 182 

167```go183```go

170import (186import (

171 "context"187 "context"

172 "fmt"188 "fmt"

189 "os"

173 190 

174 "github.com/openai/openai-go/v3"191 "github.com/openai/openai-go/v3"

175)192)

189 Input: openai.BetaAgentSessionNewParamsInputUnion{OfString: openai.String("Use Python to sum the amount column in /workspace/amounts.csv. Write a JSON object with the total to /workspace/outputs/summary.json, then read it back to verify it.")},206 Input: openai.BetaAgentSessionNewParamsInputUnion{OfString: openai.String("Use Python to sum the amount column in /workspace/amounts.csv. Write a JSON object with the total to /workspace/outputs/summary.json, then read it back to verify it.")},

190 })207 })

191 defer stream.Close()208 defer stream.Close()

192 209 openai.BetaAgentSessionWithResultCollection(stream)

193 for stream.Next() {210 for stream.Next() {

194 fmt.Println(stream.Current().RawJSON())211 fmt.Println(stream.Current().RawJSON())

195 }212 }

196 if err := stream.Err(); err != nil {213 

214 result, err := openai.BetaAgentSessionFinalResult(stream)

215 if err != nil {

216 panic(err)

217 }

218 destination, err := os.Create("summary.json")

219 if err != nil {

220 panic(err)

221 }

222 defer destination.Close()

223 _, err = client.Beta.Agents.Sessions.Artifacts.ForResult(result).Download(ctx, "/workspace/outputs/summary.json", destination)

224 if err != nil {

225 panic(err)

226 }

227 if err := destination.Close(); err != nil {

197 panic(err)228 panic(err)

198 }229 }

199}230}

201 232 

202```java233```java

203import com.openai.client.okhttp.OpenAIOkHttpClient;234import com.openai.client.okhttp.OpenAIOkHttpClient;

235import com.openai.helpers.beta.agents.AgentArtifactDownloads;

204import com.openai.models.beta.agents.EnvironmentParam;236import com.openai.models.beta.agents.EnvironmentParam;

205import com.openai.models.beta.agents.HostedEnvironmentFileParam;237import com.openai.models.beta.agents.HostedEnvironmentFileParam;

206import com.openai.models.beta.agents.sessions.SessionCreateParams;238import com.openai.models.beta.agents.sessions.SessionCreateParams;

239import com.openai.services.beta.agents.AgentTurnResults;

240import java.nio.file.Path;

207 241 

208public class HostedReport {242public class HostedReport {

209 public static void main(String[] args) throws Exception {243 public static void main(String[] args) throws Exception {

230 .build();264 .build();

231 265 

232 try (var stream = client.beta().agents().sessions().createStreaming(params)) {266 try (var stream = client.beta().agents().sessions().createStreaming(params)) {

267 AgentTurnResults.withResultCollection(stream);

233 stream.stream().forEach(System.out::println);268 stream.stream().forEach(System.out::println);

269 var result = AgentTurnResults.getFinalResult(stream);

270 AgentArtifactDownloads.forResult(client.beta().agents().sessions().artifacts(), result)

271 .download("/workspace/outputs/summary.json", Path.of("summary.json"));

234 }272 }

235 }273 }

236}274}

239```ruby277```ruby

240require "openai"278require "openai"

241require "json"279require "json"

280require "pathname"

242 281 

243client = OpenAI::Client.new282client = OpenAI::Client.new

244stream = client.beta.agents.sessions.create_streaming(283stream = client.beta.agents.sessions.create_streaming(

258)297)

259 298 

260begin299begin

300 stream.with_result_collection

261 stream.each { |event| puts event.to_json }301 stream.each { |event| puts event.to_json }

302 result = stream.get_final_result

303 puts result.output_text

304 client.beta.agents.sessions.artifacts.for_result(result).download(

305 path: "/workspace/outputs/summary.json",

306 to: Pathname("summary.json")

307 )

262ensure308ensure

263 stream.close309 stream.close

264end310end

41 "Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL.",41 "Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL.",

42 stream: true,42 stream: true,

43});43});

44for await (const event of events) {44events.withResultCollection();

45try {

46 for await (const event of events) {

45 console.log(JSON.stringify(event));47 console.log(JSON.stringify(event));

48 }

49 console.log((await events.finalResult()).output_text);

50} finally {

51 events.controller.abort();

46}52}

47```53```

48 54 

60 environment={"type": "none"},66 environment={"type": "none"},

61 input="Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL.",67 input="Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL.",

62 stream=True,68 stream=True,

63) as events:69).with_result_collection() as stream:

64 for event in events:70 for event in stream:

65 print(event.model_dump_json())71 print(event.model_dump_json())

72 result = stream.get_final_result()

73print(result.output_text)

66```74```

67 75 

68```go76```go

81 Environment: openai.EnvironmentParamUnion{OfParamNone: &openai.EnvironmentParamNone{}},89 Environment: openai.EnvironmentParamUnion{OfParamNone: &openai.EnvironmentParamNone{}},

82 Input: openai.BetaAgentSessionNewParamsInputUnion{OfString: openai.String("Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL.")}})90 Input: openai.BetaAgentSessionNewParamsInputUnion{OfString: openai.String("Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL.")}})

83defer events.Close()91defer events.Close()

92openai.BetaAgentSessionWithResultCollection(events)

84for events.Next() {93for events.Next() {

85 fmt.Println(events.Current().RawJSON())94 fmt.Println(events.Current().RawJSON())

86}95}

87if err := events.Err(); err != nil {96result, err := openai.BetaAgentSessionFinalResult(events)

97if err != nil {

88 panic(err)98 panic(err)

89}99}

100fmt.Println(result.OutputText())

90```101```

91 102 

92```java103```java

94import com.openai.client.okhttp.OpenAIOkHttpClient;105import com.openai.client.okhttp.OpenAIOkHttpClient;

95import com.openai.models.beta.agents.MultiAgentConfigParam;106import com.openai.models.beta.agents.MultiAgentConfigParam;

96import com.openai.models.beta.agents.sessions.SessionCreateParams;107import com.openai.models.beta.agents.sessions.SessionCreateParams;

108import com.openai.services.beta.agents.AgentTurnResults;

97 109 

98OpenAIClient client = OpenAIOkHttpClient.fromEnv();110OpenAIClient client = OpenAIOkHttpClient.fromEnv();

99try (var events =111try (var events =

125 + " download URL instead of file bytes. Update clients to fetch that"137 + " download URL instead of file bytes. Update clients to fetch that"

126 + " URL.")138 + " URL.")

127 .build())) {139 .build())) {

140 AgentTurnResults.withResultCollection(events);

128 events.stream().forEach(System.out::println);141 events.stream().forEach(System.out::println);

142 System.out.println(AgentTurnResults.getFinalResult(events).outputText());

129}143}

130```144```

131 145 

148 input: "Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL."162 input: "Release A: Search now supports filtering by date. Existing queries continue to work. Release B: The export endpoint now returns a download URL instead of file bytes. Update clients to fetch that URL."

149)163)

150begin164begin

165 events.with_result_collection

151 events.each { |event| puts JSON.generate(event.to_h) }166 events.each { |event| puts JSON.generate(event.to_h) }

167 result = events.get_final_result

168 puts result.output_text

152ensure169ensure

153 events.close170 events.close

154end171end

48 environment={"type": "openai_hosted"},48 environment={"type": "openai_hosted"},

49 input="Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",49 input="Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",

50 stream=True,50 stream=True,

51 ) as events:51 ).with_result_collection() as stream:

52 for event in events:52 for event in stream:

53 print(event.to_json(indent=None), flush=True)53 print(event.to_json(indent=None), flush=True)

54 result = stream.get_final_result()

55 print(result.output_text)

56 session_id = result.session_id

54```57```

55 58 

56 59 

93 "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",96 "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",

94 stream: true,97 stream: true,

95});98});

99events.withResultCollection();

96try {100try {

97 for await (const event of events) {101 for await (const event of events) {

98 console.log(JSON.stringify(event));102 console.log(JSON.stringify(event));

99 }103 }

104 const result = await events.finalResult();

105 console.log(result.output_text);

106 console.log("Session:", result.session_id);

100} finally {107} finally {

101 events.controller.abort();108 events.controller.abort();

102}109}

150 },157 },

151})158})

152defer events.Close()159defer events.Close()

160openai.BetaAgentSessionWithResultCollection(events)

153if events.Err() != nil {161if events.Err() != nil {

154 panic(events.Err())162 panic(events.Err())

155}163}

157 event := events.Current()165 event := events.Current()

158 fmt.Println(event.RawJSON())166 fmt.Println(event.RawJSON())

159}167}

160if err := events.Err(); err != nil {168result, err := openai.BetaAgentSessionFinalResult(events)

169if err != nil {

161 panic(err)170 panic(err)

162}171}

172fmt.Println(result.OutputText())

173sessionID := result.SessionID()

174fmt.Println("Session:", sessionID)

163```175```

164 176 

165 177 

201import com.openai.models.beta.agents.AgentSessionEvent;213import com.openai.models.beta.agents.AgentSessionEvent;

202import com.openai.models.beta.agents.EnvironmentParam;214import com.openai.models.beta.agents.EnvironmentParam;

203import com.openai.models.beta.agents.sessions.SessionCreateParams;215import com.openai.models.beta.agents.sessions.SessionCreateParams;

216import com.openai.services.beta.agents.AgentTurnResults;

204 217 

205OpenAIClient client = OpenAIOkHttpClient.fromEnv();218OpenAIClient client = OpenAIOkHttpClient.fromEnv();

206var json = new JsonMapper();219var json = new JsonMapper();

221 "Create tree.py, a Python script that prints a readable tree of the files"234 "Create tree.py, a Python script that prints a readable tree of the files"

222 + " in the current directory. Run it and show me the output.")235 + " in the current directory. Run it and show me the output.")

223 .build())) {236 .build())) {

237 AgentTurnResults.withResultCollection(events);

224 var iterator = events.stream().iterator();238 var iterator = events.stream().iterator();

225 while (iterator.hasNext()) {239 while (iterator.hasNext()) {

226 var event = iterator.next();240 var event = iterator.next();

227 System.out.println(json.writeValueAsString(event));241 System.out.println(json.writeValueAsString(event));

228 }242 }

243 var result = AgentTurnResults.getFinalResult(events);

244 System.out.println(result.outputText());

245 String sessionId = result.sessionId();

246 System.out.println(sessionId);

229}247}

230```248```

231 249 

269 input: "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output."287 input: "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output."

270)288)

271begin289begin

290 events.with_result_collection

272 events.each do |event|291 events.each do |event|

273 puts JSON.generate(event.to_h)292 puts JSON.generate(event.to_h)

274 end293 end

294 result = events.get_final_result

295 puts result.output_text

296 session_id = result.session_id

297 puts "Session: #{session_id}"

275ensure298ensure

276 events.close299 events.close

277end300end

38 "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",38 "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",

39 stream: true,39 stream: true,

40});40});

41events.withResultCollection();

41try {42try {

42 for await (const event of events) {43 for await (const event of events) {

43 console.log(JSON.stringify(event));44 console.log(JSON.stringify(event));

44 }45 }

46 const result = await events.finalResult();

47 console.log(result.output_text);

48 console.log("Session:", result.session_id);

45} finally {49} finally {

46 events.controller.abort();50 events.controller.abort();

47}51}

59 environment={"type": "openai_hosted"},63 environment={"type": "openai_hosted"},

60 input="Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",64 input="Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output.",

61 stream=True,65 stream=True,

62 ) as events:66 ).with_result_collection() as stream:

63 for event in events:67 for event in stream:

64 print(event.to_json(indent=None), flush=True)68 print(event.to_json(indent=None), flush=True)

69 result = stream.get_final_result()

70 print(result.output_text)

71 session_id = result.session_id

65```72```

66 73 

67```go74```go

85 },92 },

86})93})

87defer events.Close()94defer events.Close()

95openai.BetaAgentSessionWithResultCollection(events)

88if events.Err() != nil {96if events.Err() != nil {

89 panic(events.Err())97 panic(events.Err())

90}98}

92 event := events.Current()100 event := events.Current()

93 fmt.Println(event.RawJSON())101 fmt.Println(event.RawJSON())

94}102}

95if err := events.Err(); err != nil {103result, err := openai.BetaAgentSessionFinalResult(events)

104if err != nil {

96 panic(err)105 panic(err)

97}106}

107fmt.Println(result.OutputText())

108sessionID := result.SessionID()

109fmt.Println("Session:", sessionID)

98```110```

99 111 

100```java112```java

105import com.openai.models.beta.agents.AgentSessionEvent;117import com.openai.models.beta.agents.AgentSessionEvent;

106import com.openai.models.beta.agents.EnvironmentParam;118import com.openai.models.beta.agents.EnvironmentParam;

107import com.openai.models.beta.agents.sessions.SessionCreateParams;119import com.openai.models.beta.agents.sessions.SessionCreateParams;

120import com.openai.services.beta.agents.AgentTurnResults;

108 121 

109OpenAIClient client = OpenAIOkHttpClient.fromEnv();122OpenAIClient client = OpenAIOkHttpClient.fromEnv();

110var json = new JsonMapper();123var json = new JsonMapper();

125 "Create tree.py, a Python script that prints a readable tree of the files"138 "Create tree.py, a Python script that prints a readable tree of the files"

126 + " in the current directory. Run it and show me the output.")139 + " in the current directory. Run it and show me the output.")

127 .build())) {140 .build())) {

141 AgentTurnResults.withResultCollection(events);

128 var iterator = events.stream().iterator();142 var iterator = events.stream().iterator();

129 while (iterator.hasNext()) {143 while (iterator.hasNext()) {

130 var event = iterator.next();144 var event = iterator.next();

131 System.out.println(json.writeValueAsString(event));145 System.out.println(json.writeValueAsString(event));

132 }146 }

147 var result = AgentTurnResults.getFinalResult(events);

148 System.out.println(result.outputText());

149 String sessionId = result.sessionId();

150 System.out.println(sessionId);

133}151}

134```152```

135 153 

147 input: "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output."165 input: "Create tree.py, a Python script that prints a readable tree of the files in the current directory. Run it and show me the output."

148)166)

149begin167begin

168 events.with_result_collection

150 events.each do |event|169 events.each do |event|

151 puts JSON.generate(event.to_h)170 puts JSON.generate(event.to_h)

152 end171 end

172 result = events.get_final_result

173 puts result.output_text

174 session_id = result.session_id

175 puts "Session: #{session_id}"

153ensure176ensure

154 events.close177 events.close

155end178end

55}55}

56```56```

57 57 

58```java

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

60import com.openai.models.completions.CompletionCreateParams;

61 

62var completion =

63 client

64 .completions()

65 .create(

66 CompletionCreateParams.builder()

67 .model("gpt-3.5-turbo-instruct")

68 .prompt("Write a tagline for an ice cream shop.")

69 .build());

70completion.choices().forEach(choice -> System.out.println(choice.text()));

71```

72 

58```ruby73```ruby

59require "openai"74require "openai"

60 75 

110}110}

111```111```

112 112 

113```java

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

115import com.openai.models.contentprovenancechecks.ContentProvenanceCheckCreateParams;

116import java.nio.file.Path;

117 

118var result =

119 client

120 .contentProvenanceChecks()

121 .create(

122 ContentProvenanceCheckCreateParams.builder().file(Path.of("myimage.png")).build());

123System.out.println(result);

124```

125 

113```ruby126```ruby

114require "openai"127require "openai"

115require "pathname"128require "pathname"

232df.to_csv("output/embedded_1k_reviews.csv", index=False)232df.to_csv("output/embedded_1k_reviews.csv", index=False)

233```233```

234 234 

235```go

236import (

237 "context"

238 "encoding/csv"

239 "encoding/json"

240 "fmt"

241 "log"

242 "os"

243 "strings"

244 

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

246)

247 

248func main() {

249 if err := run(); err != nil {

250 log.Fatal(err)

251 }

252}

253 

254func run() error {

255 client := openai.NewClient()

256 ctx := context.Background()

257 reviews := []string{"A rich cup of coffee.", "A bright herbal tea."}

258 if err := os.MkdirAll("output", 0755); err != nil {

259 return err

260 }

261 file, err := os.Create("output/embedded_1k_reviews.csv")

262 if err != nil {

263 return err

264 }

265 defer file.Close()

266 writer := csv.NewWriter(file)

267 if err := writer.Write([]string{"combined", "ada_embedding"}); err != nil {

268 return err

269 }

270 for _, review := range reviews {

271 vector, err := embedding(ctx, &client, strings.ReplaceAll(review, "\n", " "))

272 if err != nil {

273 return err

274 }

275 encoded, err := json.Marshal(vector)

276 if err != nil {

277 return err

278 }

279 if err := writer.Write([]string{review, string(encoded)}); err != nil {

280 return err

281 }

282 }

283 writer.Flush()

284 if err := writer.Error(); err != nil {

285 return err

286 }

287 if err := file.Close(); err != nil {

288 return err

289 }

290 fmt.Println("Saved output/embedded_1k_reviews.csv")

291 return nil

292}

293 

294func embedding(ctx context.Context, client *openai.Client, text string) ([]float64, error) {

295 response, err := client.Embeddings.New(ctx, openai.EmbeddingNewParams{

296 Model: openai.EmbeddingModelTextEmbedding3Small,

297 Input: openai.EmbeddingNewParamsInputUnion{OfString: openai.String(text)},

298 })

299 if err != nil {

300 return nil, err

301 }

302 return response.Data[0].Embedding, nil

303}

304```

305 

235```java306```java

236import com.openai.client.OpenAIClient;307import com.openai.client.OpenAIClient;

237import com.openai.client.okhttp.OpenAIOkHttpClient;308import com.openai.client.okhttp.OpenAIOkHttpClient;

268System.out.println(output);339System.out.println(output);

269```340```

270 341 

342```csharp

343using System.Text.Json;

344using OpenAI.Embeddings;

345 

346string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

347string model = "text-embedding-3-small";

348EmbeddingClient client = new(model, key);

349 

350string[] reviews = ["A rich cup of coffee.", "A bright herbal tea."];

351Directory.CreateDirectory("output");

352using StreamWriter writer = new("output/embedded_1k_reviews.csv");

353await writer.WriteLineAsync("combined,ada_embedding");

354foreach (string review in reviews)

355{

356 float[] vector = await EmbedAsync(client, review.Replace("\n", " ", StringComparison.Ordinal));

357 string encoded = JsonSerializer.Serialize(vector);

358 await writer.WriteLineAsync($"{CsvField(review)},{CsvField(encoded)}");

359}

360Console.WriteLine("Saved output/embedded_1k_reviews.csv");

361 

362static async Task<float[]> EmbedAsync(EmbeddingClient client, string text)

363{

364 OpenAIEmbedding result = await client.GenerateEmbeddingAsync(text);

365 return result.ToFloats().ToArray();

366}

367 

368static string CsvField(string value) => "\"" + value.Replace("\"", "\"\"", StringComparison.Ordinal) + "\"";

369```

370 

271```ruby371```ruby

272require "csv"372require "csv"

273require "fileutils"373require "fileutils"

502print(response.choices[0].message.content)602print(response.choices[0].message.content)

503```603```

504 604 

605```go

606import (

607 "context"

608 "fmt"

609 "log"

610 

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

612)

613 

614func main() {

615 if err := run(); err != nil {

616 log.Fatal(err)

617 }

618}

619 

620func run() error {

621 client := openai.NewClient()

622 completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

623 Model: "gpt-4.1-mini", Temperature: openai.Float(0), Messages: []openai.ChatCompletionMessageParamUnion{

624 openai.SystemMessage("You answer questions about the 2022 Winter Olympics."),

625 openai.UserMessage("Use the article to answer the question. If the answer cannot be found, write \"I don't know.\"\n\nArticle: At the 2022 Winter Olympics, Great Britain won women's curling and Sweden won men's curling.\n\nQuestion: Which athletes won the gold medal in curling at the 2022 Winter Olympics?")},

626 })

627 if err != nil {

628 return err

629 }

630 fmt.Println(completion.Choices[0].Message.Content)

631 return nil

632}

633```

634 

505```java635```java

506import com.openai.client.OpenAIClient;636import com.openai.client.OpenAIClient;

507import com.openai.client.okhttp.OpenAIOkHttpClient;637import com.openai.client.okhttp.OpenAIOkHttpClient;

529 .forEach(System.out::println);659 .forEach(System.out::println);

530```660```

531 661 

662```csharp

663using OpenAI.Chat;

664 

665string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

666string model = "gpt-4.1-mini";

667ChatClient client = new(model, key);

668 

669string article = "At the 2022 Winter Olympics, Great Britain won women's curling and Sweden won men's curling.";

670string query = $"Use the article to answer the question. If the answer cannot be found, write I don't know.\nArticle: {article}\nQuestion: Which athletes won the gold medal in curling at the 2022 Winter Olympics?";

671ChatCompletion result = await client.CompleteChatAsync(

672 [new SystemChatMessage("You answer questions about the 2022 Winter Olympics."), new UserChatMessage(query)],

673 new ChatCompletionOptions { Temperature = 0 });

674Console.WriteLine(result.Content[0].Text);

675```

676 

532```ruby677```ruby

533require "openai"678require "openai"

534 679 

627res = search_reviews(df, "delicious beans", n=3)772res = search_reviews(df, "delicious beans", n=3)

628```773```

629 774 

775```go

776import (

777 "context"

778 "fmt"

779 "log"

780 "math"

781 "sort"

782 

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

784)

785 

786func main() {

787 if err := run(); err != nil {

788 log.Fatal(err)

789 }

790}

791 

792func run() error {

793 client := openai.NewClient()

794 ctx := context.Background()

795 texts := []string{"A rich cup of coffee.", "Crunchy crackers with sea salt.", "Dark chocolate with orange.", "A bright herbal tea.", "Smooth beans in tomato sauce.", "A mild cheese with herbs.", "Spicy roasted nuts.", "A crisp sparkling water."}

796 vectors := make([][]float64, len(texts))

797 for i, text := range texts {

798 vector, err := embedding(ctx, &client, text)

799 if err != nil {

800 return err

801 }

802 vectors[i] = vector

803 }

804 query, err := embedding(ctx, &client, "delicious beans")

805 if err != nil {

806 return err

807 }

808 matches := nearest(query, vectors)

809 for _, match := range matches[:min(3, len(matches))] {

810 fmt.Printf("%0.3f: %s\n", match.Similarity, texts[match.Index])

811 }

812 return nil

813}

814 

815func embedding(ctx context.Context, client *openai.Client, text string) ([]float64, error) {

816 response, err := client.Embeddings.New(ctx, openai.EmbeddingNewParams{

817 Model: openai.EmbeddingModelTextEmbedding3Small,

818 Input: openai.EmbeddingNewParamsInputUnion{OfString: openai.String(text)},

819 })

820 if err != nil {

821 return nil, err

822 }

823 return response.Data[0].Embedding, nil

824}

825 

826func cosineSimilarity(a, b []float64) float64 {

827 var dot, left, right float64

828 for i := range a {

829 dot += a[i] * b[i]

830 left += a[i] * a[i]

831 right += b[i] * b[i]

832 }

833 return dot / math.Sqrt(left*right)

834}

835 

836type match struct {

837 Index int

838 Similarity float64

839}

840 

841func nearest(query []float64, vectors [][]float64) []match {

842 matches := make([]match, len(vectors))

843 for i, vector := range vectors {

844 matches[i] = match{Index: i, Similarity: cosineSimilarity(query, vector)}

845 }

846 sort.SliceStable(matches, func(i, j int) bool { return matches[i].Similarity > matches[j].Similarity })

847 return matches

848}

849```

850 

630```java851```java

631import com.openai.client.OpenAIClient;852import com.openai.client.OpenAIClient;

632import com.openai.client.okhttp.OpenAIOkHttpClient;853import com.openai.client.okhttp.OpenAIOkHttpClient;

673 .forEach(System.out::println);894 .forEach(System.out::println);

674```895```

675 896 

897```csharp

898using OpenAI.Embeddings;

899 

900string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

901string model = "text-embedding-3-small";

902EmbeddingClient client = new(model, key);

903 

904string[] texts = ["A rich cup of coffee.", "Crunchy crackers with sea salt.", "Dark chocolate with orange.", "A bright herbal tea.", "Smooth beans in tomato sauce.", "A mild cheese with herbs.", "Spicy roasted nuts.", "A crisp sparkling water."];

905OpenAIEmbeddingCollection batch = await client.GenerateEmbeddingsAsync(texts);

906float[][] vectors = batch.Select(item => item.ToFloats().ToArray()).ToArray();

907float[] query = await EmbedAsync(client, "delicious beans");

908var ranked = vectors.Select((vector, index) => new { Index = index, Similarity = CosineSimilarity(query, vector) }).OrderByDescending(match => match.Similarity);

909foreach (var match in ranked.Take(3))

910{

911 Console.WriteLine($"{match.Similarity:F3}: {texts[match.Index]}");

912}

913 

914static async Task<float[]> EmbedAsync(EmbeddingClient client, string text)

915{

916 OpenAIEmbedding result = await client.GenerateEmbeddingAsync(text);

917 return result.ToFloats().ToArray();

918}

919 

920static double CosineSimilarity(float[] left, float[] right)

921{

922 double dot = 0, leftNorm = 0, rightNorm = 0;

923 for (int i = 0; i < left.Length; i++)

924 {

925 dot += left[i] * right[i];

926 leftNorm += left[i] * left[i];

927 rightNorm += right[i] * right[i];

928 }

929 return dot / Math.Sqrt(leftNorm * rightNorm);

930}

931```

932 

676```ruby933```ruby

677require "openai"934require "openai"

678 935 

778res = search_functions(df, "Completions API tests", n=3)1035res = search_functions(df, "Completions API tests", n=3)

779```1036```

780 1037 

1038```go

1039import (

1040 "context"

1041 "fmt"

1042 "log"

1043 "math"

1044 "sort"

1045 

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

1047)

1048 

1049func main() {

1050 if err := run(); err != nil {

1051 log.Fatal(err)

1052 }

1053}

1054 

1055func run() error {

1056 client := openai.NewClient()

1057 ctx := context.Background()

1058 texts := []string{"def add(a, b): return a + b", "def complete(prompt): return prompt"}

1059 vectors := make([][]float64, len(texts))

1060 for i, text := range texts {

1061 vector, err := embedding(ctx, &client, text)

1062 if err != nil {

1063 return err

1064 }

1065 vectors[i] = vector

1066 }

1067 query, err := embedding(ctx, &client, "Completions API tests")

1068 if err != nil {

1069 return err

1070 }

1071 matches := nearest(query, vectors)

1072 for _, match := range matches[:min(3, len(matches))] {

1073 fmt.Printf("%0.3f: %s\n", match.Similarity, texts[match.Index])

1074 }

1075 return nil

1076}

1077 

1078func embedding(ctx context.Context, client *openai.Client, text string) ([]float64, error) {

1079 response, err := client.Embeddings.New(ctx, openai.EmbeddingNewParams{

1080 Model: openai.EmbeddingModelTextEmbedding3Small,

1081 Input: openai.EmbeddingNewParamsInputUnion{OfString: openai.String(text)},

1082 })

1083 if err != nil {

1084 return nil, err

1085 }

1086 return response.Data[0].Embedding, nil

1087}

1088 

1089func cosineSimilarity(a, b []float64) float64 {

1090 var dot, left, right float64

1091 for i := range a {

1092 dot += a[i] * b[i]

1093 left += a[i] * a[i]

1094 right += b[i] * b[i]

1095 }

1096 return dot / math.Sqrt(left*right)

1097}

1098 

1099type match struct {

1100 Index int

1101 Similarity float64

1102}

1103 

1104func nearest(query []float64, vectors [][]float64) []match {

1105 matches := make([]match, len(vectors))

1106 for i, vector := range vectors {

1107 matches[i] = match{Index: i, Similarity: cosineSimilarity(query, vector)}

1108 }

1109 sort.SliceStable(matches, func(i, j int) bool { return matches[i].Similarity > matches[j].Similarity })

1110 return matches

1111}

1112```

1113 

781```java1114```java

782import com.openai.client.OpenAIClient;1115import com.openai.client.OpenAIClient;

783import com.openai.client.okhttp.OpenAIOkHttpClient;1116import com.openai.client.okhttp.OpenAIOkHttpClient;

819 .forEach(System.out::println);1152 .forEach(System.out::println);

820```1153```

821 1154 

1155```csharp

1156using OpenAI.Embeddings;

1157 

1158string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1159string model = "text-embedding-3-small";

1160EmbeddingClient client = new(model, key);

1161 

1162string[] texts = ["def add(a, b): return a + b", "def complete(prompt): return prompt"];

1163List<float[]> vectors = [];

1164foreach (string text in texts)

1165{

1166 vectors.Add(await EmbedAsync(client, text));

1167}

1168float[] query = await EmbedAsync(client, "Completions API tests");

1169var ranked = vectors.Select((vector, index) => new { Index = index, Similarity = CosineSimilarity(query, vector) }).OrderByDescending(match => match.Similarity);

1170foreach (var match in ranked.Take(3))

1171{

1172 Console.WriteLine($"{match.Similarity:F3}: {texts[match.Index]}");

1173}

1174 

1175static async Task<float[]> EmbedAsync(EmbeddingClient client, string text)

1176{

1177 OpenAIEmbedding result = await client.GenerateEmbeddingAsync(text);

1178 return result.ToFloats().ToArray();

1179}

1180 

1181static double CosineSimilarity(float[] left, float[] right)

1182{

1183 double dot = 0, leftNorm = 0, rightNorm = 0;

1184 for (int i = 0; i < left.Length; i++)

1185 {

1186 dot += left[i] * right[i];

1187 leftNorm += left[i] * left[i];

1188 rightNorm += right[i] * right[i];

1189 }

1190 return dot / Math.Sqrt(leftNorm * rightNorm);

1191}

1192```

1193 

822```ruby1194```ruby

823require "openai"1195require "openai"

824 1196 

928 return indices_of_nearest_neighbors1300 return indices_of_nearest_neighbors

929```1301```

930 1302 

1303```go

1304import (

1305 "context"

1306 "fmt"

1307 "log"

1308 "math"

1309 "sort"

1310 

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

1312)

1313 

1314func main() {

1315 if err := run(); err != nil {

1316 log.Fatal(err)

1317 }

1318}

1319 

1320func run() error {

1321 client := openai.NewClient()

1322 ctx := context.Background()

1323 texts := []string{"A cheetah is a fast land animal.", "A peregrine falcon is a fast bird.", "A tortoise moves slowly."}

1324 vectors := make([][]float64, len(texts))

1325 for i, text := range texts {

1326 vector, err := embedding(ctx, &client, text)

1327 if err != nil {

1328 return err

1329 }

1330 vectors[i] = vector

1331 }

1332 query := vectors[0]

1333 matches := nearest(query, vectors)

1334 for _, match := range matches {

1335 fmt.Println(match.Index)

1336 }

1337 return nil

1338}

1339 

1340func embedding(ctx context.Context, client *openai.Client, text string) ([]float64, error) {

1341 response, err := client.Embeddings.New(ctx, openai.EmbeddingNewParams{

1342 Model: openai.EmbeddingModelTextEmbedding3Small,

1343 Input: openai.EmbeddingNewParamsInputUnion{OfString: openai.String(text)},

1344 })

1345 if err != nil {

1346 return nil, err

1347 }

1348 return response.Data[0].Embedding, nil

1349}

1350 

1351func cosineSimilarity(a, b []float64) float64 {

1352 var dot, left, right float64

1353 for i := range a {

1354 dot += a[i] * b[i]

1355 left += a[i] * a[i]

1356 right += b[i] * b[i]

1357 }

1358 return dot / math.Sqrt(left*right)

1359}

1360 

1361type match struct {

1362 Index int

1363 Similarity float64

1364}

1365 

1366func nearest(query []float64, vectors [][]float64) []match {

1367 matches := make([]match, len(vectors))

1368 for i, vector := range vectors {

1369 matches[i] = match{Index: i, Similarity: cosineSimilarity(query, vector)}

1370 }

1371 sort.SliceStable(matches, func(i, j int) bool { return matches[i].Similarity > matches[j].Similarity })

1372 return matches

1373}

1374```

1375 

931```java1376```java

932import com.openai.client.OpenAIClient;1377import com.openai.client.OpenAIClient;

933import com.openai.client.okhttp.OpenAIOkHttpClient;1378import com.openai.client.okhttp.OpenAIOkHttpClient;

975System.out.println(nearestNeighbors);1420System.out.println(nearestNeighbors);

976```1421```

977 1422 

1423```csharp

1424using OpenAI.Embeddings;

1425 

1426string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1427string model = "text-embedding-3-small";

1428EmbeddingClient client = new(model, key);

1429 

1430string[] texts = ["A cheetah is a fast land animal.", "A peregrine falcon is a fast bird.", "A tortoise moves slowly."];

1431List<float[]> vectors = [];

1432foreach (string text in texts)

1433{

1434 vectors.Add(await EmbedAsync(client, text));

1435}

1436float[] query = vectors[0];

1437var ranked = vectors.Select((vector, index) => new { Index = index, Similarity = CosineSimilarity(query, vector) }).OrderByDescending(match => match.Similarity);

1438foreach (var match in ranked)

1439{

1440 Console.WriteLine(match.Index);

1441}

1442 

1443static async Task<float[]> EmbedAsync(EmbeddingClient client, string text)

1444{

1445 OpenAIEmbedding result = await client.GenerateEmbeddingAsync(text);

1446 return result.ToFloats().ToArray();

1447}

1448 

1449static double CosineSimilarity(float[] left, float[] right)

1450{

1451 double dot = 0, leftNorm = 0, rightNorm = 0;

1452 for (int i = 0; i < left.Length; i++)

1453 {

1454 dot += left[i] * right[i];

1455 leftNorm += left[i] * left[i];

1456 rightNorm += right[i] * right[i];

1457 }

1458 return dot / Math.Sqrt(leftNorm * rightNorm);

1459}

1460```

1461 

978```ruby1462```ruby

979require "openai"1463require "openai"

980 1464 

1200)1684)

1201```1685```

1202 1686 

1687```go

1688import (

1689 "context"

1690 "fmt"

1691 "log"

1692 "math"

1693 

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

1695)

1696 

1697func main() {

1698 if err := run(); err != nil {

1699 log.Fatal(err)

1700 }

1701}

1702 

1703func run() error {

1704 client := openai.NewClient()

1705 ctx := context.Background()

1706 negative, err := embedding(ctx, &client, "negative")

1707 if err != nil {

1708 return err

1709 }

1710 positive, err := embedding(ctx, &client, "positive")

1711 if err != nil {

1712 return err

1713 }

1714 review, err := embedding(ctx, &client, "Sample Review")

1715 if err != nil {

1716 return err

1717 }

1718 score := cosineSimilarity(review, positive) - cosineSimilarity(review, negative)

1719 prediction := "negative"

1720 if score > 0 {

1721 prediction = "positive"

1722 }

1723 fmt.Println(prediction)

1724 return nil

1725}

1726 

1727func embedding(ctx context.Context, client *openai.Client, text string) ([]float64, error) {

1728 response, err := client.Embeddings.New(ctx, openai.EmbeddingNewParams{

1729 Model: openai.EmbeddingModelTextEmbedding3Small,

1730 Input: openai.EmbeddingNewParamsInputUnion{OfString: openai.String(text)},

1731 })

1732 if err != nil {

1733 return nil, err

1734 }

1735 return response.Data[0].Embedding, nil

1736}

1737 

1738func cosineSimilarity(a, b []float64) float64 {

1739 var dot, left, right float64

1740 for i := range a {

1741 dot += a[i] * b[i]

1742 left += a[i] * a[i]

1743 right += b[i] * b[i]

1744 }

1745 return dot / math.Sqrt(left*right)

1746}

1747```

1748 

1203```java1749```java

1204import com.openai.client.OpenAIClient;1750import com.openai.client.OpenAIClient;

1205import com.openai.client.okhttp.OpenAIOkHttpClient;1751import com.openai.client.okhttp.OpenAIOkHttpClient;

1222System.out.println(positive > negative ? "positive" : "negative");1768System.out.println(positive > negative ? "positive" : "negative");

1223```1769```

1224 1770 

1771```csharp

1772using OpenAI.Embeddings;

1773 

1774string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1775string model = "text-embedding-3-small";

1776EmbeddingClient client = new(model, key);

1777 

1778float[] negative = await EmbedAsync(client, "negative");

1779float[] positive = await EmbedAsync(client, "positive");

1780float[] review = await EmbedAsync(client, "Sample Review");

1781double score = CosineSimilarity(review, positive) - CosineSimilarity(review, negative);

1782Console.WriteLine(score > 0 ? "positive" : "negative");

1783 

1784static async Task<float[]> EmbedAsync(EmbeddingClient client, string text)

1785{

1786 OpenAIEmbedding result = await client.GenerateEmbeddingAsync(text);

1787 return result.ToFloats().ToArray();

1788}

1789 

1790static double CosineSimilarity(float[] left, float[] right)

1791{

1792 double dot = 0, leftNorm = 0, rightNorm = 0;

1793 for (int i = 0; i < left.Length; i++)

1794 {

1795 dot += left[i] * right[i];

1796 leftNorm += left[i] * left[i];

1797 rightNorm += right[i] * right[i];

1798 }

1799 return dot / Math.Sqrt(leftNorm * rightNorm);

1800}

1801```

1802 

1225```ruby1803```ruby

1226require "openai"1804require "openai"

1227 1805 

810}810}

811```811```

812 812 

813```java

814import com.fasterxml.jackson.databind.JsonNode;

815import com.fasterxml.jackson.databind.ObjectMapper;

816import java.util.Map;

817 

818var argsJson = new ObjectMapper().readTree("{\"location\":\"Paris, France\"}");

819System.out.println(callFunction("get_weather", argsJson));

820 

821// These local fixtures demonstrate dispatch; replace them with your application services.

822// The email fixture prints its inputs and does not send a message.

823static Map<String, Object> callFunction(String name, JsonNode arguments) {

824 return switch (name) {

825 case "get_weather" -> getWeather(arguments.get("location").asText());

826 case "send_email" -> sendEmail(arguments.get("to").asText(), arguments.get("body").asText());

827 default -> throw new IllegalArgumentException("Unknown function: " + name);

828 };

829}

830 

831private static Map<String, Object> getWeather(String location) {

832 int temperature =

833 switch (location) {

834 case "Bogotá, Colombia" -> 18;

835 case "Paris, France" -> 15;

836 default -> 20;

837 };

838 return Map.of("location", location, "temperature_celsius", temperature);

839}

840 

841private static Map<String, Object> sendEmail(String to, String body) {

842 System.out.println("Sending email to " + to + ": " + body);

843 return Map.of("status", "sent");

844}

845```

846 

847```csharp

848using System.Text.Json;

849 

850using JsonDocument arguments = JsonDocument.Parse("{\"location\":\"Paris, France\"}");

851Console.WriteLine(FunctionDispatcher.CallFunction("get_weather", arguments.RootElement));

852 

853internal static class FunctionDispatcher

854{

855 // These local fixtures demonstrate dispatch; replace them with your application services.

856 // The email fixture prints its inputs and does not send a message.

857 internal static string CallFunction(string name, JsonElement arguments) => name switch

858 {

859 "get_weather" => GetWeather(arguments.GetProperty("location").GetString()!),

860 "send_email" => SendEmail(arguments.GetProperty("to").GetString()!, arguments.GetProperty("body").GetString()!),

861 _ => throw new ArgumentException($"Unknown function: {name}", nameof(name))

862 };

863 private static string GetWeather(string location) => JsonSerializer.Serialize(new { location, temperature_celsius = location switch { "Bogotá, Colombia" => 18, "Paris, France" => 15, _ => 20 } });

864 private static string SendEmail(string to, string body)

865 {

866 Console.WriteLine($"Sending email to {to}: {body}");

867 return "{\"status\":\"sent\"}";

868 }

869}

870```

871 

813```ruby872```ruby

814def call_function(name, arguments)873def call_function(name, arguments)

815 case name874 case name

1604}1604}

1605```1605```

1606 1606 

1607```java

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

1609import com.openai.models.images.ImageGenerateParams;

1610import java.nio.file.Files;

1611import java.nio.file.Path;

1612import java.util.Base64;

1613 

1614var params =

1615 ImageGenerateParams.builder()

1616 .prompt(

1617 "Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape")

1618 .model("gpt-image-2.5-sunburst")

1619 .partialImages(2)

1620 .build();

1621try (var stream = client.images().generateStreaming(params)) {

1622 var events = stream.stream().iterator();

1623 while (events.hasNext()) {

1624 var event = events.next();

1625 if (event.generationPartialImage().isPresent()) {

1626 var partial = event.generationPartialImage().orElseThrow();

1627 Files.write(

1628 Path.of("river" + partial.partialImageIndex() + ".png"),

1629 Base64.getDecoder().decode(partial.b64Json()));

1630 }

1631 }

1632}

1633```

1634 

1607```ruby1635```ruby

1608require "base64"1636require "base64"

1609require "openai"1637require "openai"

1825}1853}

1826```1854```

1827 1855 

1856```java

1857import java.nio.file.Files;

1858import java.nio.file.Path;

1859import java.util.Base64;

1860 

1861System.out.println(encodeImage(Path.of("example.png")));

1862 

1863private static String encodeImage(Path path) throws java.io.IOException {

1864 return Base64.getEncoder().encodeToString(Files.readAllBytes(path));

1865}

1866```

1867 

1868```csharp

1869using System;

1870 

1871Console.WriteLine(EncodeImage("example.png"));

1872 

1873static string EncodeImage(string filePath) => Convert.ToBase64String(File.ReadAllBytes(filePath));

1874```

1875 

1828```ruby1876```ruby

1829require "base64"1877require "base64"

1830 1878 

166 return completion.choices[0].message.content166 return completion.choices[0].message.content

167````167````

168 168 

169````go

170import (

171 "context"

172 "fmt"

173 "log"

174 

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

176)

177 

178func main() {

179 if err := run(); err != nil {

180 log.Fatal(err)

181 }

182}

183 

184func run() error {

185 client := openai.NewClient()

186 metaPrompt := "Given a task description or existing prompt, produce a detailed system prompt to guide a language model in completing the task effectively.\n" +

187 "\n" +

188 "# Guidelines\n" +

189 "\n" +

190 "- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.\n" +

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

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

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

194 " - Conclusion, classifications, or results should ALWAYS appear last.\n" +

195 "- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.\n" +

196 " - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.\n" +

197 "- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.\n" +

198 "- Formatting: Use markdown features for readability. DO NOT USE ``` CODE BLOCKS UNLESS SPECIFICALLY REQUESTED.\n" +

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

200 "- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.\n" +

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

202 " - For tasks outputting well-defined or structured data (classification, JSON, etc.) bias toward outputting a JSON.\n" +

203 " - JSON should never be wrapped in code blocks (```) unless explicitly requested.\n" +

204 "\n" +

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

206 "\n" +

207 "[Concise instruction describing the task - this should be the first line in the prompt, no section header]\n" +

208 "\n" +

209 "[Additional details as needed.]\n" +

210 "\n" +

211 "[Optional sections with headings or bullet points for detailed steps.]\n" +

212 "\n" +

213 "# Steps [optional]\n" +

214 "\n" +

215 "[optional: a detailed breakdown of the steps necessary to accomplish the task]\n" +

216 "\n" +

217 "# Output Format\n" +

218 "\n" +

219 "[Specifically call out how the output should be formatted, be it response length, structure e.g. JSON, markdown, etc]\n" +

220 "\n" +

221 "# Examples [optional]\n" +

222 "\n" +

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

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

225 "\n" +

226 "# Notes [optional]\n" +

227 "\n" +

228 "[optional: edge cases, details, and an area to call or repeat out specific important considerations]\n"

229 completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

230 Model: "gpt-6-astra",

231 Messages: []openai.ChatCompletionMessageParamUnion{

232 openai.SystemMessage(metaPrompt), openai.UserMessage("Task, Goal, or Current Prompt: Help a customer resolve a billing issue."),

233 }})

234 if err != nil {

235 return err

236 }

237 fmt.Println(completion.Choices[0].Message.Content)

238 return nil

239}

240````

241 

169````java242````java

170import com.openai.client.OpenAIClient;243import com.openai.client.OpenAIClient;

171import com.openai.client.okhttp.OpenAIOkHttpClient;244import com.openai.client.okhttp.OpenAIOkHttpClient;

232 .forEach(System.out::println);305 .forEach(System.out::println);

233````306````

234 307 

308````csharp

309using OpenAI.Chat;

310 

311string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

312string model = "gpt-6-astra";

313ChatClient client = new(model, key);

314 

315string metaPrompt = """"

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

317

318 # Guidelines

319

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

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

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

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

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

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

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

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

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

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

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

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

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

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

334

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

336

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

338

339 [Additional details as needed.]

340

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

342

343 # Steps [optional]

344

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

346

347 # Output Format

348

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

350

351 # Examples [optional]

352

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

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

355

356 # Notes [optional]

357

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

359 """";

360ChatCompletionOptions options = new();

361ChatCompletion result = await client.CompleteChatAsync([new SystemChatMessage(metaPrompt), new UserChatMessage("Task, Goal, or Current Prompt: Help a customer resolve a billing issue.")], options);

362Console.WriteLine(result.Content[0].Text);

363````

364 

235````ruby365````ruby

236require "openai"366require "openai"

237 367 

433 return completion.choices[0].message.content563 return completion.choices[0].message.content

434```564```

435 565 

566```go

567import (

568 "context"

569 "fmt"

570 "log"

571 

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

573)

574 

575func main() {

576 if err := run(); err != nil {

577 log.Fatal(err)

578 }

579}

580 

581func run() error {

582 client := openai.NewClient()

583 metaPrompt := "Given a task description or existing prompt, produce a detailed system prompt to guide a realtime audio output language model in completing the task effectively.\n" +

584 "\n" +

585 "# Guidelines\n" +

586 "\n" +

587 "- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.\n" +

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

589 "- Audio Output Constraints: Because the model is outputting audio, the responses should be short and conversational.\n" +

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

591 "- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.\n" +

592 " - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.\n" +

593 " - It is very important that any examples included reflect the short, conversational output responses of the model.\n" +

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

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

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

597 "- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.\n" +

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

599 "- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.\n" +

600 "\n" +

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

602 "\n" +

603 "[Concise instruction describing the task - this should be the first line in the prompt, no section header]\n" +

604 "\n" +

605 "[Additional details as needed.]\n" +

606 "\n" +

607 "[Optional sections with headings or bullet points for detailed steps.]\n" +

608 "\n" +

609 "# Examples [optional]\n" +

610 "\n" +

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

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

613 "\n" +

614 "# Notes [optional]\n" +

615 "\n" +

616 "[optional: edge cases, details, and an area to call or repeat out specific important considerations]\n"

617 completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

618 Model: "gpt-6-astra",

619 Messages: []openai.ChatCompletionMessageParamUnion{

620 openai.SystemMessage(metaPrompt), openai.UserMessage("Task, Goal, or Current Prompt: Help a customer resolve a billing issue."),

621 }})

622 if err != nil {

623 return err

624 }

625 fmt.Println(completion.Choices[0].Message.Content)

626 return nil

627}

628```

629 

436```java630```java

437import com.openai.client.OpenAIClient;631import com.openai.client.OpenAIClient;

438import com.openai.client.okhttp.OpenAIOkHttpClient;632import com.openai.client.okhttp.OpenAIOkHttpClient;

491 .forEach(System.out::println);685 .forEach(System.out::println);

492```686```

493 687 

688```csharp

689using OpenAI.Chat;

690 

691string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

692string model = "gpt-6-astra";

693ChatClient client = new(model, key);

694 

695string metaPrompt = """"

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

697

698 # Guidelines

699

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

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

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

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

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

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

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

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

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

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

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

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