OpenAI

https://developers.openai.com/
Admin
OpenAI Developers is a platform providing documentation, APIs, and tools for building AI...
Tokens:5,400,624
Snippets:33,995
Trust Score:9.4
Update:1 week ago
Show doc for...
Tokens:
Raw
### Run the Ruby example

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Executes the Ruby quickstart script.

```bash
ruby quickstart.rb
```

--------------------------------

### Install notebook dependencies

Source: https://developers.openai.com/cookbook/examples/multimodal/document_and_multimodal_understanding_tips

Install or upgrade the openai and pillow packages required for the notebook examples.

```bash
pip install --upgrade openai pillow
```

--------------------------------

### Install vLLM and Serve gpt-oss-safeguard-120b

Source: https://developers.openai.com/cookbook/articles/gpt-oss-safeguard-guide

Install vLLM version 0.10.2 with automatic torch backend selection, then start the server for the 120B model. This command downloads the model and starts the server.

```shell
uv pip install vllm==0.10.2 --torch-backend=auto

vllm serve openai/gpt-oss-safeguard-120b
```

--------------------------------

### Install Dependencies with pip

Source: https://developers.openai.com/cookbook/examples/agent_optimization/optimizing_agents_for_cost_and_quality

Install required packages for the agent optimization example. Use Python 3.10 or later and run from the example directory.

```bash
pip install --upgrade openai pandas matplotlib jinja2 ipykernel
```

--------------------------------

### Install the Ruby SDK

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Installs the openai gem required for the Ruby example.

```bash
gem install openai
```

--------------------------------

### Example Output: Vector Store Creation and Upload Start

Source: https://developers.openai.com/cookbook/examples/file_search_responses

Shows the printed output after creating the vector store and starting the upload process. The vector store ID and file count are displayed, followed by the number of PDF files to process.

```text
Vector store created: {'id': 'vs_67d06b9b9a9c8191bafd456cf2364ce3', 'name': 'openai_blog_store', 'created_at': 1741712283, 'file_count': 0}
21 PDF files to process. Uploading in parallel...
```

--------------------------------

### Get Example Code Files from OpenAI SDK

Source: https://developers.openai.com/cookbook/examples/evaluation/use-cases/responses-evaluation

Construct file paths to example code files within the OpenAI SDK installation for use in generating responses.

```python
openai_sdk_file_path = os.path.dirname(openai.__file__)

# Get some example code files from the OpenAI SDK 
file_paths   = [
    os.path.join(openai_sdk_file_path, "resources", "evals", "evals.py"),
    os.path.join(openai_sdk_file_path, "resources", "responses", "responses.py"),
    os.path.join(openai_sdk_file_path, "resources", "images.py"),
    os.path.join(openai_sdk_file_path, "resources", "embeddings.py"),
    os.path.join(openai_sdk_file_path, "resources", "files.py"),
]

print(file_paths[0])
```

--------------------------------

### Install dependencies with pip

Source: https://developers.openai.com/cookbook/examples/agents_sdk/computer_use_with_daytona/computer_use_with_daytona

Install the required Python packages from requirements.txt. Run this inside the example directory after cloning the cookbook.

```python
%pip install -r requirements.txt --quiet
```

--------------------------------

### Initialize notebook with prepare()

Source: https://developers.openai.com/cookbook/examples/partners/harness_aware_plugin_evals/harness_aware_plugin_evals

Loads .env and points Codex at this example. In live mode, also checks the API key, clears outputs/, writes the Codex config, and starts the server if needed.

```python
from notebook_setup import prepare, stop_server

RUN_LIVE = prepare()
```

--------------------------------

### Expected Output from Dependency Installation

Source: https://developers.openai.com/cookbook/examples/partners/temporal_agents_with_knowledge_graphs/temporal_agents

Example output showing Python version and pip installation status. You may need to restart the kernel after installation.

```text
Python 3.12.8
Requirement already satisfied: pip in ./.venv/lib/python3.12/site-packages (25.1.1)
Note: you may need to restart the kernel to use updated packages.
Note: you may need to restart the kernel to use updated packages.
Note: you may need to restart the kernel to use updated packages.
```

--------------------------------

### Run the Browser Translation Demo

Source: https://developers.openai.com/cookbook/examples/voice_solutions/realtime_translation_guide

Commands to install dependencies and start the complete browser translation demo. After running, open the local URL, choose a tab with audio, pick the target language, and start translation.

```shell
cd examples/voice_solutions/realtime_translation_guide/browser-translation-demo
npm install
npm run dev
```

--------------------------------

### Run gpt-oss Responses API server with Ollama backend

Source: https://developers.openai.com/cookbook/articles/gpt-oss/run-locally-ollama

Install the gpt-oss package and start the example Responses API server using Ollama as the inference backend with the gpt-oss:20b checkpoint. This is a basic example server, not a production-ready implementation.

```shell
pip install gpt-oss
python -m gpt_oss.responses_api.serve \
    --inference_backend=ollama \
    --checkpoint gpt-oss:20b
```

--------------------------------

### Sample system prompt with MCP server instructions and few-shot examples

Source: https://developers.openai.com/cookbook/examples/mcp/mcp_tool_guide

Use this system prompt to guide the model to select relevant MCP servers, ask clarifying questions for missing details, and limit catalog search results to 4 items. It includes few-shot examples for product search and documentation lookup.

```python
system_prompt= """You are an AI assistant that can call the following MCP servers:

1. allbirds_store
2. gitmcp

Steps
1. Use the MCP servers above to answer the user query, not every MCP server will relevant for a given query so you can choose which ones to invoke.  
2. If the user’s request lacks essential details (size, color, etc.), ask a follow-up question first rather than guessing and using the MCP server tool prematurely. 
3. If searching for products in a catalog, only return 4 results at a time before asking the user whether they want to see more. 

### Few-shot examples

# EX1 — Direct product search, then fetch variant details
user: Do you have the Allbirds Tree Runner in men’s size 10?  
assistant: {"name":"allbirds_store.search_shop_catalog",
            "arguments":{"query":"Tree Runner",
                         "context":"Men’s size 10 shoes"}}
# (assume the search returns product_id "gid://shopify/Product/987")  
assistant: {"name":"allbirds_store.get_product_details",
            "arguments":{"product_id":"gid://shopify/Product/987",
                         "options":{"Size":"10"}}}

# EX2 — Clarify missing size, then two-step color variant lookup
user: I want the Tree Runner in blue.  
assistant: Sure — what size do you need?  
user: Size 10.  
assistant: {"name":"allbirds_store.search_shop_catalog",
            "arguments":{"query":"Tree Runner",
                         "context":"Blue variant, size 10"}}
# (assume the search returns product_id "gid://shopify/Product/987")  
assistant: {"name":"allbirds_store.get_product_details",
            "arguments":{"product_id":"gid://shopify/Product/987",
                         "options":{"Size":"10","Color":"Blue"}}}

# EX3 — Git docs: search then fetch specific file
user: Can you show me how tiktoken does byte-pair encoding?  
assistant: {"name":"gitmcp.search_website_documentation",
            "arguments":{"query":"tiktoken byte-pair encoding"}}
# (assume the search returns document_id "docs/ENCODING.md")  
assistant: {"name":"gitmcp.fetch_website_documentation",
            "arguments":{"document_id":"docs/ENCODING.md"}} """
```

--------------------------------

### Run the credit example with node src/demo.mjs --unit credit

Source: https://developers.openai.com/cookbook/examples/chatgpt/daily_usage_limits/readme

Run from the extracted chatgpt-usage-budget-starter folder after installing Node.js 24 or later. The demo previews and applies the first release, advances to the next weekly release, and simulates an interrupted update and conflicting admin edit. A successful run ends with `Demo complete. All simulated state stayed in memory.`

```shell
node src/demo.mjs --unit credit
```

--------------------------------

### Run Go Quickstart Program

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Execute the Go quickstart program from your terminal.

```shell
go run .
```

--------------------------------

### Install optional dependencies for AWS credential-chain examples

Source: https://developers.openai.com/api/docs/guides/amazon-bedrock

Run these commands to install the required packages for using the AWS credential chain with the JavaScript, Python, Go, and Ruby SDKs.

```bash
npm install @aws-sdk/credential-provider-node @smithy/hash-node @smithy/signature-v4
pip install 'openai[bedrock]'
go get github.com/openai/openai-go/v3/bedrock
bundle add aws-sdk-core
```

--------------------------------

### Run the LiveKit translation demo

Source: https://developers.openai.com/cookbook/examples/voice_solutions/realtime_translation_guide

Navigate to the demo directory, install dependencies, and start the development server. Use the same meeting code in two browser windows to join the same LiveKit room.

```shell
cd examples/voice_solutions/realtime_translation_guide/livekit-translation-demo
pnpm install
pnpm dev
```

--------------------------------

### Install MCP SDK for stdio server

Source: https://developers.openai.com/api/docs/guides/agents-api/tools/mcp

Run these commands to create a virtual environment and install the MCP SDK version 1.26.0. This is required before starting a stdio MCP server.

```shell
python3 -m venv /workspace/mcp-demo
/workspace/mcp-demo/bin/python -m pip install 'mcp==1.26.0'
```

--------------------------------

### Install required packages

Source: https://developers.openai.com/cookbook/examples/responses_api/responses_api_tool_orchestration

Installs the Python packages needed for the cookbook: datasets, tqdm, pandas, pinecone, and openai. The command is commented out in the notebook but is required to run the example.

```python
#%pip install datasets tqdm pandas pinecone openai --quiet
```

--------------------------------

### Ask initial question in browser

Source: https://developers.openai.com/cookbook/examples/agents_api/apps/data_analyst/readme

Example question to ask the agent after opening the browser interface. Use this to start an investigation.

```text
Why did paid conversions drop last week?
```

--------------------------------

### Create virtual environment and install OCI CLI

Source: https://developers.openai.com/api/docs/guides/agents-api/environments/providers/oci

Run these commands to create a Python 3.14 virtual environment, activate it, and install the OCI CLI. Use this as the first step before installing the beta SDK.

```bash
uv venv --python 3.14
source .venv/bin/activate
uv pip install --upgrade oci-cli
```

--------------------------------

### Run Python Quickstart Script

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Execute the Python quickstart script from your terminal.

```shell
python quickstart.py
```

--------------------------------

### Initialize Promptfoo example with npx

Source: https://developers.openai.com/api/docs/guides/promptfoo-codex

Run this to set up the getting-started example using npx. Requires Node.js 22.22.0 or newer.

```shell
npx promptfoo@latest init --example getting-started
cd getting-started
```

--------------------------------

### Run JavaScript Quickstart Script

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Execute the JavaScript quickstart script from your terminal.

```shell
node quickstart.mjs
```

--------------------------------

### Lively guide voice description

Source: https://developers.openai.com/api/docs/guides/custom-voices

Example description for a bright, clear adult voice with slightly higher pitch and lightly textured timbre. Use as a starting point and listen to the result in your application.

```text
A bright, clear adult voice with a slightly higher pitch and a lightly textured timbre.
Use a lively, conversational delivery at a brisk but easy-to-follow pace.
```

--------------------------------

### Initialize Promptfoo example with pip

Source: https://developers.openai.com/api/docs/guides/promptfoo-codex

Run this to set up the getting-started example using pip. Requires an active Python 3.10+ virtual environment and Node.js 22.22.0 or newer.

```shell
pip install promptfoo
promptfoo init --example getting-started
cd getting-started
```

--------------------------------

### Set up Python environment and install dependencies

Source: https://developers.openai.com/cookbook/examples/deep_research_api/how_to_build_a_deep_research_mcp_server/readme

Create a virtual environment, activate it, and install required packages from requirements.txt. Run these commands in the project directory.

```bash
python3 -m venv env
source env/bin/activate
pip install -r requirements.txt
```

--------------------------------

### Initialize Go Module and Install OpenAI Go SDK

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Create a new Go module and install the OpenAI Go SDK v3.

```shell
go mod init agents-quickstart
go get github.com/openai/openai-go/v3@latest
```

--------------------------------

### Install Python dependencies with pip

Source: https://developers.openai.com/cookbook/examples/realtime_out_of_band_transcription

Installs sounddevice and websockets, which are required for the realtime transcription example.

```bash
pip install sounddevice websockets
```

--------------------------------

### Expose local server with ngrok

Source: https://developers.openai.com/cookbook/examples/deep_research_api/how_to_build_a_deep_research_mcp_server/readme

Install ngrok via Homebrew, configure your authtoken, and start a tunnel on port 8000 to make the local server reachable from the public internet.

```bash
brew install ngrok 
ngrok config add-authtoken <your_token>
ngrok http 8000
```

--------------------------------

### Setup OpenAI Client and Images Directory

Source: https://developers.openai.com/cookbook/examples/multimodal/image_evals

Run this once to create the API client and ensure the images/ directory exists.

```python
import os
from openai import OpenAI

client = OpenAI()

os.makedirs("../../images", exist_ok=True)
```

--------------------------------

### Setup cell: locate repository, import helpers, and verify tools

Source: https://developers.openai.com/cookbook/examples/partners/aws/chatgpt_agents_sdk_aws_agentcore_cookbook/notebooks/chatgpt_agents_sdk_aws_agentcore_cookbook

Run this cell from the cookbook repository or notebooks directory. It finds the repo root by checking for runtime-agent/pyproject.toml and mcp-adapter/package.json, imports notebook helpers, and raises an error if uv, Node.js, or npm are missing.

```python
import json
import os
import shutil
import sys
import urllib.request
from pathlib import Path

REPO_ROOT = next(
    (path for path in (Path.cwd(), *Path.cwd().parents)
     if (path / "runtime-agent" / "pyproject.toml").exists()
     and (path / "mcp-adapter" / "package.json").exists()),
    None,
)
if REPO_ROOT is None:
    raise RuntimeError("Run this notebook from the cookbook repository or notebooks directory.")
RUNTIME_DIR, MCP_DIR = REPO_ROOT / "runtime-agent", REPO_ROOT / "mcp-adapter"
sys.path.insert(0, str(RUNTIME_DIR))

from demo_date import demo_travel_date
from notebook_helpers import (
    live_runtime_environment, local_runtime_service, run,
    run_agent_evaluation, selected_environment,
)

DEMO_TRAVEL_DATE = demo_travel_date()
UV, NODE, NPM = (shutil.which(command) for command in ("uv", "node", "npm"))
if not UV or not NODE or not NPM:
    raise RuntimeError("Install uv and Node.js/npm before executing the notebook.")
print("Repository:", REPO_ROOT)
print("Commit:", run(["git", "rev-parse", "HEAD"], REPO_ROOT).stdout.strip())
for name, command in (("uv", UV), ("Node", NODE), ("npm", NPM)):
    print(name + ":", run([command, "--version"], REPO_ROOT).stdout.strip())

```

--------------------------------

### Get target name for first example

Source: https://developers.openai.com/cookbook/examples/fine-tuned_classification

Retrieves the category name corresponding to the first example's target label.

```python
sports_dataset.target_names[sports_dataset['target'][0]]
```

--------------------------------

### Run the desktop control sample

Source: https://developers.openai.com/api/docs/guides/tools-computer-use-integration

Run the sample script using Python or Node.js. The SDK selects the editor's text, types a fictional note, saves it, and captures the desktop. It independently reads the guest file and prints 'Verified: Dispatch #1042: ready for pickup.'

```shell
.venv/bin/python dispatch.py
# Or:
node dispatch.mjs
```

--------------------------------

### Form upload and server start output

Source: https://developers.openai.com/cookbook/examples/agents_sdk/computer_use_with_daytona/computer_use_with_daytona

Example output confirming the form was uploaded and the HTTP server started on port 8080.

```text
Form uploaded to /home/daytona/form/index.html
HTTP server started on port 8080
```

--------------------------------

### Initialize OpenAI client in JavaScript

Source: https://developers.openai.com/api/docs/guides/prompt-generation

JavaScript example importing the OpenAI SDK and creating a client instance.

```javascript
import OpenAI from "openai";

const client = new OpenAI();
```

--------------------------------

### Safety case response example

Source: https://developers.openai.com/api/reference/resources/safety/subresources/cases/methods/retrieve

Example response body returned by the get safety case endpoint, showing a warning notice with reason cyber_abuse.

```json
{
  "id": "C-abc123",
  "object": "safety.case",
  "created_at": 1787659200,
  "entity_identifier": "safety-id-123",
  "reason": "cyber_abuse",
  "notice": {"type": "warning"}
}
```

--------------------------------

### Certificate response example

Source: https://developers.openai.com/api/reference/resources/admin/subresources/organization/subresources/certificates/methods/retrieve

Example JSON response for the get certificate request, showing the certificate object with certificate_details including valid_at, expires_at, and content.

```json
{
  "object": "certificate",
  "id": "cert_abc",
  "name": "My Example Certificate",
  "created_at": 1234567,
  "certificate_details": {
    "valid_at": 1234567,
    "expires_at": 12345678,
    "content": "-----BEGIN CERTIFICATE-----MIIDeT...-----END CERTIFICATE-----"
  }
}
```

--------------------------------

### Run the Java example with Maven

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Command to compile and execute the Java example class AgentsApiSessionsStreamConversationExample.

```bash
mvn compile exec:java -Dexec.mainClass=AgentsApiSessionsStreamConversationExample
```

--------------------------------

### List ads response example

Source: https://developers.openai.com/ads/api-reference/ads

Example JSON response from GET /ads showing a list of ads with pagination fields first_id, last_id, and has_more.

```json
{
  "object": "list",
  "data": [
    {
      "id": "ad_501",
      "name": "Planner launch card",
      "created_at": 1735689800,
      "updated_at": 1735776200,
      "creative": {
        "type": "chat_card",
        "title": "Try the new workspace planner",
        "body": "Coordinate tasks, docs, and meetings in one place.",
        "file_id": "file_901",
        "image_url": "https://cdn.openai.com/ads/file_901.png",
        "target_url": "https://example.com/workspace-planner"
      },
      "status": "active",
      "review_status": "approved"
    }
  ],
  "first_id": "ad_501",
  "last_id": "ad_501",
  "has_more": false
}
```

--------------------------------

### Initialize project and install React, TypeScript, and esbuild

Source: https://developers.openai.com/plugins/build/chatgpt-ui

Run from the web/ directory. Node 18+ is recommended. Add any additional libraries (e.g., drag-and-drop, charts) now and keep dependencies lean to reduce bundle size.

```shell
cd plugin-ui/web
npm init -y
npm install react@^18 react-dom@^18
npm install -D typescript esbuild
```

--------------------------------

### Install TRL, PEFT, Transformers, and Trackio

Source: https://developers.openai.com/cookbook/articles/gpt-oss/fine-tune-transfomers

Installs the remaining dependencies with minimum version constraints. Run this after installing PyTorch.

```bash
%pip install "trl>=0.20.0" "peft>=0.17.0" "transformers>=4.55.0" trackio
```

--------------------------------

### Start the private MCP server with npm start

Source: https://developers.openai.com/cookbook/examples/partners/aws/chatgpt_agents_sdk_aws_agentcore_cookbook/notebooks/chatgpt_agents_sdk_aws_agentcore_cookbook

Run from the mcp-adapter/ directory to start the private MCP server, which listens on http://127.0.0.1:8787/mcp.

```shell
npm start
```

--------------------------------

### List campaigns response example

Source: https://developers.openai.com/ads/api-reference/campaigns

Example JSON response from GET /campaigns showing a paginated list with campaign fields such as id, status, budget, and targeting.

```json
{
  "object": "list",
  "data": [
    {
      "id": "cmpn_101",
      "created_at": 1735689600,
      "status": "active",
      "bidding_type": "impressions",
      "budget": {
        "lifetime_spend_limit_micros": 25000000
      },
      "conversion_event_setting_ids": [],
      "description": "Promote the new productivity bundle.",
      "end_time": 1738368000,
      "mode": null,
      "name": "Spring launch",
      "start_time": 1735689600,
      "targeting": {},
      "updated_at": 1735776000
    }
  ],
  "first_id": "cmpn_101",
  "last_id": "cmpn_101",
  "has_more": false
}
```

--------------------------------

### Set up imports and OpenAI client

Source: https://developers.openai.com/cookbook/examples/orchestrating_agents

Import OpenAI, Pydantic, and typing modules, then instantiate the OpenAI client. Use this as the initial setup before defining routines.

```python
from openai import OpenAI
from pydantic import BaseModel
from typing import Optional
import json


client = OpenAI()
```

--------------------------------

### Customize composer placeholder and start screen greeting

Source: https://developers.openai.com/api/docs/guides/chatkit-themes

Set the composer's placeholder text and the start screen greeting to guide users' first input.

```javascript
const options = {
  composer: {
    placeholder: "Ask anything about your data…",
  },
  startScreen: {
    greeting: "Welcome to FeedbackBot!",
  },
};
```

--------------------------------

### Initialize OpenAI Client and List PDF Files

Source: https://developers.openai.com/cookbook/examples/file_search_responses

Import necessary modules, create an OpenAI client using the API key from environment variable, and list PDF files from the 'openai_blog_pdfs' directory.

```python
from openai import OpenAI
from concurrent.futures import ThreadPoolExecutor
from tqdm import tqdm
import concurrent
import PyPDF2
import os
import pandas as pd
import base64

client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
dir_pdfs = 'openai_blog_pdfs' # have those PDFs stored locally here
pdf_files = [os.path.join(dir_pdfs, f) for f in os.listdir(dir_pdfs)]
```

--------------------------------

### Sample SKILL.md for setup-demo-app

Source: https://developers.openai.com/blog/eval-skills

Paste this into .codex/skills/setup-demo-app/SKILL.md (repo-scoped) or ~/.codex/skills/setup-demo-app/SKILL.md (user-scoped). It scaffolds a Vite React TypeScript app, configures Tailwind, and defines a minimal file structure and definition of done.

```markdown
---
name: setup-demo-app
description: Scaffold a Vite + React + Tailwind demo app with a small, consistent project structure.
---

## When to use this

Use when you need a fresh demo app for quick UI experiments or reproductions.

## What to build

Create a Vite React TypeScript app and configure Tailwind. Keep it minimal.

Project structure after setup:

- src/
  - main.tsx (entry)
  - App.tsx (root UI)
  - components/
    - Header.tsx
    - Card.tsx
  - index.css (Tailwind import)
- index.html
- package.json

Style requirements:

- TypeScript components
- Functional components only
- Tailwind classes for styling (no CSS modules)
- No extra UI libraries

## Steps

1. Scaffold with Vite using the React TS template:
   npm create vite@latest demo-app -- --template react-ts

2. Install dependencies:
   cd demo-app
   npm install

3. Install and configure Tailwind using the Vite plugin.
   - npm install tailwindcss @tailwindcss/vite
   - Add the tailwind plugin to vite.config.ts
   - In src/index.css, replace contents with:
     @import "tailwindcss";

4. Implement the minimal UI:
   - Header: app title and short subtitle
   - Card: reusable card container
   - App: render Header + 2 Cards with placeholder text

## Definition of done

- npm run dev starts successfully
- package.json exists
- src/components/Header.tsx and src/components/Card.tsx exist
```

--------------------------------

### Install OpenAI, OCI, and Requests Python packages

Source: https://developers.openai.com/api/docs/guides/workload-identity-federation/oracle-cloud

Run this pip command to install the Python dependencies required for the OCI instance principal token provider example.

```shell
pip install openai oci requests
```

--------------------------------

### Initialize Go module and install OpenAI Go SDK

Source: https://developers.openai.com/api/docs/guides/tools-computer-use-integration

Run these commands to initialize a Go module and install the pinned OpenAI Go SDK version v3.70.0. Use this if your project doesn't already have a Go module.

```shell
go mod init example.com/computer-use
go get github.com/openai/openai-go/v3@v3.70.0
```

--------------------------------

### Transcript delta event example

Source: https://developers.openai.com/api/docs/guides/live-conversations

Example payload for a session.input_transcript.delta event. Append delta fragments exactly as received and retain start_ms and end_ms, which are milliseconds from session start.

```json
{
  "type": "session.input_transcript.delta",
  "event_id": "event_transcript_1",
  "delta": "What is",
  "start_ms": 1000,
  "end_ms": 1200
}
```

--------------------------------

### Run a complete steering example in Java

Source: https://developers.openai.com/api/docs/guides/steering

Uses OpenAIOkHttpClient to connect, send a response create event, then steer the response with additional input. Handles events until the successor response completes and prints the output text.

```java
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.*;
import java.util.*;

long deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(120);
try (var conn =
    client.async().responses().connect().get(10, java.util.concurrent.TimeUnit.SECONDS)) {
  conn.send(
      ResponsesClientEvent.ofResponseCreate(
          ResponsesClientEvent.ResponseCreate.builder()
              .model("gpt-6-astra")
              .reasoning(
                  com.openai.models.Reasoning.builder()
                      .effort(com.openai.models.ReasoningEffort.MEDIUM)
                      .build())
              .store(false)
              .input("Draft a project plan for building a task-tracking app.")
              .build()));
  String initialId = null, successorId = null;
  while (true) {
    var event =
        conn.receive()
            .get(
                Math.max(1, deadline - System.nanoTime()),
                java.util.concurrent.TimeUnit.NANOSECONDS);
    if (event.responseCreated().isPresent()) {
      var id = event.responseCreated().orElseThrow().response().id();
      if (initialId == null) {
        initialId = id;
        conn.send(
            ResponsesClientEvent.ofResponseSteer(
                ResponseSteerEvent.builder()
                    .previousResponseId(id)
                    .input(
                        "Keep the scope small enough for one developer to finish in two weeks.")
                    .build()));
      } else {
        successorId = id;
      }
    } else if (event.responseSteerFailed().isPresent()
        || event.responseFailed().isPresent()
        || event.error().isPresent()) {
      throw new IllegalStateException(event.toString());
    } else if (event.responseIncomplete().isPresent()) {
      var response = event.responseIncomplete().orElseThrow().response();
      if (!response.id().equals(initialId)
          || !response
              .incompleteDetails()
              .flatMap(Response.IncompleteDetails::reason)
              .map(r -> r.toString().equals("steered"))
              .orElse(false)) throw new IllegalStateException(event.toString());
    } else if (event.responseCompleted().isPresent()
        && event.responseCompleted().orElseThrow().response().id().equals(successorId)) {
      event.responseCompleted().orElseThrow().response().output().stream()
          .flatMap(item -> item.message().stream())
          .flatMap(message -> message.content().stream())
          .flatMap(content -> content.outputText().stream())
          .forEach(text -> System.out.println(text.text()));
      break;
    }
    // Acceptance only queues input; follow the successor through completion.
  }
} finally {
  client.close();
}
```

--------------------------------

### Example skills/list response with resources and digests

Source: https://developers.openai.com/plugins/build/mcp-server

Each skill entry must include a `uri` pointing to `SKILL.md`, `frontmatter` with all parsed front matter entries, a complete `resources` list, and a SHA-256 digest per resource. Use the `skill://` URI convention; the directory containing `SKILL.md` must match the skill name.

```json
{
  "skills": [
    {
      "uri": "skill://dice-roller/tabletop-dice/SKILL.md",
      "frontmatter": {
        "name": "tabletop-dice",
        "description": "Roll one or more dice and report each result and the total."
      },
      "resources": [
        {
          "uri": "skill://dice-roller/tabletop-dice/SKILL.md",
          "digest": "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
        },
        {
          "uri": "skill://dice-roller/tabletop-dice/references/notation.md",
          "digest": "sha256:abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789"
        }
      ]
    }
  ],
  "nextCursor": "optional-next-page-cursor"
}
```

--------------------------------

### Get safety case with curl

Source: https://developers.openai.com/api/reference/resources/safety/subresources/cases/methods/retrieve

Send a GET request to /v1/safety/cases/{id} with a bearer token to retrieve a safety case. The example uses the case ID C-abc123.

```bash
curl https://api.openai.com/v1/safety/cases/C-abc123 \
  -H "Authorization: Bearer $OPENAI_API_KEY"
```

--------------------------------

### Start spiffe-helper with helper.conf

Source: https://developers.openai.com/api/docs/guides/workload-identity-federation/idira

Run this in the Kubernetes sidecar or VM service after creating the token directory and granting the helper write access. Keep the helper running so it replaces the token before it expires.

```bash
spiffe-helper -config helper.conf
```

--------------------------------

### Ad account metadata response example

Source: https://developers.openai.com/ads/api-reference/ad-account

Example JSON response from GET /ad_account. Optional fields legal_name, account_name, and brand_name default to the legal name when unset.

```json
{
  "id": "adacct_123",
  "name": "Acme LLC",
  "legal_name": "Acme LLC",
  "account_name": "Acme US campaigns",
  "brand_name": "Acme",
  "url": "https://www.acme.example",
  "preview_url": null,
  "status": "active",
  "timezone": "UTC",
  "currency_code": "USD",
  "review": {
    "status": "approved"
  }
}
```

--------------------------------

### Create and Run tree.py with Python SDK

Source: https://developers.openai.com/api/docs/guides/agents-api/quickstart

Use the Python SDK to create an agent session that writes and runs `tree.py`, streaming progress and printing the final output. Save as `quickstart.py` and run with `python quickstart.py`.

```python
from openai import OpenAI

with OpenAI() as client:
    with client.beta.agents.sessions.create(
        agent={
            "model": "gpt-6-astra",
            "instructions": "Write clean code, run it, and report the actual output.",
        },
        environment={"type": "openai_hosted"},
        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.",
        stream=True,
    ).with_result_collection() as stream:
        for event in stream:
            print(event.to_json(indent=None), flush=True)
        result = stream.get_final_result()
    print(result.output_text)
    session_id = result.session_id
```

--------------------------------

### session.delegation.created notification example

Source: https://developers.openai.com/api/docs/guides/live-migration

Example notification received when delegation is configured as {"type":"client"}. Use it to start your delegation handler and preserve delegation.id.

```json
{
  "type": "session.delegation.created",
  "offset_ms": 1000,
  "delegation": {
    "id": "item_appointment_1",
    "type": "delegation",
    "target": "client"
  }
}
```

--------------------------------

### Locate companion data and set up runs directory

Source: https://developers.openai.com/cookbook/examples/codex/build_iterative_repair_loops_with_codex

Finds the data/docs directory from candidate paths and creates a temporary output directory. Raises an error if the companion sample notebooks are missing.

```python
import concurrent.futures
import json
import os
import shlex
import shutil
import subprocess
import tempfile
from pathlib import Path
from typing import Any

CANDIDATE_EXAMPLE_DIRS = [Path("."), Path("examples/codex")]
EXAMPLE_DIR = next((base for base in CANDIDATE_EXAMPLE_DIRS if (base / "data" / "docs").exists()), None)

if EXAMPLE_DIR is None:
    raise RuntimeError(
        "This notebook needs its companion sample notebooks. "
        "Download the data folder that ships with this example and place it next to "
        "this notebook as ./data/docs, or run from a checkout where examples/codex/data/docs exists."
    )

DATA_DIR = EXAMPLE_DIR / "data" / "docs"
DEFAULT_RUNS_DIR = Path(tempfile.gettempdir()) / "codex_iterative_repair_loop_outputs"
RUNS_DIR = Path(os.getenv("CODEX_REPAIR_RUNS_DIR", str(DEFAULT_RUNS_DIR))).expanduser()
RUNS_DIR.mkdir(parents=True, exist_ok=True)
```

--------------------------------

### Create project returns example project object

Source: https://developers.openai.com/api/reference/resources/admin/subresources/organization/subresources/projects/methods/create

Example response body for the create-project endpoint, showing the project object fields returned after creation.

```json
{
    "id": "proj_abc",
    "object": "organization.project",
    "name": "Project ABC",
    "created_at": 1711471533,
    "archived_at": null,
    "status": "active"
}
```

--------------------------------

### GET /agents/environments/{environment_id}

Source: https://developers.openai.com/api/reference/resources/beta/subresources/agents/subresources/environments/methods/retrieve

Retrieves an execution environment's connection status and safe installed metadata. Use this endpoint to get information about a specific environment by providing its ID.

```APIDOC
## GET /agents/environments/{environment_id}

### Description
Retrieves an execution environment's connection status and safe installed metadata.

### Method
GET

### Endpoint
/agents/environments/{environment_id}

### Parameters
#### Path Parameters
- **environment_id** (string) - Required - The ID of the environment to retrieve. Minimum length: 0, maximum length: 1048576.

### Response
#### Success Response (200)
- **id** (string) - The ID of the environment.
- **files** (array of HostedEnvironmentFile) - Files installed in the environment, without their contents. Each file can be one of the following types:
  - **HostedEnvironmentFileID** object:
    - **id** (string) - The session-scoped ID of the file in the execution environment.
    - **file_id** (string) - The ID of the uploaded file.
    - **path** (string) - The file's absolute path inside the environment.
    - **size_bytes** (number) - The decoded file size in bytes.
    - **type** (string) - Always `file_id`.
  - **Inline object**:
    - **id** (string) - The session-scoped ID of the file in the execution environment.
    - **path** (string) - The file's absolute path inside the environment.
    - **size_bytes** (number) - The decoded file size in bytes.
    - **type** (string) - Always `inline`.
- **object** (string) - The object type.
- **4 more** - Additional fields not detailed in the source.

#### Response Example
{
  "id": "env_123",
  "files": [
    {
      "id": "file_abc",
      "file_id": "file_123",
      "path": "/home/user/file.txt",
      "size_bytes": 1024,
      "type": "file_id"
    },
    {
      "id": "file_def",
      "path": "/home/user/inline.txt",
      "size_bytes": 2048,
      "type": "inline"
    }
  ],
  "object": "environment"
}
```

--------------------------------

### Set up OpenAI client and asset directory for transparent image generation

Source: https://developers.openai.com/cookbook/examples/multimodal/transparent-image-assets-for-campaigns-and-presentations

Install the openai and pillow packages and set OPENAI_API_KEY before running. This snippet initializes the OpenAI client, selects the gpt-image-2.5-flare model, and creates the output directory for transparent image assets.

```python
import base64
import os
from pathlib import Path

from openai import OpenAI
from PIL import Image

if not os.getenv("OPENAI_API_KEY"):
    raise RuntimeError("Set OPENAI_API_KEY before running this notebook.")

IMAGE_MODEL = "gpt-image-2.5-flare"

client = OpenAI()
asset_dir = Path("images/transparent-image-assets")
asset_dir.mkdir(parents=True, exist_ok=True)
```

--------------------------------

### GET /ad_account response example

Source: https://developers.openai.com/ads/api-quickstart

Example response from the ad account endpoint showing the account id, name, URL, status, timezone, currency code, and review status.

```json
{
  "id": "adacct_123",
  "name": "Acme Ads",
  "url": "https://www.acme.example",
  "preview_url": null,
  "status": "active",
  "timezone": "UTC",
  "currency_code": "USD",
  "review": {
    "status": "approved"
  }
}
```

--------------------------------

### Plan and create a Python project with Go

Source: https://developers.openai.com/api/docs/guides/reasoning

Uses the OpenAI Go SDK to send a prompt asking the model to plan a directory structure and return each file in full. The prompt is sent as a user message.

```go
package main

import (
	"context"
	"fmt"

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

func main() {
	client := openai.NewClient()
	prompt := `I want to build a Python app that takes user questions and looks them up
in a database where they are mapped to answers. If there is a close match, it
retrieves the matched answer. If there is not, it asks the user to provide an
answer and stores the question/answer pair in the database. Make a plan for the
directory structure you will need, then return each file in full.`

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage(prompt),
		},
	})
	if err != nil {
		panic(err)
	}

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

--------------------------------

### Start Codex from terminal

Source: https://developers.openai.com/learn/developers-codex-plugin

Run this command in your terminal to launch Codex before installing the plugin.

```shell
codex
```

--------------------------------

### Install frontend-skill with $skill-installer in Codex

Source: https://developers.openai.com/blog/designing-delightful-frontends-with-gpt-5-4

Run this command inside the Codex app to install the frontend-skill. The skill then guides frontend generation using the design, copy, and motion rules on this page.

```shell
$skill-installer frontend-skill
```

--------------------------------

### Configure 500-credit weekly plan with fixed_release pattern

Source: https://developers.openai.com/cookbook/examples/chatgpt/daily_usage_limits/readme

Include these fields in the complete configuration created by the configuration and enrollment guide. Replace the example anchor with the start of your plan within the confirmed monthly period. startCap sets the first monthly limit; every 168 hours the controller adds increment up to ceiling, producing monthly limits of 500, 1000, 1500, and 2000 credits.

```json
{
  "unit": "credit",
  "policy": {
    "pattern": "fixed_release",
    "anchor": "2030-01-01T00:00:00Z",
    "intervalHours": 168,
    "startCap": "500",
    "increment": "500",
    "ceiling": "2000"
  }
}
```

--------------------------------

### Get embedding for a single string

Source: https://developers.openai.com/cookbook/examples/get_embeddings_from_dataset

Example of calling get_embedding with a short text to obtain its embedding vector.

```python
a = get_embedding("hi", model=embedding_model)
```

--------------------------------

### Initialize notebook environment, models, and artifact directories

Source: https://developers.openai.com/cookbook/examples/agents_sdk/agent_improvement_loop

Imports required libraries, locates the project root, validates OPENAI_API_KEY and npx, configures model choices via environment variables, and creates artifact directories. Running this cell prints the detected project root and model configuration.

```python
from __future__ import annotations

import asyncio
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import tempfile
import time
import textwrap
import threading
from contextlib import contextmanager
from dataclasses import asdict, dataclass, field
from datetime import datetime, timezone
from importlib.metadata import version
from pathlib import Path
from typing import Any, Iterable, Iterator, Mapping

from IPython.display import Markdown, display
from openai import OpenAI

def find_project_root(start: Path | None = None) -> Path:
    current = (start or Path.cwd()).resolve()
    for candidate in [current, *current.parents]:
        if (candidate / "registry.yaml").exists():
            return candidate
    return current


PROJECT_ROOT = find_project_root()

if not os.getenv("OPENAI_API_KEY"):
    raise RuntimeError("Set OPENAI_API_KEY before running this live notebook.")
if shutil.which("npx") is None:
    raise RuntimeError("Install Node.js with npx before running the Promptfoo eval gate.")

# Edit these in one place if you want to use lower-cost models for part of the loop.
AGENT_MODEL = os.getenv("OPENAI_AGENT_MODEL", "gpt-5.5")
ANALYSIS_MODEL = os.getenv("OPENAI_ANALYSIS_MODEL", "gpt-5.5")
EVAL_GENERATION_MODEL = os.getenv("OPENAI_EVAL_GENERATION_MODEL", ANALYSIS_MODEL)
JUDGE_MODEL = os.getenv("OPENAI_JUDGE_MODEL", ANALYSIS_MODEL)
HALO_MODEL = os.getenv("OPENAI_HALO_MODEL", ANALYSIS_MODEL)
PROMPTFOO_VERSION = os.getenv("PROMPTFOO_VERSION", "0.121.9")

client = OpenAI()


def format_duration(seconds: float) -> str:
    minutes, remainder = divmod(int(round(seconds)), 60)
    return f"{minutes}m {remainder:02d}s" if minutes else f"{remainder}s"


ARTIFACT_DIR = PROJECT_ROOT / "examples" / "agents_sdk" / "agent_improvement_loop_artifacts"
TRACE_DIR = ARTIFACT_DIR / "traces"
HALO_TRACE_PATH = ARTIFACT_DIR / "halo_traces" / "traces.jsonl"
if ARTIFACT_DIR.exists():
    shutil.rmtree(ARTIFACT_DIR)
ARTIFACT_DIR.mkdir(exist_ok=True)
TRACE_DIR.mkdir(exist_ok=True)
HALO_TRACE_PATH.parent.mkdir(exist_ok=True)

print("Project root detected.")
print("Models:", {
    "agent": AGENT_MODEL,
    "analysis": ANALYSIS_MODEL,
    "eval_generation": EVAL_GENERATION_MODEL,
    "judge": JUDGE_MODEL,
    "halo": HALO_MODEL,
    "promptfoo": PROMPTFOO_VERSION,
})
```

--------------------------------

### Run a complete steering example in Ruby

Source: https://developers.openai.com/api/docs/guides/steering

Uses the OpenAI Ruby client with async to connect, create a response, steer it, and process events until the steered response completes. Prints the output text and raises on errors or incomplete responses.

```ruby
require "async"
require "openai"

client = OpenAI::Client.new
Sync do |task|
  task.with_timeout(120) do
    client.responses.connect(request_options: { timeout: 10 }) do |connection|
      connection.response.create(
        model: "gpt-6-astra", reasoning: { effort: "medium" },
        input: "Draft a project plan for building a task-tracking app."
      )
      state = {}
      while (event = connection.receive)
        case event
        when OpenAI::Responses::ResponseCreatedEvent
          response = event.response
          if !state[:initial_id]
            state[:initial_id] = response.id
            connection.send_event(
              type: "response.steer", previous_response_id: state[:initial_id],
              input: "Keep the scope small enough for one developer to finish in two weeks."
            )
          else
            state[:successor_id] = response.id
          end
        when OpenAI::Responses::ResponseSteerFailedEvent, OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponsesServerEvent::ResponseWsError
          raise "Steering failed: #{event.to_json}"
        when OpenAI::Responses::ResponseIncompleteEvent
          response = event.response
          unless response.id == state[:initial_id] && response.incomplete_details&.reason.to_s == "steered"
            raise "Response incomplete: #{event.to_json}"
          end
        when OpenAI::Responses::ResponseCompletedEvent
          response = event.response
          next unless state[:successor_id] && response.id == state[:successor_id]

          puts(response.output_text)
          state[:completed] = true
          break
        end
      end
      raise "Connection closed before the steered response finished" unless state[:completed]
    end
  end
end
```

--------------------------------

### Output preview of fact-checking long text

Source: https://developers.openai.com/cookbook/articles/gpt-oss/build-your-own-fact-checker-cerebras

Shows the printed output from the example, indicating the start of fact-checking a longer text.

```text
Fact-checking the following longer text:

```

--------------------------------

### GET /v1/agents/sessions

Source: https://developers.openai.com/api/reference/resources/beta/subresources/agents/subresources/sessions/methods/list

Lists agent sessions. The response includes an array of session objects, each containing an environment with installed skills.

```APIDOC
## GET /v1/agents/sessions

### Description
Retrieves a list of agent sessions. Each session includes details about the environment and the skills installed in that environment.

### Method
GET

### Endpoint
/v1/agents/sessions

### Parameters
No parameters documented.

### Response
#### Success Response (200)
- **data** (array) - Array of agent session objects.
  - **id** (string) - Unique identifier for the session.
  - **environment** (object) - The environment configuration for the session.
    - **skills** (array) - Skills installed in the environment, excluding their archive contents.
      - Each skill is one of:
        - **HostedSkillReference** object:
          - **description** (string) - The installed skill description.
          - **name** (string) - The installed skill name.
          - **skill_id** (string) - The referenced skill ID.
          - **type** (string) - Always `skill_reference`.
          - **version** (string) - The concrete skill version installed for this session.
        - **Inline object**:
          - **description** (string) - The installed skill description.
          - **name** (string) - The installed skill name.
          - **type** (string) - Always `inline`.

#### Response Example
{
  "data": [
    {
      "id": "sess_123",
      "environment": {
        "skills": [
          {
            "description": "A skill for data analysis",
            "name": "Data Analysis",
            "skill_id": "skill_abc",
            "type": "skill_reference",
            "version": "1.0.0"
          },
          {
            "description": "A custom skill",
            "name": "Custom Skill",
            "type": "inline"
          }
        ]
      }
    }
  ]
}
```
Tokens:
Raw